Otters Civ. Revived

Unofficial reference for the Fabric mod Otters Civ. Revived. Codename (team / repo): Project OOGA. Technical mod id: project_ooga (changed from fpsmod to avoid mod ID conflict with standalone FPS overlay mod). Repository title: Minecraft Civ Remixed.

Otters Civ. Revived (codename: Project OOGA) is a Fabric mod that keeps SQLite-backed world state, adds slash commands you type in normal Minecraft chat, ships a spawnable in-game handbook via /guide, shows join system messages (full onboarding the first time you connect to that save, a shorter welcome back ~ line when you’ve been there before), pays you for configured mining and combat actions (see rewards.json), and ships a server-authoritative jobs + guilds layer with client extras like the jobs HUD and guild map overlay. Long-term design: shops, social tools, governance, and scale hardening—see Target feature set.

Features (current build)

Shipped today: SQLite-backed economy, transfers and admin econ tools, join tips, configurable mining/kill payouts, a configurable 5-job starter pack with HUD controls, and guilds with claims/protection.

Target feature set (design goals)

Plain picture: one economy everyone trusts, guilds that own land together, jobs that change how you earn—not just the passive mining/kill loop you have now.

Below is the intended scope of Otters Civ. Revived: a civ-style multiplayer layer on Fabric. Ship order and detail follow the repo roadmap; this is not a commitment timeline. Group territory is framed as guilds (faction-like mechanics without using “factions” as the product label).

Requirements & install stack

Match these pins to avoid “works on my machine.” Source builds: read gradle.properties; downloads: trust the release page or Modrinth slice for that jar.

Align versions with the repository’s Gradle pins when building from source; for downloaded JARs, match the Modrinth or release notes for that build.

Install note: Put the mod on the machine that hosts the world (single-player = your own game; multiplayer = the host’s mods folder). Players only need the client JAR if they want the jobs HUD overlay or /otter GUI extras—money and commands still run from the world host. No separate database server is required; the jar bundles its SQLite runtime and auto-creates project_ooga.db on first start.

Slash commands (in-game chat)

Simple explanation: Press your chat key (often T), type a line that starts with / (for example /money), press Enter. That works while you are playing inside a world—single-player or multiplayer. You are not using a separate “server program” window; “server” in modding just means the part of Minecraft that remembers money and runs the command.

Try /guide first if you want the in-game handbook item, or /otter if you want the live civ hub menu. On a client with this mod installed, /otter opens a stylized in-game menu (tabbed: Home · Wallet · Jobs · Guilds · Shop · Rewards · Brief · Civ · Help) with one-click buttons to run /money, preview the jobs HUD, join a job, run guild actions, browse/buy/sell in the player-shop market, or open config files. Brief is the in-game mirror of the whitepaper Phases 0–3 and roadmap M0–M3; Civ shows M0–M6 milestone cards. Use the footer Theme chip to cycle color palettes (Otter, Midnight, Sunset, Mint); the choice persists in config/project_ooga/otter_ui.properties. On vanilla clients it prints a short chat help list instead.

Players also see automatic system messages when they connect (not a slash command). The first time your account is seen on this world save, you get three lines: Otters Civ. Revived branding, /guide, /otter, /money, and a pointer to passive rewards / rewards.json. Later joins get a gold/aqua welcome back ~name line and a condensed command reminder—stored per save as project_ooga:join_attendance (overworld saved data), separate from the main SQLite store and JSON config files.

/otter

No arguments. Vanilla / server-only client: prints a compact chat command list (same lines as in-game help) plus short tips for the mod hub, join messages, and the live handbook. Mod client: opens the tabbed civ hub (Home · Wallet · Jobs · Guilds · Shop · Rewards · Brief · Civ · Help) with quick actions, jobs HUD preview, guild buttons, the player-shop market (Browse / Mine / Sell), optional config opens, and the footer Theme chip. Brief condenses DOCS/whitepaper.md Phases 0–3 and DOCS/ROADMAP.md M0–M3; Civ lists M0–M6 cards. Home adds Minecraft + mod version, local vs multiplayer session hint, your current chunk and claim name (when the server has synced claims), richer wallet/guild cards, a /guide shortcut, and a live sync snapshot (claim count · jobs in catalog).

