Deciding (Bicameral)

Bicameral is the core’s decision maker, named for Westworld’s bicameral mind: the voice that tells a host what to do until it becomes their own. It holds the needs, the layered priorities (story, job, routine, needs), the weighing of every option, the pick, and the habits people learn. Beside it, the core keeps the skills people grow by practice.

• Needs
• Actions
• The layered stack
• Routines
• Jobs and shifts
• Directives
• Urgent and desperate needs
• What an option is worth
• Considerations and curves
• The pick
• When people think
• Habits and rewards
• Skills and talents
• Pastimes that pall
• Wishes and dreams
• Config
• Asking why

Needs

world.need({ id: 'hunger', rise: 0.06, start: 0.3, emotion: 'irritable' });
world.need({ id: 'fun', rise: 0.05, urgent: 1.1, emotion: 'bored' });   // never breaks a routine

How fast every need rises can be scaled at once with the headline knob config.needs (and a person’s own, tune: { core: { needs } }): see Tuning.

A need’s level is computed, not ticked: the stored value plus rise times the hours since it was stored, clamped to 0..1. While someone is doing an action that relieves the need, the level drops gradually through the action (by the fraction done), and the full relief is applied when the action ends. While someone is doing an action with rates, the need rises at rise × rate instead.

Read a level with world.needOf(id, need). There’s no public input that sets a need directly; see Integration: custom inputs if the game needs one (feeding someone, say).

Actions

world.action({
  id: 'eat_cafe', label: 'eating at the cafe',
  at: 'tag:food', slot: 'seat', minutes: [30, 45],
  relieves: { hunger: [0.5, 0.7], company: 0.1 },
  price: 6, pose: 'sit', tags: ['social', 'food'], feels: ['good_meal'],
});

Every field of ActionDef:

An action is a free choice only if it has relieves or base, its rank isn’t below 0, and the person has its job (if it names one). Actions without either are still possible when something requires them.

The layered stack

Every option has a rank. Only options at the highest rank available are considered at all; weight decides among them. The ranks come from the layer that asked:

The numbers are config: storyRank (3), jobRank (2), routineRank (1), urgentRank (1.5), desperateRank (2.5), and Reverie’s breakRank (4).

What a person is doing carries its rank (world.get(id).doing.rank). While they’re busy, they only switch to something new if it outranks what they’re doing, or if the routine entry, shift or directive that started it has run out.

Routines

A routine says what’s expected when: from this hour, be at this place doing this, until the next entry.

world.person('ruth', {
  home: 'apt_4',
  routine: [
    [8, null, '*'],               // from 8:00: free time
    [9.5, 'market', 'buy_food'],  // 9:30: shopping
    [9.75, null, '*'],            // 9:45: free again
    [18, 'tag:food', 'eat_cafe'], // 18:00: dinner out
    [19, null, '*'],
    [22, 'home', 'sleep'],        // 22:00 until 8:00 tomorrow: bed
  ],
});

Each entry is [hour, place, activity, extra?]:

An entry lasts until the next one. The last entry of the day runs until the first entry of the next day, so a routine with one entry fills the whole day, every day. Plan the day as a sequence.

'*' means two different things:

• [19, null, '*'] (or '*' with 'here', or the activity 'free' with no place): free time. Nothing is required; the person’s needs decide.
• [7, 'home', '*']: anything at that place. Every action the place offers becomes an option at the routine’s rank: actions whose at matches the place (its id, a tag it has, 'home'/'work' for theirs), actions the place lists in offers, and also actions with no at (they can be done anywhere). Each gets the required bonus (+1 to its base), so the choice among them is close to even; each choice takes its own minutes and then they choose again, leaving on time for the next entry. Actions with rank: -1 and job actions they don’t hold are included in the list (job actions are then ruled out), so keep “only when required” actions that shouldn’t happen at home (sulking, a bender) at places that aren’t used with '*', or give them who/if conditions.

Fill. When a routine entry names an action (not '*'), the action stretches to the end of the entry: [19, 'bar', 'drink'] followed by [21.5, null, '*'] means drinking at the bar until half past nine, however long drink normally takes. If the entry ends in under 5 minutes, the action lasts the shorter of its own length and 5 minutes. Set fill: false on an action to keep its own length.

