Teparap

NOT OPEN YETPRESEASONLIVE The game has not opened and the $TPRP token does not exist yet.The game is open. The $TPRP token is not set yet, so nights run on play alone.The game is open and the $TPRP token is set.

How a night is decided

Teparap is a browser game on Solana where holding the token is taking part. This page describes the rules as the engine file states them and shows where each result can be checked. If this page and the engine ever disagree, the engine is right.

The numbers below are the engine's own, read again from /engine/v1.js when this page loads.

The land as every season opens, cut from the engine's own map.

What it is

Every Solana address already belongs to one of four sides: Wick, Fern, Tide and Rook. Every night at 00:00 UTC the sides fight over one shared map of 64 hex tiles. Two things make a side strong: how long its members have held the token, and how well its signed-in members played that day's run.

The weakest side that night loses 1 to 4 tiles to the strongest. After 28 nights the side with the most land takes the season banner, and the map is split evenly again.

No wallet is needed to look. Paste any address on its page to see its side, and from launch its days held, ranks and titles.

There are no cash prizes, NFTs, staking or lockups. Nothing moves between players and nobody can lose tokens in a night.

Sides come from addresses

side = SHA-256("faction-v1" || the address's 32 bytes)[0] mod 4

The program, the server, the indexer and your browser all use this line, factionOf in the engine file. Nobody picks a side and it never changes.

To be in another side you need another address, and an address that is new to the token starts its days held from zero. Making addresses until one lands in the side you like is allowed; the cost is the days you had.

The answer is computed here, with nothing sent anywhere.

The daily run

  • 5 terraces, one wall. Tap a terrace, or press 1 to 5, to loose a quarrel: it hits the nearest night thing in that terrace.
  • The quiver holds 5 quarrels and refills one every 0.27 s. A tap on an empty terrace is a miss and breaks your combo.
  • Space, or the pitch key, pours a pot of pitch: it burns every night thing in the nearer 45% of the field. You earn one pot per 15 quarrel kills and hold 2 at most. Kills by pitch earn no pot.
  • Four night things: the Scuttler is fast, the Murkling plain, the Ram takes 3 hits and strikes the wall for 2, and the Moth hops terraces every 24 to 39 ticks.
  • The wall holds 10. When it breaks, the run ends. Waves never stop getting harder (6% faster every wave, more of them, in pairs from wave 3 and threes from wave 7), so there is no top score.
  • Score: points per kill (Scuttler and Murkling 10, Moth 25, Ram 30, plus 2 per Ram hit) times your multiplier (1 + combo ÷ 8), 5 more for a kill near the wall, and a bonus of 25 × wave for a wave that ends with no breach.
The night things, live from the engine's rules
NameEngine kindSpeed at wave 1HitsWall damagePoints

Everyone gets the same night: the kinds, terraces and timings of the night things come from the day's seed and never from what you do. That is what makes any run replayable by anyone.

Practice is unlimited. One official run per address per day counts, if it is finished before that night is resolved just after 00:00 UTC; a run finished later stays on the board but is not part of the night. Guests with no wallet get one per device per day on the nickname board. Signing in is a free message from the wallet, never a transaction.

What counts toward a side

A signed run counts for its player's side when it passes the human-input rules and, once the token exists, when the address's lowest balance during the previous day was at least the minimum. The balance at the moment you start does not matter, so buying just before a run and selling after does nothing. Each side's play power is the sum of its best 100 counted runs that day, so a small side can beat a big one on skill.

Human-input rules

Part of the engine, applied to every run, with no manual removal. A run is not counted when it has:

  • more than 14 inputs inside any one second;
  • more than 60% of the gaps between inputs being exactly the same length (runs with 40 or more inputs);
  • 12 or more hits landing one tick (33 ms) after the target appeared or hopped, making 40% or more of all hits;
  • a finish submitted faster than the run lasted, or more than 10 minutes after it should have ended (checked by the run server).

The seed is public, so a day can be practised, or solved by a program, before playing it. These rules and the best-100 cap make that less useful; they do not make it impossible.

The night

Night n closes day n. It is resolved with the seed of day n + 1, which opens at the boundary, so nobody knows the night's randomness during the day.

  1. Power. power = 50 × holding share + 50 × play share, each share out of the four sides' total. Until the token is set, holding power is zero for every side, so play decides.
  2. Land. land = √(16 ÷ tiles held). A big territory has a long border to guard, so every extra tile thins it.
  3. Seed. Each side draws a coefficient between 0.6 and 1.4 from the night's seed.
  4. Roll. roll = power × land × coefficient. The lowest roll is hit, the two lowest on a big night (one night in 4). The highest roll takes the tiles.
  5. Tiles. The hit side loses 1 + floor(4 × (top roll − its roll) ÷ top roll) tiles, at most 4, never going under 4 tiles. Tiles touching the winner go first, in the order of SHA-256(seed, "tile", tile number). A tile with a beacon is skipped.
  6. Season. After 28 nights the side with the most land takes the season banner. Every member who held through the whole season keeps the banner on their address page. The map is split evenly again.

All arithmetic is integer (fixed point, 10⁹), so every computer gets the same night. Every night page shows each of these numbers, and any night can be recomputed in your browser.

The recorded mock-season test ran 1,000 simulated seasons with holding shares fixed at 40/25/20/15 and equal play: the weakest side was hit on 36.8% of nights, the land leader changed in 57.4% of seasons, and the map never stood still (docs/season-sim.md, engine v1). With equal play the largest holder side takes nearly every banner; play is what changes that. /rules runs the same test again in your browser.

Simulation, not a real season. The first season of the mock-season test, resolved night by night by the engine in your browser: seeds SHA-256("season-sim:0:night"), holding shares fixed at 40/25/20/15, equal play.

Holding power, and why buying late does not help

Holding power begins when the token is set. Until then nights run on play alone, and this is how holding will count.

  • A day counts only the lowest balance an address had that day.
  • Tokens arrive in lots. Selling or sending takes from the newest lot first, so selling part keeps the age of what you kept.
  • Token-days = for each lot, amount × days held (each lot counts up to 90 days), over the oldest lots that fit inside the day's lowest balance.
  • Days held grows by one every day the lowest balance stays at or above the minimum, and restarts at zero below it.
  • A side's holding power is the sum of its members' token-days. Splitting one balance across many addresses adds nothing.
  • Not counted: program-owned accounts (pools, LP, bonding curves), the burn address, and the listed team, treasury, house and exchange addresses, published on /rules with reasons and fixed for the whole season. Team wallets appear on boards marked Team and add no power.
held at dawnthe low pointbought just before nightwhat the day counts00:0024:00
An address counts its lowest balance of the day, however much it bought late.

Titles

Titles come only from public records: Held 7, 30, 100 and 365 days; Day 1 (held without a break since the token's first full day; on launch day itself everyone's lowest balance is zero, because nobody held when that day began); Night defender (inside your side's counted best 100); First night; Season banner; Beacon nights.

Beacons

A member can burn tokens to light a beacon on one of their side's tiles. That tile cannot be taken that night. Each side may light a limited number of beacons a night, before the night's cut-off, and none on the first night of a season, when the map is dealt again. The burn is done by our program, recorded on chain, and listed on /burnsthe beacons page with its transaction. A beacon gives no rank and no score.

How anyone can check

The engine

Every rule lives in one plain file, /engine/v1.js, run alike in your browser and on our servers. Its SHA-256 is the rules version. /engine shows the file and its hash, and compares it with the one our program registered.

SHA-256 in your browser: working…

A run

A run is its seed and its list of inputs. simulate(seed, inputs) plays it again and must land on the same score. Every run on a night page links to its replay. Today's runs of the engine playing by itself, re-run here:

working…

A night

/verify/night/n replays every official run of the day, recomputes play power, holding power, the roll and the map, and compares the roots with the published record and with the night committed on chain.

working…

The seed

Each day's seed opens at 00:00 UTC. /day/n shows its slot, its value and how it was opened, and rebuilds it from Solana in your browser.

working…

A holder

/verify/holder rebuilds an address's lots from the chain through a public RPC in your browser and compares them with the published table and its Merkle root.

Before the program is on mainnet

Our program is not on mainnet yet. Until it is, each day uses a practice seed anyone can rebuild: SHA-256("teparap-practice-v1" || blockhash of the first mainnet block at or after 00:00 UTC). Pages that show it say so. Nights in this period are recomputable but not anchored on chain.

Where each part runs
PartWhereHow to check it
SidesAnywhere, from the addressfactionOf in the engine file
The runYour browser, then replayed by the run serversimulate(seed, inputs) on /replay
Holding powerThe indexer, from the token's transfers/verify/holder against the published root
The nightResolved by the server from public inputs, recorded on Solana by our program/verify/night/n
The seedOur program, from Solana's SlotHashesA mainnet blockhash (practice seed)/day/n
BeaconsA burn on Solana by our programThe burn transaction

API

Everything on the site comes from a public JSON API on the same address. No key is needed. Big integers (token amounts, token-days, rolls) are strings. Limits a minute per address: 240 reads, 30 writes, and 600 calls to the read-only RPC relay. Night, day and run numbers count from 0, so night 0 is the first night.

Reads (open any of them)
PathWhat it returns
/api/healthState, today's game day, the engine hash, the last opened day and resolved night, queues and the indexer's lag
/api/configThe public switches: state, token mint, program id, cluster, day zero
/engine/v1.jsThe rules engine byte for byte, with its SHA-256 in the x-engine-sha256 header
/api/day/today, /api/day/nA day's seed: value, source, slot, attempt, blockhash or opening transaction
/api/attractThe engine playing today's waves by itself, with its inputs
/api/nightsEvery night with its status, summary, map hash and commit
/api/night/n, /data/nights/n.jsonOne night's full record: every input, every number of the result, the roots
/data/holders/n.jsonThe holder table of a night and its Merkle root
/api/mapToday's map: 64 side ids
/api/seasonsEvery season's nights, maps and banner
/api/rulesEvery engine constant, the excluded addresses and their hash
/api/leaderboardBoards: board=defenders|guests with span=day|week|season, or longest|tokendays
/api/address/addressAn address: side, runs, ranks and titles
/api/run/idOne run with its inputs, ready to replay
/api/programOur program: deployed or not, its keys, and its accounts read from chain
/api/burnsBeacon burns with their transactions
/api/sponsorSponsor price, approval window, deposits and weeks

Writes need a signed-in session (an HttpOnly cookie set after the wallet signs a free message) or a run ticket: POST /api/auth/nonce, /api/auth/verify, /api/auth/logout, /api/profile, /api/run/start and /api/run/finish. POST /api/rpc is a read-only relay of a few Solana methods for browsers; a check that used it says "not independent".

Token

$TPRP on Solana. Holding it is how you take part; burning it lights beacons. No staking, no lockups, nothing is paid out to players, and no player can lose tokens in a night.

The token is not set yet. Its supply, its mint address and any unlock schedule are published on this page at launch. There is no team unlock schedule today.

Reading the mint from Solana…

There is no team unlock schedule.

Nothing in the game locks tokens. Holding power only reads how long tokens have been held.

Next

  • Our Solana program on mainnet. It registers the engine file's hash, opens each day's seed from SlotHashes, records every night's inputs and result, burns tokens for beacons and holds sponsor deposits. It is built and tested on a local validator; deployment comes first.
  • The token. Holding power, holder tables, ranks, titles and beacons begin with it.
  • Season banners on address share cards once the first season ends.
  • New rules versions only through a new registered engine hash, applied from the next day.

What is thin today: the run and the night rules are finished and checkable from the engine file, but a side's play power depends on how many people sign runs, and nothing is on chain until our program is deployed.