/guide

Gives you a written Otters Civ. handbook item with the current basics for money, jobs, guilds, and config locations. Requires a free inventory slot.

/guide give <player>

Gamemaster-only. Gives the handbook to another player; if their inventory is full it drops at their feet instead.

/money

You must be a player in the world (same as vanilla chat commands). Prints your balance.

/money set <player> <amount>

Replace that player’s saved balance with amount (≥ 0). Requires Minecraft gamemaster-level command permission (OP-equivalent for cheat-style commands)—see below.

/money add <player> <amount>

Add amount to that player’s balance (additive, clamped to Long.MAX_VALUE). Gamemaster-only. Logged to the SQLite wallet_ledger table with reason ADMIN_ADD.

/money take <player> <amount>

Deduct up to amount from that player’s balance (clamped to 0, never goes negative). Gamemaster-only. Logged to wallet_ledger with reason ADMIN_TAKE.

/pay <player> <amount>

Transfer amount coins from your wallet to another player. Available to all players in the world. Transfer is atomic—either both balances update or neither does. Server-enforced policy from config/otters_civ_revived/economy.json: minTransferAmount, maxTransferPerCommand (default 100,000; 0 disables), optional allowSelfPay, transferCooldownSeconds (default 3; 0 disables), and optional transferFlatFee (default 0). Fails with clear feedback on insufficient funds, oversized amount, active cooldown, or receiver max-balance limits. Both sides are logged to the SQLite wallet_ledger table (PLAYER_PAY_SENT / PLAYER_PAY_RECEIVED); the fee, if any, is logged as a separate PLAYER_PAY_FEE entry on the sender.

/economy reload

Re-read config/otters_civ_revived/economy.json in place — caps, cooldowns, and the flat fee take effect immediately without a restart. Gamemaster-only. Prints the active values back to chat for confirmation.

/economy log [count]

Tail the most recent ledger entries server-wide, newest first. count defaults to 10 and is capped at 50. Each line shows age, reason code, signed delta, post-balance, and any note. Gamemaster-only.

/economy log player <player> [count]

Filter the ledger to a single online player. Gamemaster-only.

/job, /job list, /job info <id>, /job join <id>, /job leave [id], /job stats

Operate on the live server job catalog defined in jobs.json. Depending on the server's activation policy, you can have one active job or multiple active jobs at once. Reward chat is split into a money line (+N coins) and separate job XP/progress lines whenever one of your active jobs matches the gameplay event. The HUD uses the server-synced primary active job for its label/icon/level display.

/guild create <name>

Create a new guild. Costs $250 from your wallet. Name: 3–24 chars, alphanumeric + underscores.

/guild invite <player>

Invite a player to your guild (officer+). They accept with /guild join; open guilds can also be joined directly with /guild join <name>.

/guild leave, /guild kick <player>

Leave or kick. Owners use /guild disband instead of leave.

/guild promote <player>, /guild demote <player>

Owner-only. Promote/demote between member and officer rank. Officers can invite and claim land.

/guild claim, /guild unclaim

Claim or unclaim the chunk you stand in ($100 per claim, max 16 per guild). Officer+.

/guild map

Shows an ASCII chunk-claim map in chat (9×9 grid, radius 4). Also toggles a 30-second client GUI overlay in the top-right: surface tint per chunk, green vs amber for your guild vs others, a yaw-facing wedge on your cell, and a hotbar-style line when you walk into a different claim.

/guild sethome, /guild home

Set guild teleport point (officer+) and teleport to it (any member). Cooldown is operator-tunable in guilds.json.

/guild open, /guild close

Owner-only. Toggle between public joining and invite-only mode when open guilds are allowed in guilds.json.

/guild info, /guild list

Show your guild details or list all guilds on the server.

/guild disband

Owner-only. Dissolves the guild and refunds claim costs.

/guild reload