Variants choose a different plan by day or by condition. The first variant that fits is used:

world.person('lena', {
  home: 'apt_5',
  routine: [
    { days: [5, 6], plan: [[8, null, '*'], [23, 'home', 'sleep']] },                          // weekends
    { when: ['fact:raining'], plan: [[8, 'home', '*'], [22, 'home', 'sleep']] },             // rain: stay in
    { plan: [[8, null, '*'], [19, 'bar', 'drink'], [21.5, null, '*'], [23, 'home', 'sleep']] },
  ],
});

If no variant fits, the person has no routine that day (their needs decide).

Jobs and shifts

world.action({ id: 'sell', at: 'market', slot: 'till', minutes: 60, job: 'grocer', rank: -1, pose: 'work' });
world.person('dev', {
  home: 'apt_3',
  job: { id: 'grocer', place: 'market', action: 'sell', shifts: [[8, 16]], days: [0, 1, 2, 3, 4, 5], wage: 0 },
});

On shift, the job’s action is required at rank 2 (config.jobRank), until the shift ends, and fills the shift. Only a desperate need (or a break or a directive) takes them off it.

Staff in a closed place. A place that’s closed (by its hours or a closed:<id> fact) turns everyone away, except for actions that name the person’s job (job: 'grocer') at their job’s place. So give work actions job, or a baker whose shift starts before the bakery opens will be turned away at the door. This only works for actions: a job whose action is a task is blocked like anyone else.

Give work actions rank: -1 so nobody chooses them in their free time.

Directives

The story layer: tell someone to do something, above their job and routine.

world.direct('kofi', { do: 'eat_cafe' });                                      // once, as soon as possible
world.direct('vance', { do: 'patrol', at: 'market', until: world.now + 120 }); // for two hours
world.direct('ruth', { do: 'fix_radio' });                                     // a task: Mentat plans it
world.direct('kofi', null);                                                    // release them

A directive is active while it isn’t done (or repeats) and until hasn’t passed. It stays on the person (marked done) until you replace it or clear it with null. world.direct makes the person stop what they’re doing and think again at once.

Urgent and desperate needs

An option that’s chosen freely (not required) gets its rank lifted when it meets an urgent need, but only if it really meets it: the action must relieve that need by config.liftRelief (0.3) or more (the middle of its range times the place’s quality).

• Level at arrival at or above urgent (default 0.85): rank config.urgentRank (1.5), above routines.
• Level at or above max(urgent, config.desperate) (0.97): rank config.desperateRank + (level - config.desperate) × config.desperateSlope (2.5 to 2.8), above work. So someone starving wakes up even when exhausted.

The level checked is the level when they’d arrive, so a long walk counts. Needs with urgent above 1 never lift anything: use that for needs that should color a day without ever breaking it.

People don’t wait to notice: when someone starts anything, Tyrell works out when their next need will cross urgent, desperate or 1 (at the current action’s rates), and schedules a check for that minute.

What an option is worth

For each option that isn’t ruled out, the weight is built up in parts. world.why(id).picked.parts and world.whyNot(id, action) show them.

Base.

base = action.base
     + sum over relieved needs: curve(level at arrival) × min(relief × quality, max(level, config.reliefFloor))

Relief beyond what the person needs counts for nothing (eating when barely hungry is worth little). A required option (from a routine, job or directive) adds 1 to max(base, 0), so it’s always worth something. An option with a base of 0 or less is ruled out (“nothing in it for them”).

Multipliers, in this order (a factor of exactly 1 isn’t listed):

Ruled out before weighing, with the reason shown in the inspector: no such action; needs a job they don’t have; who fails; cooling down; failed at that place in the last config.backoff minutes (failed recently); can’t get there (infinite travel); hours don’t include the arrival time; the place is closed at arrival (except staff, above); the slot’s who (places) fails; no free slot (unless they already hold it); if fails; the target isn’t around; or a module blocks it (Ceres: can’t afford it, sold out, needs an item).

Considerations and curves

A consideration takes an input, normalizes it over a range, passes it through a curve and maps the result to an output range. The result multiplies the weight.

