playbooks

home / skills / simhacker / moollm / time

time skill

/skills/time

This skill helps you reason about simulation turns versus LLM iterations, clarifying timing and pacing for game-like narratives.

npx playbooks add skill simhacker/moollm --skill time

Review the files below or copy the command above to add this skill to your agents.

Files (5)
SKILL.md
1.1 KB
---
name: time
description: "Motto: Time flows as the story requires."
license: MIT
tier: 1
allowed-tools:
  - read_file
  - write_file
related: [simulation, adventure, buff, needs, action-queue, speed-of-light, session-log]
tags: [moollm, turns, duration, narrative, flow]
---

# Time Skill

Simulation turns vs LLM iterations.

**Motto:** *"Time flows as the story requires."*

## Key Concepts

- **Simulation turns** — Game time, what mechanics track
- **LLM iterations** — Meta-level, one response
- **They're not the same!** One LLM response might be 0, 1, or many turns

## Turn Definition

| Action | Turns |
|--------|-------|
| GO NORTH | 1 |
| PAT TERPIE | 1 |
| LOOK | 0 |
| INVENTORY | 0 |
| Pet all 8 kittens | 8 |
| Take a nap | ~10 |

## Duration Types

- **Turns** — X simulation turns (primary unit)
- **Conditional** — Until condition met
- **While present** — While in location/with item
- **Permanent** — Until explicitly removed

## See Also

- [buff](../buff/) — Buff durations use simulation turns
- [needs](../needs/) — Needs decay over simulation turns

Overview

This skill models the relationship between game simulation time (turns) and language model iterations. It makes explicit that an LLM response is a meta-level event and can correspond to zero, one, or many simulation turns. Motto: "Time flows as the story requires."

How this skill works

The skill classifies actions by how many simulation turns they consume and by duration type. Simple commands like movement or discrete interactions consume one or more turns, while informational commands consume zero turns. It also supports duration types such as fixed turns, conditional durations, while-present durations, and permanent effects.

When to use it

  • Designing turn-based game mechanics that mix player input and automated simulation.
  • Mapping narrative LLM responses to in-world time progression.
  • Implementing buffs, needs, or timed effects that must decay with simulation time.
  • Deciding which commands should advance time and which should not.
  • Balancing game pacing when LLM iterations and turns diverge.

Best practices

  • Treat LLM iterations as separate from simulation turns; explicitly choose how many turns each response advances.
  • Use zero-turn commands for pure information queries (e.g., LOOK, INVENTORY) to avoid unintended time progression.
  • Define clear duration types: fixed turns, conditional, while-present, and permanent.
  • Document turn costs for all player actions and common macros (e.g., petting multiple animals).
  • Prefer deterministic turn accounting for mechanics like buffs and needs to ensure consistent decay.

Example use cases

  • Move the player north: consume 1 simulation turn and resolve environment changes.
  • LOOK or INVENTORY: return information with 0 turns consumed to keep timing intact.
  • Pet all 8 kittens: count as 8 turns, useful for stamina or social mechanics.
  • Take a nap: model as multi-turn sleep (e.g., ~10 turns) with conditional wake triggers.
  • Apply a buff that lasts 30 simulation turns or until a condition is met.

FAQ

Can one LLM response map to multiple turns?

Yes. A single response can represent many simulation turns when the narrative advances time or summarizes extended actions.

Should LOOK always cost zero turns?

Generally yes—reserve zero-turn commands for information-only queries to prevent accidental progression, unless you intentionally want observation to consume time.

How do I choose between fixed and conditional durations?

Use fixed durations for predictable effects and conditional durations when the effect should end based on in-world events or player actions.