Gamemaster-only. Reloads guilds.json config.

/shop sell <count> <price> [stock]

List the plain item in your main hand (no enchants/custom name/damage). count = items per bundle, price = coins per bundle, stock = number of bundles (default 1). The items are taken from your inventory when the listing is created; an optional listingCreationFee sink may apply.

/shop buy <id> [units]

Buy units bundles from a listing (accepts a full UUID or a unique short-id prefix). Rollback-safe: stock is reserved via an atomic guarded-UPDATE before any coins move, so a failed reservation leaves you untouched. Buyer pays price × units; the seller receives that minus a configurable basis-point sales tax (a pure sink).

/shop list [page], /shop mine, /shop info <id>

Browse the open market (paginated), list your own listings, or show one listing's item/price/stock/tax detail.

/shop restock <id> <units>, /shop close <id>

Owner-only. Restock adds bundles from your inventory (reopens a sold-out listing); close marks the listing closed and returns any unsold stock to you. All shop money movements are audited as SHOP_PURCHASE / SHOP_SALE / SHOP_TAX / SHOP_LISTING_FEE ledger entries (see /economy log). Policy in config/otters_civ_revived/shops.json.

/ooga db status, /ooga db migrate

Gamemaster-only database administration: inspect schema version / DB path or run pending migrations.

Who can run which command (today)

Open to players: /guide, /otter, /money with no arguments, /pay <player> <amount>, the self-service /job set (/job, /job list, /job info <id>, /job join <id>, /job leave [id], /job stats), and most /guild commands. Passive mining/kill payouts have no slash command—they follow rewards.json plus optional block_values.json / entity_values.json (merged at startup).

Role-gated inside guilds: officers handle invites, claims, and guild-home setting; owners handle promotions, ownership transfer, disband, and public/invite-only join mode.

Gamemaster / OP band only: /guide give <player>, /money set, /money add, /money take, /economy reload, /economy log, /job reload, /job validate, /guild reload, and /ooga db status|migrate check CommandSourceStack.permissions() for Permission.HasCommandLevel(GAMEMASTERS)—same tier vanilla uses for many built-in cheats. Dedicated console and suitably permissioned integrations still work as the server configures them.

Future: a dedicated Otters Civ. permission apparatus (explicit string ids, optional Fabric Permissions API / server plugins, non-OP econ moderators). Sketched under Permissions apparatus (planned) in DOCS/ROADMAP.md and M1’s admin-permission backlog.

Economy & persistence

Think “one authoritative server database”: balances in memory for gameplay speed, SQLite underneath for persistence, migrations, and audit history.

Balances are keyed by player UUID and cached in memory at runtime, then persisted to config/otters_civ_revived/project_ooga.db. The same database also stores jobs state, guilds, chunk claims, and schema versioning.

Every balance mutation (admin set/add/take, player pay, fee, starting balance, reward) records an immutable row in the SQLite wallet_ledger table with delta, post-balance, reason, note, and timestamp. Moderators can inspect recent rows live with /economy log instead of opening a file.

Passive rewards

Breaking the right blocks and killing the right mobs silently adds coins. What “right” means is editable JSON—often via tags Datapacks already understand—with optional exceptions per exact block/mob ID.

Coverage is intentionally broad: the current bundled reward surface spans the current vanilla block set and the current vanilla living-entity set, while the same tag + value-file approach keeps future blocks and mobs coverable without changing the core reward model.

Mining and combat payouts load from JSON at config/otters_civ_revived/rewards.json, then merge sibling block_values.json and entity_values.json whole-file maps (see below). All are created with defaults when missing. Use /reload after editing reward files, or restart the host if you prefer.

What counts: tags and datapacks

Which blocks and mobs pay is not hard-coded in that JSON as a block list. The config points at tag identifiers; the tag contents come from Minecraft’s tag system (vanilla + mod + user datapacks).