const night = { name: 'night', input: 'hour', range: [0, 24],
  curve: [[0, 1], [6 / 24, 1], [8 / 24, 0.12], [20 / 24, 0.3], [22.5 / 24, 1], [1, 1]] };
world.action({ id: 'sleep', at: 'home', slot: 'bed', minutes: [420, 510], relieves: { energy: 0.95 },
  rates: { hunger: 0.4 }, tags: ['sleep'], pose: 'sleep', considerations: [night] });

world.action({ id: 'gamble', at: 'tag:casino', minutes: 60, base: 0.2,
  considerations: [{ name: 'nerve', input: 'trait.courage', out: [0.2, 1.5] },
                   { name: 'broke', input: 'money', range: [0, 50], curve: 'smooth' }] });

The input is read with the option’s context: the person, the candidate place, the target, the action. Any term works; terms that don’t exist read as a fact of that name (usually nothing, so 0). Some read the option itself: 'habit' is the person’s habit for this action (1 when they have none; habits run from 0.25 to 4, so give it a range), 'crowd' is how full the place is (the share of its slots taken, 0..1), and 'price' is the action’s price (Ceres). Use a function input for anything else.

Curves:

Tyrell.curveAt(curve, x) evaluates one, and world.mind.consider(consideration, ctx) evaluates a consideration.

Compensation. Multiplying many factors under 1 drags an option down just for having more considerations. With config.compensate (on by default), each factor v between 0 and 1 of an option with n > 1 considerations is raised to v + (1 - v) × (1 - 1/n) × v, the compensation from Dave Mark’s Infinite Axis Utility System. A 0 still vetoes and a 1 stays 1.

The pick

1. Drop options that are ruled out or weigh 0.
2. Keep only the highest rank.
3. Drop options under config.cut (0.25) of the best weight at that rank.
4. Keep the best config.top (3), heaviest first (ties by id).
5. Draw one, with probability proportional to weight ^ config.power (2), from the person’s own stream.

Squaring the weights makes the best option likely without making it certain. Setting top: 1 makes people predictable; a lower power makes them whimsical.

If nothing is left, the person waits where they are (config.idle minutes, 20 by default) and thinks again.

When people think

People decide at these moments, all of them queued events:

• an action or walk ends (and a plan’s next step doesn’t follow);
• they’ve been idle for config.idle minutes;
• a routine entry starts, a shift starts or ends, or a directive’s until passes, during what they’re doing (a “boundary” check: they switch if the new requirement outranks what they’re doing, or if what they’re doing came from the entry that just ended);
• a need is about to become urgent, desperate or reach 1 during an action (an “urge” check: they switch only if something now outranks what they’re doing). Urge checks don’t interrupt a walk; boundary checks do;
• a directive is given (world.direct), they come back from being away, or something fails.

Each check is an event queued for its moment. Someone who keeps on after a check has their checks queued again, so the same moment can be queued, and thought over, more than once; with config.checksOnce a check already queued for that moment isn’t queued again.

A plan that was set aside for something urgent is picked up again at the next decision, unless something outranks it (see Mentat).

Habits and rewards

Each person keeps a habit weight per action, two numbers (fast and slow) whose average multiplies the action’s weight. Everyone starts at 1. How fast they move is config (below, and Tuning): habitFast, habitSlow and habitDrift, all three scaled by the headline knob habits (0 freezes habits; a person’s tune has their own), with habitDone (the share of a go that must be done, 20%), habitBest (the most a go counts as, twice as good as expected) and nudgeSlow (a reward’s share for the slow weight, a quarter).

After an action ends with more than 20% of it done, the habit learns from how it went: the relief actually got (each need weighted by its urgency) against the relief expected. Better than expected nudges the fast weight up, worse nudges it down; the fast weight is pulled slowly back toward 1 (habitDrift), and the slow weight follows the fast one. Both stay between habitMin (0.25) and habitMax (4).

The game can reward or discourage a choice directly. This is an input, so it’s recorded:

world.reward('kofi', 'chat', 0.3);    // he enjoyed that: more likely to chat
world.reward('sam', 'steal_food', -0.5);

