Skip to content

RevFramework: Loot (Free)

RevFramework: Loot is the complete Loot system, free — the same source files, version number, documentation and teachable panels that ship as the fourth system of the paid Inventory, Pickups & Crafting package:

  • Drop tables — weighted and independent-chance rolls, nested tables with cycle detection
  • Seeded replays — opt-in deterministic RNG, so a surprising drop is investigable
  • Accounted delivery — every award is delivered, spawned into the world, or named in an Undelivered event. Never silently discarded
  • The shared core — the save coordinator, file store and participant contract every RevFramework package is built on

Not a trial, not a watermark, not a feature cap. If you later buy a paid package, it imports over this one, because they are built from the same tree.

If you can't code, don't get this

This is a developer toolkit, not a drag-and-drop template — even free, it would only cost you an afternoon of confusion.

The mirror of that warning: if you write C# and want systems you can read, test, and delete — this is built for you.

Listing status

The free listing is in preparation for the Asset Store. The store link lands here the day it goes live; everything on this page describes the package as built.

System decoupling

  • Loot references nothing but the framework core — it compiles and operates with no other system installed.
  • Rolling is a pure function: no service, no scene, no Play Mode required.
  • Delivery lands through a small adapter seam. Adapters for Inventory, Currency, Pickups and Health ship in the package as source and compile in automatically when those systems are present.

Multiplayer & netcode

Loot has no authority model of its own, on purpose: rolling mutates nothing, so there is nothing to gate. Authority belongs at the delivery boundary — the inventory or wallet that accepts the award — and the adapter seam reports an authority refusal as its own outcome, so a denied award is never re-routed into the world. No networking, replication, or transport layers are included.

What This Free Package Proves

The point of giving a whole system away is that the method can be judged on it. Each of these is checkable in the package, not asserted:

  • Dependency discipline — RevFramework.Core.Abstractions references nothing at all; Loot references only the core. Open the asmdefs and count.
  • Separation of concerns — Loot compiles and operates with no other system installed.
  • Composition over coupling — integration happens through explicit interfaces (items as GUID strings, containers as opaque handles), never systems reaching into each other.
  • Failure transparency — outcomes and refusals are surfaced and named instead of silently swallowed. The quickstart demonstrates the refusal first, deliberately.
  • Real infrastructure — the save coordinator and persistence contracts are the production classes every paid package uses; your own participants join the same save file through the same interface, with no privilege difference.

If you do not like how Loot is built, you will not like the rest — better to learn that for free.

What's Included

Loot System

  • Weighted tables and independent-chance tables, nested to any depth with cycle detection
  • LootRoller — rolling as a pure function over a table, usable with nothing else in the scene
  • LootService — delivery routing with optional adapters, Granted / Spawned / Undelivered events, and a default container
  • Opt-in deterministic RNG — UseDeterministicRng(seed) replays the same roll within a build
  • Ten runtime source files — small enough to read in a sitting

Shared Core

  • The save coordinator, file store, participant ordering and carry-over (Runtime/Core, byte-identical in every RevFramework package)
  • Result-first conventions and the editor foundation the tooling is built on

Teaching & Samples

  • Three teachable panels — loot rolls (seeded sampling without Play Mode), loot delivery (which adapters are bound, and where every award actually went), and the save coordinator
  • Two sample scenes — the Loot quickstart and the Save quickstart
  • A sample receiver in the quickstart: press Play and watch an award be refused by name, bind the receiver, press Play again and watch the same award land. The whole adapter seam is about twenty lines, and that file is it

Documentation

The full suite, same as every paid system:

These pages live in the Inventory, Pickups & Crafting section of this site, because that is the paid package Loot ships in — the free system sitting visibly inside the package it came from.

Getting Started

  1. Open the Loot Quickstart scene (the welcome window offers it on first import)
  2. Use the roll panel before Play Mode: roll once, then sample thousands of pulls and compare the measured rates against the weights you authored
  3. Press Play and Roll And Grant — the award is refused by name, because nothing is bound. That is the delivery contract demonstrating itself
  4. Bind the Sample Loot Receiver to the service's adapter slots and roll again — the same award lands, reported through the same events
  5. Read SampleLootReceiver.cs, then write your own adapter against your systems — or install a paid package and bind its real adapters

Tests

Loot is covered by the same adversarial and behaviour-pinning suites as every paid system, run in CI on every push.

The suite download on the Testing page is gated on a paid invoice number — free packages are added to your assets without an order, so the store issues no invoice number for them. Any paid RevFramework purchase unlocks it; the suite covering this exact code runs in CI either way.

The Paid Packages

What they add — this package stays complete either way:

  • Inventory, Pickups & Crafting — includes Loot plus the three systems its adapters deliver into
  • Health & Status Effects — the LootDropOnDeath adapter lights up beside it
  • Currency & Economy — loot that credits real wallets
  • RevFramework Complete — all nine systems

All built with the same architecture, documentation standard and testing philosophy. This package is the free way to evaluate all of it.