• blockTag — block tag id (e.g. otters_civ_revived:currency_blocks). Used for the fallback blockReward when that block’s registry id is not listed in blockRewards. Point it at any valid block tag.
• entityTag — entity type tag id (default otters_civ_revived:currency_mobs). Used for entityReward fallback when the mob’s id is missing from entityRewards. Your own datapack tags are fine.
• Membership — The mod ships tag JSON under data/otters_civ_revived/tags/… inside the JAR. Server owners can add world/server datapacks to merge extra entries into those tags or define new tags, then set blockTag / entityTag to those ids in rewards.json.
• Per-block / per-mob payouts — Objects blockRewards and entityRewards in rewards.json map registry ids (e.g. "minecraft:diamond_ore": 40, "minecraft:zombie": 2) to whole-number payouts. Keys are validated and normalized at load; invalid ids are skipped with a server log warning.
• Dedicated value files — block_values.json / entity_values.json beside rewards.json normally contain one line per rewarded block/rewarded entity; Otters Civ. seeds them automatically on SERVER_STARTED whenever a sibling file parses to zero keys ({}, invalid JSON counts as zero). Rows default to whichever blockTag / entityTag resolves to plus flat blockReward / entityReward. Inline blockRewards / entityRewards overrides win on shared keys.
• Fallback amounts — Once maps are merged, if the broken block’s id is not listed, the payout is blockReward only when that block matches blockTag. Same pattern for kills: merged entityRewards wins, otherwise entityReward when the victim’s type matches entityTag. Listed ids pay their configured amount even without tag membership.

Other keys in rewards.json: enabled, optional blockRewards / entityRewards, per-action cooldowns, skip creative/spectator, dimensionBlacklist (dimension ids), announceRewards. Defaults shipped in code target otters_civ_revived:currency_blocks and otters_civ_revived:currency_mobs; sibling value files populate from those tags automatically the first time the server starts with empty maps.

Kill credit in this build favors direct player hits; bows, tridents, and other indirect kills are not credited yet.

Bundled datapack tags (default JAR)

These are the shipped entries merged into the mod’s namespaces. Operators can supersede or extend them with world/server datapacks; rewards.json decides which tag ids participate in payouts.

otters_civ_revived:currency_blocks

~260+ block ids and nested tag references shipped in the JAR (data/otters_civ_revived/tags/block/currency_blocks.json). Ore lines expand every block in each vanilla ore tag. All default to the flat blockReward (1); operators tune per-block amounts in block_values.json.