reward adds the amount to the fast weight and a quarter of it to the slow one. With Fellowship, people also pick up a little of the habits of people they like when they spend time together. A game that learns in its own way (Merryfolk’s folk learn to love what relieved a lot) sets habitFast, habitSlow and habitDrift to 0, and its rewards are then the only thing that moves a habit.

Instincts

A habit is learned; an instinct is inborn. PersonDef.instincts gives a person a standing multiplier per action or task ({ fish: 1.3, chat: 0.8 }): it’s weighed in as the factor instinct beside habit, and never changes. Delos fills it in from a genome, so children inherit their parents’ tastes; a game can also write it by hand. Read it as instinct.<action>.

Skills and talents

A skill is how good someone has got at something: a level per person that rises with practice, at their own pace, harder the nearer the top, and slips back slowly if they let it go. Declare skills, and say which actions train them:

world.skill({ id: 'baking', label: 'Baking', rate: 0.03, levels: [[0.25, 'competent'], [0.5, 'skilled'], [0.75, 'expert']], decay: 0.01, then: ['feel:proud'] });
world.action({ id: 'bake', at: 'cafe', minutes: 60, job: 'baker', rank: -1, trains: { baking: 1 } });
world.person('mara', { talents: { baking: 1.4 }, skills: { baking: 0.3 }, job: { ... } });

• Practice. When an action with trains ends (or stops), each skill it names gets the time spent on it, times its number: { baking: 1 } is an hour of practice per hour of baking, { baking: 0.5, chat: 0.2 } half that and a little conversation. The game can give practice from outside the simulation with world.train(id, skill, hours) (a lesson, a book: an input), and set a level outright with world.setSkill(id, skill, level). In effects: train:<skill>=hours and skill.<skill>+=0.1.
• The pace. Progress is rate per hour at talent 1, scaled by how much room is left: the gain shrinks with (1 - level / max) to the power diminish. It’s worked out exactly over the hours, so eight hours at once is the same as eight one-hour goes. A person’s talents entry multiplies the rate (Delos inherits talents); the skill’s learn considerations multiply it again (schooling, wit).
• Forgetting. With decay, a skill not practiced for grace days (3) loses decay a day after that, down to floor. It’s worked out when the level is read, so nothing ticks.
• Named levels. Reaching one of levels on the way up logs skill, emits skill { id, skill, level, value }, and runs the skill’s then effects (ctx.data.level is the level’s name).
• Reading them. skill.<id> in conditions and considerations: gate an action (if: ['skill.baking>=0.5']), or weigh it ({ input: 'skill.baking', out: [0.6, 1.4] }); Ceres’ yields can scale what a skilled hand makes. From the game, world.skillOf(id, skill); world.skills.of(person) lists them; world.describe shows them.

Levels live on the person (PersonState.skills: [level, when last practiced]), so they save and rewind.

Pastimes that pall

The same pleasure satisfies less each time, until it’s been let alone a while (Merryfolk’s variety). Mark an action palls, with a kind it shares with others or true for itself alone:

world.pastime({ id: 'drink', label: 'the ale', gain: 0.35, decay: 0.08, penalty: 0.6 });   // optional: a label and its own pace
world.action({ id: 'ale', at: 'tag:drink', minutes: 60, relieves: { fun: 0.4 }, palls: 'drink' });
world.action({ id: 'cider', at: 'tag:drink', minutes: 60, relieves: { fun: 0.35 }, palls: 'drink' });
world.action({ id: 'darts', at: 'tag:drink', minutes: 30, relieves: { fun: 0.3 }, palls: true });

Each go (an action of the kind that ends with more than config.pallDone, 20%, done) adds gain (0.35) to the person’s tolerance for the kind, up to 1; it wears off by decay (0.08) an hour. While it’s over 0.05, every action of the kind weighs 1 - penalty × tolerance (the part had enough of <label>): at full tolerance, 40% of what it would. So people ring the changes, and come back to an old favorite after a few hours. A pastime that palls is exempt from the plain did it last penalty, which this replaces. tolerance:<kind> reads it in conditions; world.describe lists what they’ve had enough of. The defaults are config.pallGain, pallDecay and pallPenalty; a pastime declaration overrides them for its kind.

