Conditions and effects

Conditions and effects are short strings, so they can live in plain JSON (a person’s routine, a saved directive) and survive a rewind. Anywhere a definition is code, a function works too.

world.action({
  id: 'buy_round', at: 'tag:drink', minutes: 15, target: 'person', base: 0.1,
  if: ['money>=10', '!felt:wronged', 'hour>=17'],
  targetIf: ['regard>0.3'],
  then: ['money-=10', 'regard+=0.05', 'var.rounds+=1'],
});

• Syntax
• Where conditions and effects are used
• Core terms
• Module terms
• Effects
• Functions
• Extending the language
• Rewind safety

Syntax

A condition is a term, optionally compared with a literal, optionally negated:

term                  true when the term's value is truthy
term<op>literal       a comparison
!term<op>literal      negated (or 'not term<op>literal')

A term is a name, then . or :, then an argument: need.hunger, has:radio, thinks:open:workshop, file:player.fixed. The name is the part before the first . or :; the argument is everything after (it can contain more : and .). A bare word that isn’t a registered term reads the world fact of that name (raining is fact:raining).

Operators: >=, <=, >, <, == (or =), !=. The first operator in the string is the one used (the longer one when two start at the same place), so keys can’t contain operator characters.

Literals: numbers (0.5, -2), true, false, null, and strings, with or without quotes (emotion==angry, person=='ruth').

Comparing:

An effect is a term with an assignment, or a bare term:

money-=6      var.tips+=1      need.hunger-=0.2      fact:open:noodles=false
give:radio    take:radio*2     feel:tired            believe:fixed:radio=true

Assignment operators are =, +=, -= and *=. A bare effect (give:radio, fact:alarm) uses the effect’s own default (for fact: and game:, true). An effect name that isn’t registered is taken as a person variable: tips+=1 is var.tips+=1.

Conditions are compiled once and cached, so using them is cheap.

Where conditions and effects are used

Core terms

Always available. “The person” is the context’s person.

Module terms

Each module registers its terms when it’s switched on. With a module off, its terms read as facts of the same name (usually nothing).

Reverie

Fellowship

<id> defaults to the context’s target.

Wormtongue

Cityspeak

Mentat

Gaff

Ceres

Cradle

Athelas

Delos

Voice

The person talked to is the person, and the speaker ('player') the target.

Bree

The person, with the target the other.

Morgul

<id> defaults to the context’s target.

Effects

Effects change state directly. They’re meant to run inside the simulation: an action’s then, a line said with cityspeak.say, a social act’s outcome. There, they’re replayed along with everything else.

Core effects

Module effects

Functions

Wherever a condition is accepted in a definition (not in routines, which are saved), a function (ctx) => boolean works; wherever an effect is, (ctx) => void works.

world.action({
  id: 'confide', at: 'here', target: 'person', minutes: 20, base: 0.1,
  targetIf: [(ctx) => ctx.world.fellowship.regard(ctx.person.id, ctx.target) > 0.6],
  then: [(ctx) => { ctx.world.reverie.applyFeel(ctx.target, 'helped', ctx.person.id); }],
});

The context:

A function effect runs inside the simulation, so it may change state directly (as above, with the apply... methods): a replay runs it again. It must be deterministic: draw randomness from ctx.world.stream(ctx.person), never Math.random.

Extending the language

world.term('weekend', () => world.weekday >= 5);
world.term('owns', (ctx, item) => (ctx.person?.inv[item] ?? 0) > 0);
world.effect('stress', (ctx, _arg, op, value) => {
  if (ctx.person && world.reverie) world.reverie.addStress(ctx.person.id, Number(value));
});

world.action({ id: 'lie_in', at: 'home', minutes: 90, base: 0.1, if: ['weekend'], pose: 'sleep' });
world.action({ id: 'tax_return', at: 'home', minutes: 60, rank: -1, then: ['stress+=0.2'] });

world.term(name, fn): fn(ctx, arg) returns a value (a string, number, boolean or null). The name must be a plain identifier; arg is everything after the first . or : (an empty string for a bare term). Registering a name again replaces it.

world.effect(name, fn): fn(ctx, arg, op, value), where op is '=', '+=', '-=', '*=' or '' for a bare effect, and value is the parsed literal (null for a bare effect). Effects run inside the simulation; change state directly, deterministically.

Terms and effects are definitions: register them on every start.

Rewind safety

Every string condition and effect is safe across rewinds as long as it reads and writes Tyrell’s own state. The exceptions:

• fact: falling back to shell.check. When a fact isn’t set, fact:<key> asks the game live, and a replay sees the game as it is now, not as it was. Push facts with world.fact instead.
• Function conditions and custom terms that read game state that isn’t kept in the world (the player’s position, a game flag). Read facts or kept values instead.
• chance: is deterministic: in a decision it draws from the person’s seeded stream, which advances it. Calls that only look (world.whyNot, world.describe, world.mind.explain, cityspeak.choose and say, barks, Joi, gaff.eligible, mentat.acquire, the ink bridge) draw from a stream that changes nothing instead, so looking never changes the world. When game code tests conditions itself, wrap it the same way: world.peek(() => world.lang.test(cond, ctx)).
• Calling world.lang.apply (or any effect function) from game code changes the state without an input. Use an input instead.