• Stone & polished: stone, granite, polished_granite, diorite, polished_diorite, andesite, polished_andesite, deepslate, cobbled_deepslate, polished_deepslate, tuff, polished_tuff, tuff_bricks, chiseled_tuff, chiseled_tuff_bricks, calcite, dripstone_block, pointed_dripstone, cobblestone, mossy_cobblestone, smooth_stone
• Stone bricks: stone_bricks, mossy_stone_bricks, cracked_stone_bricks, chiseled_stone_bricks, deepslate_bricks, cracked_deepslate_bricks, deepslate_tiles, cracked_deepslate_tiles, chiseled_deepslate, infested variants (stone/cobblestone/bricks/deepslate)
• Ores: #minecraft:coal_ores, #minecraft:iron_ores, #minecraft:copper_ores, #minecraft:gold_ores, #minecraft:redstone_ores, #minecraft:lapis_ores, #minecraft:diamond_ores, #minecraft:emerald_ores, nether_quartz_ore, ancient_debris
• Earth & soil: #minecraft:dirt (dirt, grass_block, podzol, mycelium, rooted_dirt, mud, etc.), #minecraft:sand, gravel, clay, farmland, packed_mud, mud_bricks, moss_block, moss_carpet
• Wood: #minecraft:logs (all log/stem/wood/hyphae + stripped), #minecraft:leaves, #minecraft:planks, bamboo_block, stripped_bamboo_block, bamboo_mosaic
• Wool: #minecraft:wool (all 16 colors)
• Terracotta: plain terracotta + all 16 colored variants + all 16 glazed variants
• Concrete: all 16 *_concrete + all 16 *_concrete_powder
• Sandstone: regular + red × (plain, chiseled, cut, smooth)
• Bricks & prismarine: bricks, prismarine, prismarine_bricks, dark_prismarine, sea_lantern
• Nether: netherrack, basalt, smooth_basalt, polished_basalt, blackstone family (polished/bricks/cracked/chiseled/gilded), nether bricks (red/cracked/chiseled), glowstone, shroomlight, nether_wart_block, warped_wart_block, nylium, soul_sand, soul_soil, magma_block, obsidian, crying_obsidian, respawn_anchor, lodestone
• End: end_stone, end_stone_bricks, purpur_block, purpur_pillar
• Ice & snow: #minecraft:ice, snow_block, powder_snow
• Coral: #minecraft:coral_blocks (all 5 live + 5 dead)
• Amethyst: amethyst_block, budding_amethyst
• Copper: all oxidation states × (block, cut, chiseled, grate, bulb) × (unwaxed, waxed) — 40 variants total
• Mineral storage: raw_iron_block, raw_copper_block, raw_gold_block, coal_block, iron_block, gold_block, diamond_block, emerald_block, lapis_block, redstone_block, netherite_block
• Glass: glass, tinted_glass, all 16 *_stained_glass
• Organic: melon, pumpkin, carved_pumpkin, jack_o_lantern, hay_block, dried_kelp_block, honeycomb_block, honey_block, slime_block, bone_block, sponge, wet_sponge, mushroom blocks
• Sculk: sculk, sculk_catalyst, sculk_sensor, calibrated_sculk_sensor, sculk_shrieker, sculk_vein
• Utility: crafting_table, furnace, blast_furnace, smoker, workstations (loom, cartography, fletching, smithing, stonecutter, grindstone), composter, barrel, bookshelf, chiseled_bookshelf, enchanting_table, anvils, brewing_stand, lectern, bell, beacon, conduit, note_block, jukebox, target, tnt, cobweb

otters_civ_revived:currency_mobs

The shipped entity-type tag is otters_civ_revived:currency_mobs. It now covers a broad editable vanilla living-entity roster so entity_values.json seeds more like block_values.json: hostiles, passives, neutrals, bosses, mounts, villagers, and other current living entities found in the runtime identifier set. It still excludes player, but it now includes a future-safe optional minecraft:sulfur_cube entry using tag syntax with required: false, so newer runtimes can pick it up without breaking current ones.

A separate bundled tag, otters_civ_revived:hostile_mobs, preserves the hostile-only grouping for jobs and for operators who want a combat-only reward surface. The default fighter job tag points there, so broadening the economy reward list does not make /job fighter grant XP for cows, fish, or villagers.

All config files (quick reference)

Everything below mirrors what the jar writes if you omit a field—the table is authoritative for spelling and defaults.

rewards.json and jobs.json both mirror Gson-backed coded defaults when omitted. Value files: on first logical server start with no persisted ids, Otters Civ. writes populated block_values.json / entity_values.json sourced from resolved tags (sorted keys)—see anchors below.

config/otters_civ_revived/rewards.json

rewards.json toggles payouts, picks tag groups, cooldowns/dimensions, and may carry inline per-block/per-mob maps (combined with sibling value files).

config/otters_civ_revived/jobs.json

Server-authoritative jobs catalog. This file now defines the live jobs roster itself: arbitrary job ids, display metadata, triggers, progression, boosts, and activation policy.

Shipped starter recommendation: five low-overlap jobs in single mode by default — miner, lumberjack, farmer, excavator, and fighter. The bundle is tuned for fast early levels, modest boosts, and long-tail specialization instead of multi-job stacking.

Edits load on normal startup and on /reload because the jobs service refreshes during both SERVER_STARTED and END_DATA_PACK_RELOAD. Clients do not read this file directly on dedicated servers; the server compiles the catalog and syncs the result to them.

config/otters_civ_revived/block_values.json