Wishes and dreams

A wish is a standing goal: it pulls someone toward what would grant it until it comes true, then it’s granted (with its effects, and maybe a wish that follows), or it fades. A dream is a life’s wish: one at a time, and it never fades (The Sims’ wants and aspirations, Merryfolk’s wishes and dreams).

world.wish({ id: 'pint', label: 'A pint at the Belt', if: ['!is:child'], weight: [{ input: 'trait.talkative', out: [0.3, 1.2] }],
  toward: ['drink'], by: ['drink'], then: ['feel:wish_granted'] });
world.wish({ id: 'catch_up', label: 'A good talk with a friend', about: (ctx) => ctx.world.fellowship.friends(ctx.person.id, 1)[0],
  toward: ['tag:social'], by: ['chat'], minutes: 2 * 1440 });
world.wish({ id: 'make_up', label: 'Make it up', when: ['regard>=0.25'] });      // granted by a condition
world.wish({ id: 'master', label: 'Become an expert baker', dream: true, if: ['job:baker'],
  progress: (ctx) => ctx.world.skillOf(ctx.person.id, 'baking') / 0.8, toward: ['bake'] });

• Coming to wish. At each of config.wishHours (8, 13 and 17), each person with fewer than config.wishMax (2) wishes may come to wish one, with probability config.wishChance (0.5): a weighted draw, from their own stream, among the wishes they don’t hold whose if holds, by weight (a number, considerations multiplied, or a function). Someone without a dream may come to dream one the same way. A dream (and any wish with once) is never wished again once it’s come true. The game gives one with world.wishFor(id, wish, about?) (an input), effects with wish:<id>.
• What it’s about. about (a term, or a function of the context) is worked out when it’s wished: a favorite dish, a friend’s id, a number to beat. If it comes out null or undefined, the wish can’t be wished now. It’s kept with the wish (x). When it’s a person, the wish is aimed at them: it pulls only toward options aimed at them (or at nobody), and only an action aimed at them grants it; in its when, then and fades, ctx.target is that person (ctx.data.x holds whatever it’s about, always).
• The pull. While it’s held, options whose id or tag is in toward weigh pull (config.wishPull, 1.35) more: the part wish: <label> (or dream: <label>). At most one wish and one dream count for an option.
• Coming true. A wish is granted when the person finishes an action in its by (ids or tag:<tag>); or when its when conditions hold, checked each hour and whenever they finish something; or, each hour, when its progress (a term or a function, 0..1) reaches 1. The game grants one with world.grant(id, wish), effects with grant:<id>. Granting removes it, counts it (granted:<id>), logs and emits granted, runs then, and gives the next wish, if any.
• Fading. A wish not granted within minutes (config.wishMinutes, a day and a half; 0 never) fades at the next hour: logged and emitted as faded, with its fades effects.

Read them with world.wishesOf(id) (each { id, label, t, until?, x?, dream?, progress? }), the terms wish:<id> (what it’s about, or true, while it’s held), wishes (how many), dream (the dream’s id) and granted:<id>, and in world.describe. Held wishes live on the person (PersonState.wishes, granted), so they save and rewind.

Config

Pass any of these in Tyrell.create({ config: { ... } }). They’re definitions, not state: don’t change them by hand mid-run (a rewind replays with the current values); to change them during play, use world.tune('core', { ... }), an input (Tuning). minutesPerSecond and budgetMs are safe to change directly at any time. The headline knobs (needs, habits, learning, wishes, crowds) and the finer numbers are at the end; Tuning has every field with which way to turn it.

Asking why

const d = world.why('kofi');          // the latest Decision
d.picked;                             // the Candidate chosen: id, place, rank, layer, weight, parts
d.reason;                             // 'need at rank 0; beat read, walk'
world.whyNot('kofi', 'drink');        // "drink at bar weighs 0.12 (base 0.2 x travel 0.6); chat weighed 0.4 (...)"
console.log(world.describe('kofi'));  // needs, mood, doing, plan, beliefs, what's expected, last choice

See Tools for the inspector in full.