Language Guide

@card greeting {
  visit_count: 0
  content: ```
  <p>Hello! This is visit number ${card.visit_count}.</p>
  <p><a card="greeting">Visit again</a></p>
  ```
  on_start: (card) => {
    card.visit_count += 1;
  }
}

@game {
  name: "adventure"
  title: "Sandbags Mythical Adventure"
  initial_scene_id: #sc_opening
  author: "Matt Mower"
  author_email: "self@mattmower.com"
  layout: ```
    <section class="hero">
      <div class="hero-body">
        <p class="title">${game.title}</p>
        <p class="subtitle">By ${game.author}</p>
      </div>
    </section>
    ${content}
  ```
}

@scene opening {
  initial_card_id: #start_here
  blocks: [sidebar: #sidebar]
  layout: ```
    <div class="columns-2">
      <div class="column">${sidebar}</div>
      <div class="column">${content}</div>
    </div>
  ```
}

@card start_here {
  content: ```
  <p>Your adventure begins...</p>
  <p><a card="next_card">Continue</a></p>
  ```
}

description: "A rusty old key"

damage: 15
weight: 2.5
price: -10

magic: true
cursed: false
found: yes      // yes/no also work
hidden: no

material: :gold
rarity: :legendary
type: :weapon

owner_id: #player
location_id: #forest
wielded_by_id: #hero

content: ```
<p>Welcome, ${player.name}!</p>
<p>You have ${player.gold} gold coins.</p>
```

colors: [:red :green :blue]
numbers: [1 2 3 4 5]
names: ["Alice" "Bob" "Charlie"]
items: [#sword #shield #potion]

on_use: (item) => {
  player.health += 10;
  return RezEvent.playCard("feeling_better");
}

use: function() {
  this.uses -= 1;
}

@actor hero {
  first_name: "Sir"
  last_name: "Galahad"

  // This calculates every time it's accessed
  full_name: ^p{
    return `${this.first_name} ${this.last_name}`;
  }

  health: 85
  max_health: 100

  // Perfect for UI elements like health bars
  health_percentage: ^p{
    return this.health * 100 / this.max_health;
  }

  // Boolean states based on other attributes
  is_healthy: ^p{
    return this.health > this.max_health * 0.5;
  }

  is_at_full_health: ^p{
    return this.health >= this.max_health;
  }
}

@actor character {
  strength: 15
  dexterity: 12
  intelligence: 14

  // Calculated modifier (D&D style)
  strength_modifier: ^p{
    return Math.floor((this.strength - 10) / 2);
  }

  dex_modifier: ^p{
    return Math.floor((this.dex - 10) / 2);
  }

  // Total of all stats
  total_stats: ^p{
    return this.strength + this.dexterity + this.intelligence;
  }

  // Armor class calculation
  base_armor: 10
  armor_bonus: 2
  armor_class: ^p{
    return this.base_armor + this.dex_modifier + this.armor_bonus;
  }
}

@actor player {
  gold: 150
  silver: 75
  copper: 200

  // Total wealth in copper pieces
  total_wealth: ^p{
    return this.copper + (this.silver * 10) + (this.gold * 100);
  }

  current_weight: 45
  max_carrying_capacity: 100

  // How much more can be carried
  carrying_capacity_remaining: ^p{
    return Math.max(0, this.max_carrying_capacity - this.current_weight);
  }

  // Whether player is overloaded
  is_encumbered: ^p{
    return this.current_weight > this.max_carrying_capacity;
  }
}

@card welcome {
  content: ```
  <h2>Welcome to the Adventure!</h2>
  <p>You are standing in a medieval village square.</p>
  ```
}

@card status {
  content: ```
  <h3>Character Status</h3>
  <p>Name: ${player.name}</p>
  <p>Level: ${player.level}</p>
  <p>Health: ${player.health}/${player.max_health}</p>
  ```
}

@card status {
  bindings: [player: #main_character]
  content: ```
  <p>Name: ${player.name}</p>
  ```
}

@card example {
  visit_count: 0
  content: ```
  <p>This card has been visited ${card.visit_count} times.</p>
  ```
}

<a card="forest_clearing">Enter the forest</a>

<a scene="dungeon_entrance">Enter the dungeon</a>

<a interlude="conversation">Talk to the Hermit</a>

@card magic_door {
  locked: true
  content: ```
  <p>A mysterious door blocks your path.</p>
  $if(card.locked) {%
    <a event="try_key">Try to unlock with the key</a>
  %}, {%
    <a card="beyond_door">Go through the door</a>
  %}
  ```
  on_try_key: (card) => {
    if(player.has_item("magic_key")) {
      card.locked = false;
      return RezEvent.flash("The key works! The door swings open.");
    } else {
      return RezEvent.flash("You don't have the right key.");
    }
  }
}

<button card="next_scene">Continue Adventure</button>
<button event="cast_spell">Cast Fireball</button>

@component component_name (bindings, assigns, content) => {
  // JavaScript code that returns HTML string
  return `<div>Custom HTML here</div>`;
}

@component health_bar (bindings, assigns, content) => {
  const current = assigns.current || 0;
  const max = assigns.max || 100;
  const percentage = Math.round((current / max) * 100);

  return `
    <div class="health-bar">
      <div class="health-fill" style="width: ${percentage}%"></div>
      <span class="health-text">${current}/${max}</span>
    </div>
  `;
}

content: ```
<.health_bar current="${player.health}" max="${player.max_health}" />
```

@component info_panel (bindings, assigns, content) => {
  const title = assigns.title || "Information";
  const type = assigns.type || "default";

  return `
    <div class="info-panel info-panel--${type}">
      <h3 class="info-panel__title">${title}</h3>
      <div class="info-panel__content">
        ${content}
      </div>
    </div>
  `;
}

content: ```
<.info_panel title="Combat Status" type="warning">
  <p>You are in combat with ${enemy.name}!</p>
  <p>Your health: ${player.health}</p>
</.info_panel>
```

@component inventory_slot (bindings, assigns, content) => {
  const item = assigns.item;
  const index = assigns.index;
  const isEmpty = !item;

  if (isEmpty) {
    return `
      <div class="inventory-slot inventory-slot--empty" data-slot="${index}">
        <div class="slot-placeholder">Empty</div>
      </div>
    `;
  }

  const rarity = item.rarity || "common";
  const quantity = item.quantity > 1 ? `<span class="quantity">${item.quantity}</span>` : "";

  return `
    <div class="inventory-slot inventory-slot--${rarity}" data-slot="${index}">
      <img src="${item.icon}" alt="${item.name}" class="item-icon">
      <div class="item-name">${item.name}</div>
      ${quantity}
      <div class="item-tooltip" data-tooltip="${item.description}"></div>
    </div>
  `;
}

@card tavern {
  bindings: [player: #hero]
  content: ```
  <h3>The Rusty Dragon Tavern</h3>

  $if(player.gold >= 10) -> {%
    <p>You have enough gold for a meal and room.</p>
    <button event="buy_room">Rent a room (10 gold)</button>
  %}
  () -> {%
    <p>You're too poor to afford a room here.</p>
    <button event="work_for_gold">Offer to work for gold</button>
  %}

  $if(player.level >= 5) -> {%
    <p>The bartender nods respectfully at such an experienced adventurer.</p>
  %}
  ```
}

$if(player.health <= 0) -> {%
  <p>You have died!</p>
%}
(player.health < 20) -> {%
  <p>You are badly wounded.</p>
%}
() -> {%
  <p>You feel healthy and strong.</p>
%}

@card inventory {
  bindings: [
    player: #hero,
    items: () => $("hero").inventory.items
  ]
  content: ```
  <h3>Your Inventory</h3>

  $if(items.length > 0) {%
    <ul>
    $foreach(item: items) {%
      <li>${item.name} - ${item.description}</li>
    %}
    </ul>
  %}, {%
    <p>Your inventory is empty.</p>
  %}
  ```
}

$foreach(skill: player.skills) {%
  ${skill.name}: Level ${skill.level}
%}, {%
  <br>
%}

bindings: [
  player: #main_character,
  location: #current_room,
  villain: #dark_lord
]

bindings: [
  total_score: () => {return player.experience + player.gold},
  random_event: () => {return Math.random() < 0.3},
  available_exits: () => {return current_location.getExits()}
]

bindings: [
  player: #player
  player_name: player.name
  current_health: player.health
]

bindings: [
  options: 2
]

@card character_setup {
  bindings: [player: #player]
  content: ```
  <h3>Character Setup</h3>

  <label>Character Name:</label>
  <input type="text" rez-bind="player.name" placeholder="Enter your name">

  <label>Background Story:</label>
  <textarea rez-bind="player.background" rows="4"></textarea>

  <button card="choose_stats">Continue</button>
  ```
}

@card preferences {
  bindings: [settings: #game_settings]
  content: ```
  <h3>Game Preferences</h3>

  <label>
    <input type="checkbox" rez-bind="settings.sound_enabled">
    Enable Sound Effects
  </label>

  <label>
    <input type="checkbox" rez-bind="settings.difficulty_hard">
    Hard Difficulty Mode
  </label>
  ```
}

<h4>Choose your weapon:</h4>
<label>
  <input type="radio" name="weapon" value="sword" rez-bind="player.starting_weapon">
  Sword (+3 Attack)
</label>
<label>
  <input type="radio" name="weapon" value="bow" rez-bind="player.starting_weapon">
  Bow (+2 Attack, +1 Range)
</label>
<label>
  <input type="radio" name="weapon" value="staff" rez-bind="player.starting_weapon">
  Staff (+1 Attack, +2 Magic)
</label>

<label>Starting Location:</label>
<select rez-bind="player.hometown">
  <option value="village">Peaceful Village</option>
  <option value="city">Bustling City</option>
  <option value="forest">Forest Dwelling</option>
  <option value="mountain">Mountain Keep</option>
</select>

@card dynamic_stats {
  content: ```
  <h3>Allocate Stat Points</h3>
  <p>Points remaining: ${card.points_remaining}</p>

  <label>Strength:
    <input type="range" min="1" max="20" rez-bind="player.strength" rez-live>
  </label>

  <label>Intelligence:
    <input type="range" min="1" max="20" rez-bind="player.intelligence" rez-live>
  </label>
  ```

  points_remaining: 20

  on_input: (card, event) => {
    const total = player.strength + player.intelligence;
    card.points_remaining = 20 - total;
    return RezEvent.render();
  }
}

@asset hero_portrait {
  file: "characters/hero.png"
  width: 150
  height: 200
}

@asset background_music {
  file: "audio/tavern_theme.mp3"
}

@asset treasure_sound {
  file: "audio/treasure_found.wav"
}

@card character_sheet {
  content: ```
  <h3>Character Information</h3>
  <div class="character-display">
    <.img name="hero_portrait" class="character-image" />
    <div class="character-stats">
      <p><strong>Name:</strong> ${player.name}</p>
      <p><strong>Level:</strong> ${player.level}</p>
    </div>
  </div>
  ```
}

<img src='${"hero_portrait" | asset_path}' alt="Hero Portrait" class="portrait">

@card location_view {
  bindings: [
    location_image: () => {
      if (player.location === "forest") return "forest_scene";
      if (player.location === "dungeon") return "dungeon_scene";
      return "default_scene";
    }
  ]
  content: ```
  <div class="location-display">
    <img src='${location_image | asset_path}' alt="Current Location">
    <p>${location.description}</p>
  </div>
  ```
}

@card victory {
  content: ```
  <h2>Victory!</h2>
  <p>You have defeated the dragon and claimed the treasure!</p>
  <audio autoplay>
    <source src='${"victory_music" | asset_path}' type="audio/mpeg">
  </audio>
  ```
}

@elem npc = actor

@npc village_guard {
  name: "Guard"
  occupation: "Village Protector"
  dialogue: "Halt! State your business."
}

@elem monster = actor

@defaults monster {
  hostile: true
  experience_reward: 10
  gold_reward: 5
  behavior_pattern: :aggressive
}

@monster goblin {
  name: "Goblin Warrior"
  health: 25
  attack_power: 8
  // Inherits: hostile: true, experience_reward: 10, etc.
}

@mixin combat_capable {
  health: 100
  max_health: 100
  attack_power: 10
  defense: 5

  take_damage: function(amount) {
    this.health = Math.max(0, this.health - amount);
    return this.health <= 0;
  }

  heal: function(amount) {
    this.health = Math.min(this.max_health, this.health + amount);
  }
}

@elem warrior = actor<#combat_capable>
@elem guardian = actor<#combat_capable>

@warrior player_character {
  name: "Hero"
  // Automatically gets all combat_capable attributes and methods
}

@mixin magic_user {
  mana: 50
  max_mana: 50
  spell_power: 12
}

@elem battle_mage = actor<#combat_capable, #magic_user>

@actor smart_guard {
  name: "Intelligent Guard"

  behaviors: ^[
    $select
      [$sequence
        [player_nearby range=3]
        [guard_not_alerted]
        [set_alert_level level=1]]
      [$sequence
        [alert_level_equals level=2]
        [call_for_backup]]
      [patrol_route]
  ]
}

behaviors: ^[
  $select
    [has_weapon]      // Try this first
    [find_weapon]     // If no weapon, try to find one
    [flee_combat]     // Last resort: run away
]

behaviors: ^[
  $sequence
    [see_enemy]       // First, spot an enemy
    [weapon_ready]    // Then, make sure weapon is ready
    [attack_enemy]    // Finally, attack
]

behaviors: ^[
  $parallel
    [patrol_area]     // Keep patrolling
    [watch_for_threats] // While watching for danger
]

@behaviour player_nearby {
  options: ["range"]
  execute: function(owner, behaviour, wmem) {
    const range = behaviour.option("range");
    const distance = owner.distanceTo($("player"));

    return {
      success: distance <= range,
      wmem: wmem
    };
  }
}

@behaviour set_alert_level {
  options: ["level"]
  execute: function(owner, behaviour, wmem) {
    const level = behaviour.option("level");
    owner.alert_level = level;

    return {
      success: true,
      wmem: wmem
    };
  }
}

@actor tavern_keeper {
  name: "Bartender Bob"
  mood: :neutral
  reputation_with_player: 0
  last_interaction: 0

  behaviors: ^[
    $select
      // Emergency responses
      [$sequence
        [tavern_on_fire]
        [evacuate_tavern]]

      // Player interactions
      [$sequence
        [player_at_bar]
        [$select
          [$sequence
            [player_reputation_high]
            [greet_warmly]]
          [$sequence
            [player_reputation_low]
            [greet_coldly]]
          [greet_neutrally]]]

      // Idle behaviors
      [$sequence
        [no_customers_present]
        [$select
          [clean_glasses]
          [restock_bottles]
          [count_money]]]

      // Default: serve customers
      [serve_random_customer]
  ]
}

@behaviour player_at_bar {
  execute: function(owner, behaviour, wmem) {
    const player_location = $("player").current_location;
    return {
      success: player_location === "tavern_bar",
      wmem: wmem
    };
  }
}

@behaviour greet_warmly {
  execute: function(owner, behaviour, wmem) {
    const greetings = [
      "Welcome back, friend! The usual?",
      "Good to see you again! What can I get you?",
      "My favorite customer! What brings you here today?"
    ];

    owner.current_dialogue = greetings.randomElement();
    $("game").trigger_event("npc_speaks", {npc: owner, text: owner.current_dialogue});

    return {success: true, wmem: wmem};
  }
}

@script {
  // Dice rolling utilities
  function rollDie(sides) {
    return Math.floor(Math.random() * sides) + 1;
  }

  function rollDice(count, sides, modifier = 0) {
    let total = modifier;
    for (let i = 0; i < count; i++) {
      total += rollDie(sides);
    }
    return total;
  }

  // Combat calculation helpers
  function calculateDamage(attacker, defender) {
    const baseDamage = rollDice(2, 6) + attacker.strength_modifier;
    const mitigatedDamage = Math.max(1, baseDamage - defender.armor_class);
    return mitigatedDamage;
  }
}

@stylesheet {
  .character-sheet {
    border: 2px solid #8B4513;
    border-radius: 10px;
    padding: 20px;
    background: linear-gradient(135deg, #F5E6D3, #E8D5B7);
    box-shadow: 0 4px 8px rgba(0,0,0,0.3);
  }

  .health-bar {
    width: 100%;
    height: 20px;
    background-color: #444;
    border: 2px solid #000;
    border-radius: 10px;
    overflow: hidden;
  }

  .health-fill {
    height: 100%;
    background: linear-gradient(90deg, #ff4444, #ffaa44, #44ff44);
    transition: width 0.3s ease;
  }

  .combat-actions button {
    background: #8B4513;
    color: white;
    border: none;
    padding: 10px 20px;
    margin: 5px;
    border-radius: 5px;
    cursor: pointer;
    font-size: 16px;
  }

  .combat-actions button:hover {
    background: #A0522D;
    transform: translateY(-2px);
  }

  .flash-message {
    background: #FFD700;
    border: 2px solid #FFA500;
    padding: 10px;
    margin: 10px 0;
    border-radius: 5px;
    text-align: center;
    font-weight: bold;
  }
}

@patch {
  patch: "Array"
  method: "sample"
  impl: function(count = 1) {
    const shuffled = [...this].sort(() => 0.5 - Math.random());
    return count === 1 ? shuffled[0] : shuffled.slice(0, count);
  }
}

// Now you can use:
// ["red", "green", "blue"].sample()  -> "green"
// [1,2,3,4,5].sample(3)  -> [3, 1, 5]

@filter DICE_ROLL_FILTER {
  name: "roll"
  impl: (dice_notation) => {
    // Parse "2d6+3" format
    const match = dice_notation.match(/(\d+)d(\d+)(?:\+(\d+))?/);
    if (!match) return 0;

    const count = parseInt(match[1]);
    const sides = parseInt(match[2]);
    const modifier = parseInt(match[3]) || 0;

    return rollDice(count, sides, modifier);
  }
}

// Use in templates:
// <p>You rolled ${"2d6+3" | roll} damage!</p>

@actor hero {
  name: "Brave Knight"
  health: 100

  heal: function(amount) {
    this.health += amount;
  }
}

// Becomes at runtime:
const hero = new RezActor({
  id: "hero",
  name: "Brave Knight",
  health: 100,
  heal: function(amount) {
    this.health += amount;
  }
});

<div class="game">                    <!-- Game wrapper -->
  <!-- Game layout content -->
  <div class="scene" id="scene_forest"> <!-- Scene wrapper -->
    <!-- Scene layout content -->
    <div class="card" id="card_clearing"> <!-- Card wrapper -->
      <!-- Card content -->
    </div>
  </div>
</div>

@actor player {
  $global: true
  name: "Hero"
}

// Accessible as: window.$player or just $player

visible: true
completed: false
enabled: yes     // yes/no also work
hidden: no

count: 42
price: 19.99
temperature: -10
percentage: 0.85

name: "Magic Sword"
description: "A blade that glows with inner light"
note: ""  // Empty string

type: :weapon
rarity: :legendary
status: :active
category: :consumable

owner_id: #player
location_id: #forest_clearing
target_id: #dragon

colors: [:red :green :blue]
scores: [100 250 75 420]
items: [#sword #shield #potion]
mixed: ["text" 42 :keyword #reference]

tags: #{:magical :rare :weapon}
visited_locations: #{#town #forest #cave}

content: ```
<h2>${title}</h2>
<p>Welcome, ${player.name}!</p>
$if(player.level > 5) {%
  <p>You are an experienced adventurer.</p>
%}
```

bindings: [
  player: #main_character,
  location: () => player.current_location,
  gold: &player.gold
]

@object treasure_horde {
  gold: ^i:1{return Math.rand_int_between(20, 50);}
  silver: ^i:2{return Math.rand_int_between(this.gold, 200);}
  copper: ^i{return Math.rand_int_between(this.silver, 1000);}
}

@actor player {
  movement_speed: ^p{
    let speed = this.base_speed || 30;
    if (this.is_encumbered) speed = Math.floor(speed / 2);
    if (this.hasCondition?.("haste")) speed *= 2;
    if (this.hasCondition?.("slow")) speed = Math.floor(speed / 2);
    return Math.max(0, speed);
  }
}

@card c_player_run {
  bindings: [
    player: #player
  ]

  content: ```
  <p>Your character can run at ${player.speed} meters per second.</p>
  ```
}

@actor player {
  spells_cast: ^d:spell_book

  spell_book_id: #player_spell_book
}

@object player_spell_book {
  spells_cast: 0
}

@item sword_template {
  $template: true
  damage: ^i{return Math.rand_int_between(6, 8)}
  name: "Iron Sword"
}

@actor player {
  weapon_id: ^c:#sword_template
}

@item weapon_template {
  $template: true
  on_copy: (obj, evt) => {
    console.log(`Created ${obj.id} from ${evt.original.id}`);
  }
}

@actor hero {
  main_hand_id: ^c:1:#weapon_template
  off_hand_id: ^c:2:#weapon_template
}

damage: ^r:2d6+3      // Roll 2 six-sided dice, add 3
treasure: ^r:d100     // Roll 1 hundred-sided die
healing: ^r:1d4+1     // Roll 1 four-sided die, add 1

loot_type: |:common 60 :uncommon 25 :rare 10 :legendary 5|
encounter: |#goblin 40 #orc 30 #troll 20 #dragon 10|
weather: |"sunny" 50 "cloudy" 30 "rainy" 15 "stormy" 5|

on_use: (item, event) => {
  player.health += item.healing_power;
  return RezEvent.flash("You feel better!");
}

on_enter: (scene, event) => {
  scene.visit_count = (scene.visit_count || 0) + 1;
  return RezEvent.render();
}

attack: function(target) {
  const damage = this.attack_power + rollDie(6);
  target.health -= damage;
  return damage;
}

canAfford: function(price) {
  return this.gold >= price;
}

behaviors: ^[
  $select
    [$sequence
      [health_low]
      [has_potion]
      [use_potion]]
    [$sequence
      [enemy_nearby]
      [attack_enemy]]
    [wander_around]
]

$global: true          // Create global variable
$template: true        // Mark as template for copying
$js_ctor: "CustomClass" // Use different JavaScript constructor
$built_in: true        // Mark as built-in (documentation only)

@actor player {
  nemesis_id: #villain_1
}

@actor villian_1 {
  name: "Suruman of Many Colours"
}

@card c_player_nemesis {
  bindings: [
    player: #player
  ]
  content: ```
  <p>Your current nemesis is ${player.nemesis.name}.</p>
  ```
}

@actor villain_2 {
  name: "Sauron"
}

@actor player {
  on_return_of_the_king: (player) => {
    // These two lines are equivalent
    player.nemesis_id = "villain_2";
    player.nemesis = $("villain_2");
  }
}

src/
├── game.rez              # Main game definition
├── characters/
│   ├── player.rez        # Player character
│   ├── npcs.rez          # Non-player characters
│   └── monsters.rez      # Enemy creatures
├── locations/
│   ├── town.rez          # Town scenes and cards
│   ├── dungeon.rez       # Dungeon areas
│   └── overworld.rez     # World map
├── items/
│   ├── weapons.rez       # Weapon definitions
│   ├── armor.rez         # Armor and protection
│   └── consumables.rez   # Potions, scrolls, etc.
└── systems/
    ├── combat.rez        # Combat mechanics
    ├── inventory.rez     # Inventory management
    └── dialogue.rez      # Conversation system

// In game.rez
@game {
  name: "My Adventure"
  // ... game definition
}

%(characters/player.rez)
%(characters/npcs.rez)
%(locations/town.rez)
%(items/weapons.rez)
%(systems/combat.rez)

// Scenes: describe location or context
@scene forest_entrance
@scene combat_arena
@scene character_creation

// Cards: describe content or action
@card explore_clearing
@card merchant_dialogue
@card level_up_screen

// Actors: role or name
@actor village_guard
@actor evil_wizard
@actor shop_keeper

// Items: descriptive names
@item rusty_sword
@item healing_potion
@item magic_amulet

@game {
  name: "Adventure Game"

  // Global game state
  current_chapter: 1
  player_score: 0
  game_flags: {}

  // Helper methods for state
  setFlag: function(name, value = true) {
    this.game_flags[name] = value;
  }

  getFlag: function(name) {
    return this.game_flags[name] || false;
  }

  addScore: function(points) {
    this.player_score += points;
    if (this.player_score >= 1000) {
      this.setFlag("high_score_achieved");
    }
  }
}

@card examine_item {
  bindings: [
    target_item: () => {
      const itemId = $("game").selected_item_id;
      return itemId ? $(itemId) : null;
    }
  ]
  content: ```
  $if(target_item) {%
    <h3>${target_item.name}</h3>
    <p>${target_item.description}</p>
    <button event="use_item">Use Item</button>
  %}, {%
    <p>No item selected to examine.</p>
    <button card="inventory">Back to Inventory</button>
  %}
  ```
}

// Use ^p{} for values that change frequently and need to be current
health_percentage: ^p{return this.health * 100 / this.max_health;}

// Use ^i{} for complex setup that rarely changes
starting_equipment: ^i{
  return this.character_class === "warrior"
    ? ["sword", "shield", "armor"]
    : ["dagger", "lockpicks", "cloak"];
}

// Use regular attributes for values that change manually
experience: 0  // Updated by events, not calculated

// Use ^i{} with manual updates for expensive calculations
threat_level: ^i{return this.calculateThreatLevel();}
recalculate_threat: function() {
  this.threat_level = this.calculateThreatLevel();
}

// Good: use dynamic properties to move calculations out of templates
@actor player {
  base_attack: 10
  strength: 15
  attack_power: ^p{return this.base_attack + Math.floor(this.strength / 2);}
}

content: ```
Attack Power: ${player.attack_power}
```

// Less good: calculate every time template renders
content: ```
Attack Power: ${player.base_attack + Math.floor(player.strength / 2)}
```