Whole-file map: block registry id (namespace:path) → non‑negative payout. On Fabric’s logical-server started callback, Otters Civ. expands whatever blockTag points at (including nested datapack references like #minecraft:diamond_ores), assigns each matched block flat blockReward, unions inline blockRewards from rewards.json, and—only while this file parses to zero keys—persists sorted UTF‑8 JSON you can skim like a spreadsheet.

This is the editable block surface operators work from: broad enough for the current vanilla game, while still using normal tag-based plumbing so future blocks can be folded in without redesigning the reward system.

If this file already has keys, startup only merges—it never wipes your edits. Broken JSON logs an error and is treated empty (then regenerated if still “no sibling keys”).

config/otters_civ_revived/entity_values.json

Same pattern for entity type ids using flat entityReward defaults when prefilling from the bundled broad reward tag otters_civ_revived:currency_mobs.

This is the editable entity surface operators work from: broad enough for the current vanilla living-entity set, while still staying future-friendly through the same tag + override-file model.

Again: regenerated only while the sibling file has no surviving keys—existing operator files remain authoritative overlays.

Adding your own blocks & mobs

Three ways, pick the one that fits how permanent the change should be. All three coexist; later layers override earlier ones for the same id.

1. Edit block_values.json / entity_values.json directly — easiest. Add lines like "minecraft:ancient_debris": 500, or "yourmod:custom_ore": 75, anywhere in the JSON object, save, and /reload (or restart). Per-id payouts always win over tag fallback, so this works for blocks/mobs that aren't in any tag at all. Keep keys lowercase namespace:path; invalid ids log a warning and are skipped.
2. Inline in rewards.json — same idea, different file. Add entries under blockRewards or entityRewards:

   {
     "blockRewards": {
       "minecraft:ancient_debris": 500,
       "yourmod:custom_ore": 75
     },
     "entityRewards": {
       "minecraft:warden": 250
     }
   }

   At startup the sibling value files merge on top, so if the same id appears in both files, the sibling file wins. Use whichever feels natural — rewards.json for "config I check in," sibling files for "ops dial-tuning."
3. Extend the bundled tag via a server datapack — for entries that should automatically appear in regenerated sibling files and inherit the flat blockReward / entityReward:
   1. Drop a pack.mcmeta + data/otters_civ_revived/tags/block/currency_blocks.json into <world>/datapacks/<your_pack>/ (note the singular block / entity_type directory names — plural is silently ignored by MC 1.21+).
   2. Contents: { "replace": false, "values": ["yourmod:custom_ore", "#yourmod:custom_ore_tag"] }. Nested #tag references resolve recursively.
   3. /reload — the prefill re-runs on END_DATA_PACK_RELOAD; if the sibling file has no keys yet, your entries appear in the regenerated JSON at blockReward amount.
   Alternatively, change blockTag / entityTag in rewards.json to point at a different tag id entirely (vanilla, modded, or one you defined).

Precedence (high → low) when a block breaks or mob dies: sibling value file entry → rewards.json inline map entry → tag membership with flat reward → no payout. So any explicit per-id line in either JSON beats tag-wide fallback.

config/otters_civ_revived/project_ooga.db → jobs_state table

Player jobs runtime state: active job ids and per-job XP totals now persist in the SQLite jobs_state table inside project_ooga.db, not in a separate JSON file.

Use jobs.json to change the live catalog. The database table is auto-managed runtime state only. Older jobs.properties and jobs_state.json notes are legacy history and should not be treated as the current storage path.

config/otters_civ_revived/project_ooga.db

Main runtime store: this SQLite database holds wallet balances, the immutable wallet_ledger audit table, jobs state, guild records, chunk claims, and schema version metadata. It is auto-created on first startup and migrated in place as schema versions advance.

The database runs in WAL mode for safer concurrent reads, and admin inspection is surfaced in-game through /economy log plus /ooga db status. Prefer those commands over hand-editing the DB unless you are taking a controlled backup/restore pass.

config/project_ooga/jobs_hud.properties

Client-only jobs HUD config: visible=true|false, offsetX, offsetY, and scale. The file is written when you use the /otter → Jobs controls. Default behavior: visible, centered, 12 px above the vanilla XP bar, scale 1.0.

Deprecated: the old FPS-only config remains at config/fpsmod/hud.properties for the standalone FPS overlay lineage, but Project OOGA no longer registers that overlay.

config/project_ooga/otter_ui.properties

Client-only /otter hub theme: theme is one of OTTER, MIDNIGHT, SUNSET, or MINT (default OTTER). The file is written when you click the footer Theme: … ▶ chip in the full menu or the matching control on the small-window fallback card.

Roadmap milestones (execution order)

Rough delivery spine (M0–M6, with M3.5 job loot, M3.7 visibility/operator tools, and M4.5 social between)—not dates. Matches DOCS/ROADMAP.md; pairing read: target feature set.

High-level phases from DOCS/ROADMAP.md; the target feature set section describes intended gameplay, while this table is the delivery spine. The remaining backlog now centers on a richer permission apparatus beyond vanilla gamemaster, in-game visibility & operator tools (leaderboards, player stats, economy health, audit), friends / PM, diplomacy/governance layers, optional PostgreSQL at scale, and soak testing plus operator playbooks.

Client features (detail)

/otter hub themes: the civ menu is drawn with flat rectangles (no texture pack dependency). Four built-in palettes change panel, accent, and text colors; cycle them from the menu footer and your choice persists under config/project_ooga/otter_ui.properties.

Player-shop market (/otter → Shop): a UI-first market with three views. Browse lists every open listing (item, items-per-bundle, price, stock, seller) with a per-row Buy button and a shared quantity stepper. Mine shows your own listings with a state badge and Close / Restock buttons. Sell previews the item currently in your main hand and gives items-per-bundle, price, and stock steppers (±1 / ±10) plus a one-click List held item. The panel is driven by a server→client market snapshot pushed on join and refreshed after every shop action, and all actions route through the same server-validated /shop core (no client-trusted economy) — a player completes the entire buy/sell loop without typing a command. Listings only accept plain items (no enchants/custom name/damage); prices, caps, fees, and the seller-paid sales tax come from config/otters_civ_revived/shops.json.

Jobs HUD: Project OOGA draws a compact jobs bar above vanilla XP whenever the local player has an active job and the HUD is enabled. The /otter → Jobs tab now includes a preview of that bar, paged join/leave/info controls driven by the synced server catalog, and the usual visibility / offset / scale controls so you can see what the overlay is supposed to look like before closing the menu.

Guild chunk map overlay: Running /guild map toggles a 30-second GUI chunk-map overlay in the top-right corner of the screen. A 9×9 grid tints each cell from the chunk’s surface block (vanilla map colors), then overlays semi-transparent green for your guild’s claims and amber for other guilds; your cell stays aqua with a short white line showing horizontal facing (yaw). While you move on foot, crossing into a chunk with a different claim shows a hotbar-style line (“your guild” vs named “claimed land”). Claim data (including display names for the hint) is streamed from the server on join and whenever chunks are claimed or unclaimed.

Chunk border particles: /guild map also spawns particle columns at claimed chunk corners — green end rods for your guild's claims, orange flame particles for other guilds. Particles persist for 30 seconds.

Scaling behavior: the bar width is now content-aware. Longer labels such as LUMBERJACK and larger XP strings no longer overrun the right-hand text at default settings; the HUD expands when it has room, truncates safely only when it must, and clamps back on-screen after offsets are applied.

Small-window fallback: if the game window / GUI viewport gets too cramped for the full /otter panel, the client now swaps to a compact prompt instead of trying to cram the full menu on-screen. That prompt tells the player to enlarge the window or lower Minecraft GUI Scale and still exposes quick buttons for /money, /job, and /job list.

Deprecated: The legacy FPS counter and overlay toggle from the repository's original template (FpsHudOverlay / HUD config under config/fpsmod/). The standalone FPS overlay mod handles FPS display; Project OOGA's client UX is the jobs HUD + civ menu.

Operational limits

• One rewards/config directory per launcher instance applies to integrated server usage; the main SQLite store follows that same Fabric config root.
• Join onboarding vs welcome-back is tracked per world save (overworld saved data project_ooga:join_attendance), not in global config/—a new single-player world or new server map always gets the full first-join messages again for each player UUID.
• /money set and /guild reload are intentionally narrow: vanilla gamemaster permission only until a plugin-friendly permission layer ships (see command permissions).
• Tag-based payouts do not imply “worldgen-only” blocks; duplication farming is deferred to roadmap hardening.
• Remote clients render jobs from server-synced catalog/status payloads; opening jobs.json from /otter is only available when the local machine also hosts the world.
• /otter uses a compact fallback prompt on very small GUI viewports instead of rendering the full panel half-clipped. If you hit that state, enlarge the game window or lower Minecraft GUI Scale, then reopen /otter.

Architecture

Project OOGA is structured as five domain layers built on top of the Fabric baseline. The current JAR activates the economy, jobs, and guilds/claims surfaces; the layers below are the planned target shape.

Planned data model (v1)

Runtime flow

1. Player action emits game event.
2. Validation checks permissions and limits.
3. Domain service computes result.
4. Transaction and state changes persist atomically.
5. Player receives feedback via UI, chat, or action bar.

Installation

Client install is optional (jobs HUD + /otter GUI extras). Server install enables economy commands, jobs progression, and passive payouts.

1. Install Fabric Loader >= 0.19.2 for Minecraft 26.1.2. The Fabric installer handles this.
2. Drop Fabric API (0.146.1+26.1.2 or compatible) into your mods/ folder.
3. Drop the mod JAR (project-ooga-1.0.0.jar) into mods/.
4. Start the server (or client). Otters Civ. creates config/otters_civ_revived/ (economy.json, rewards.json, jobs.json, guilds.json, optional sibling value files, and project_ooga.db) and, on clients using the jobs HUD, config/project_ooga/jobs_hud.properties.
5. Optionally edit config/otters_civ_revived/rewards.json to tune payout amounts, tags, and cooldowns, or config/otters_civ_revived/jobs.json to define the live jobs catalog, then restart or run /reload.

Building from source

Requires JDK 25+ and Git. The repo uses the Gradle wrapper—no separate Gradle install needed.

1. Clone: git clone https://github.com/Otterdays/Minecraft-Civ-Remixed.git
2. Build: ./gradlew build (Linux/macOS) or gradlew.bat build (Windows)
3. Output JAR: BUILT/libs/project-ooga-1.0.0.jar

The build version and Minecraft target are pinned in gradle.properties. Match Fabric API and Loader to the pins there for a reproducible build.

Changelog

Unreleased

Added

/otter command — in-game synopsis and config pointers.

/money and /money set <player> <amount> — wallet read and admin bootstrap.

Passive rewards: mining payout for otters_civ_revived:currency_blocks; kill payout for otters_civ_revived:currency_mobs (direct melee only).

WalletStore, FileWalletStore, WalletService — persistence layer.

RewardOrchestrator + JobsHooks stub for future professions.

Config: config/otters_civ_revived/rewards.json (created on first run).

Project OOGA whitepaper and full DOCS set (architecture, roadmap, SBOM, style guide, changelog).

Imagery Optimizery desktop utility (images/optimize-here/) — Pillow batch pipeline with optional tkinter GUI.

Changed

JoinWelcome: first join per world save keeps the three-line onboarding; returning players get a styled welcome-back line plus a short /otter / /money tip (JoinAttendanceSavedData, id project_ooga:join_attendance).

/money set requires Permission.HasCommandLevel(GAMEMASTERS) (vanilla gamemaster / OP band); /money read stays open. Planned: mod-specific permission apparatus—see DOCS/ROADMAP.md.

Runtime store: config/otters_civ_revived/project_ooga.db (SQLite, WAL mode). config/fpsmod/ is FPS HUD only (hud.properties).

fabric.mod.json environment changed from client to * to enable server command registration.

LICENSE clarified: ARR with carve-outs for gameplay/video use and including the official unmodified JAR in mod packs.

Repository rebranded to Minecraft-Civ-Remixed / Project OOGA.