Moksha samples

Small games built on the Moksha engine, each in its own folder with its own executable. They show how a game uses the engine and serve as the engine's test harness.

Website: mokshaengine.com

Sample	Executable	Shows
ui_demo/	Sample_UIDemo	UI widgets (panels, labels, images, a button), text, input
net_test/	Sample_NetTest	Networking against Samples_Server: connect, ping, synced scores, high score, timed quiz
evolution/	Sample_Evolution	Environment simulation: Perlin-noise terrain, thousands of creatures as instanced atlas sprites, physics colliders; WASD moves the camera
survivors/	Sample_Survivors	Arena stress test: growing enemy waves (pooled, instanced), auto-fired bullets, layered collision, overlapping SFX; WASD moves. Art: Kenney's Tiny Dungeon (CC0); sounds are procedurally generated
systems_check/	Sample_SystemsCheck	The engine's non-graphics systems, each logged as PASS/FAIL/SKIP: config, time, timers, files, random, physics, network, input, audio. Draws nothing, so it runs first on a new platform
rally/	Sample_Rally	Two-player paddle ball over the network (portrait, one paddle per phone): Samples_Server runs the match, clients send their paddle and draw the server's state. Sample_Rally_Headless is a bot that plays until a second human joins
graphics_stress/	Sample_GraphicsStress	Rendering stress test and demo (portrait, runs on iPhone): a turning spiral galaxy, with buttons that raise each render path's load (instances, moving instances, overdraw, UI panels, UI text) until the frame rate drops; 1,000 plain sprites add draw calls. Textures are procedurally generated
particle_life/	Sample_ParticleLife	CPU simulation load test (landscape): Particle Life, where six colours of particles attract and repel each other by random rules and form cells, chains and swarms that glow where they crowd (additive instanced sprites). - and + step from 1,000 to 100,000 particles; the headless twin is a CPU benchmark. The texture is procedurally generated
prism_drop/	Sample_PrismDrop	Falling block puzzle (portrait, iPhone and web): seven-piece bag, rotation kicks, hold, ghost, T-spins, combos; particles, eased piece motion, row collapse, screen shake, popups and looping music. The title screen plays itself. Art, sounds and music are procedurally generated

Also built: Samples_Server (server/, the net test's and the rally's server, with a SQLite high-score table) and Samples_Tests (tests/). shared/ holds the code both sides use (the samples' messages, the rally rules).

To try the net test, start Samples_Server, then one or two Sample_NetTest windows. Point them at another machine with --serverIP=<ip> (and --serverPort=<port>).

Systems check

Sample_SystemsCheck_Headless runs the automatic checks, logs a SYSTEMS CHECK report after 4 seconds and quits. Start Samples_Server first, or the network check fails. Compare the random checksum line across platforms: it must match. The windowed Sample_SystemsCheck also logs key presses and mouse clicks, beeps at start and on Space, and quits on Escape.

Load test

Sample_NetTest_Headless is the net test without a window, playing as a bot: it scores, chats, answers the quiz, measures ping round trips, and with --duration=<s> logs a BOT SUMMARY line and quits. To run many at once:

bash tools/load_test.sh <path to Sample_NetTest_Headless> <server-ip> [bots=20] [seconds=60]

On Linux (e.g. a Raspberry Pi) the headless bot and the server build without a GPU: cmake --preset pinned -DCMAKE_BUILD_TYPE=Release, then build Samples_Server and Sample_NetTest_Headless.

Building

Requires CMake 3.31+ and a C++20 compiler. On Windows the cook also needs dxc on PATH.

cmake --preset pinned
cmake --build --preset pinned

pinned builds the engine commit set in MOKSHA_PIN (root CMakeLists.txt), fetched from GitHub.

Working on the engine at the same time

Clone the engine next to this repo (<Projects>/moksha/moksha beside <Projects>/moksha_samples/moksha_samples) and add a CMakeUserPresets.json (gitignored) with a live preset:

{
    "version": 6,
    "configurePresets": [
        {
            "name": "live",
            "binaryDir": "${sourceDir}/build-live",
            "cacheVariables": { "FETCHCONTENT_SOURCE_DIR_MOKSHA": "${sourceDir}/../../moksha/moksha" }
        }
    ],
    "buildPresets": [ { "name": "live", "configurePreset": "live" } ]
}

cmake --preset live then builds your local engine clone, so engine edits show up on the next build. It warns when MOKSHA_PIN is behind the clone. Push the engine first, then bump the pin. Open moksha_samples.code-workspace to have both repos in one VS Code window.

Executables run from their build folder; their cooked resources/ folder sits next to them.

License

MIT, see LICENSE.