path: root/skill_plans/thieving.md

# Thieving Skill Implementation Plan

## 1. Overview

Thieving is a gathering-category skill that allows players to steal from mobs and objects. Unlike mining/fishing/woodcutting which use the behavior-YAML-driven `gather` system, thieving is a **hardcoded action type** (like `burn` and `search`) because it has unique mechanics:

- Mob aggro on failure (mobs turn hostile)
- Guard watching cycles on objects (tick-based state machine)
- Guard spawning on watched-object failures
- Sneak mode toggle with real-time guard awareness notifications

The skill uses the existing `Thieving` constant already defined in `internal/player/player.go` (line 25, abbreviation `"thv"` at line 57).

Commands: `steal` (active), `sneak` (instant toggle). Aliases: `thieve` maps to `steal`.

---

## 2. Commands

### `steal` / `thieve`

- **Classification:** `ClassActive`
- **Aliases:** `thieve` → `steal` (added to `verbAliases` in `action.go`)
- **Syntax:**
  - `steal` — auto-resolves if only one stealable target (mob or object) in room
  - `steal <target>` — steal from a specific mob or object by name
  - `steal 2.man` — steal from the 2nd man (numbered targeting)
- **Behavior:** Searches mobs first (reversed from `StartAction` which searches objects first), then objects. This is because stealing from mobs is the primary use case.

### `sneak`

- **Classification:** `ClassInstant`
- **Syntax:** `sneak` — toggles sneak mode on/off
- **Behavior:** Sets `p.Sneaking` (new bool field on Player, transient/not saved). While sneaking, `SneakTick()` sends guard-watching notifications each tick.

---

## 3. New Files to Create

### Go Files

| File | Purpose |
|---|---|
| `internal/game/action_steal.go` | `doSteal()`, `startSteal()`, `advanceSteal()`, `resolveStealTarget()`, mob aggro logic, guard alert logic |
| `internal/game/cmd_sneak.go` | `doSneak()` toggle handler, `SneakTick()` for guard-watching notifications |

### YAML Data Files

| File | Purpose |
|---|---|
| `data/items/credit_stick.yaml` | Credit stick item (searchable) |
| `data/items/potato_seed.yaml` | Low-value seed |
| `data/items/onion_seed.yaml` | Low-value seed |
| `data/items/cabbage_seed.yaml` | Low-value seed |
| `data/items/tomato_seed.yaml` | Low-mid value seed |
| `data/items/sweetcorn_seed.yaml` | Mid value seed |
| `data/items/strawberry_seed.yaml` | Mid value seed |
| `data/items/watermelon_seed.yaml` | Mid-high value seed |
| `data/items/ranarr_seed.yaml` | High value seed |
| `data/items/snapdragon_seed.yaml` | High value seed |
| `data/items/torstol_seed.yaml` | Very high value seed |
| `data/items/bread.yaml` | Low-value food from stall |
| `data/items/apple.yaml` | Low-value food from stall |
| `data/items/cheese.yaml` | Low-value food from stall |
| `data/objects/market_stall.yaml` | Market stall object (stealable) |
| `data/mobs/farmer.yaml` | Farmer mob (stealable, low-mid seeds) |
| `data/mobs/bioengineer.yaml` | Bioengineer mob (stealable, mid-high seeds) |
| `data/drops/credit_stick_drop.yaml` | Drop table for credit stick search |
| `data/drops/man_steal.yaml` | Drop table for stealing from man |
| `data/drops/farmer_steal.yaml` | Drop table for stealing from farmer |
| `data/drops/bioengineer_steal.yaml` | Drop table for stealing from bioengineer |
| `data/drops/market_stall_steal.yaml` | Drop table for stealing from market stall |
| `data/behaviors/stall_guard_talk.yaml` | Talk behavior for the guard who catches you |
| `data/rooms/150.yaml` | Market Square (stall + guard + men) |
| `data/rooms/151.yaml` | Farm Outpost (farmer + bioengineer) |
| `data/rooms/152.yaml` | Detention Cell (jail room) |
| `data/help/steal.yaml` | Help topic for steal |
| `data/help/sneak.yaml` | Help topic for sneak |
| `data/help/thieving.yaml` | Help topic for thieving skill |

---

## 4. Code Changes to Existing Files

### `internal/player/player.go`

Add a transient `Sneaking` field to the `Player` struct:

```go
// In the Player struct, after the existing transient fields:
Sneaking         bool                         `yaml:"-"`
```

Add after line 174 (`VisualTickCurrent int`):
```go
Sneaking          bool                         `yaml:"-"`
```

### `internal/game/action_state.go`

Add the new `ActionType` constant. After `ActionEating` (line 24):

```go
ActionStealing ActionType = "stealing"
```

Add a `Description()` case inside the switch (after the `ActionEating` case, around line 75):

```go
case ActionStealing:
    return "stealing from " + a.TargetName
```

### `internal/game/action.go`

Add `steal` aliases to `verbAliases` map (after `"push": "toggle"` on line 27):

```go
"steal":  "steal",
"thieve": "steal",
```

Add to `verbSkill` map (after `"shear": "crafting"` on line 36):

```go
"steal":  "thieving",
"thieve": "thieving",
```

Add `"steal"` case to `AdvanceActions()` switch (after `case "search":` block, around line 235):

```go
case "steal":
    g.advanceSteal(sess, p)
```

### `internal/game/game.go`

#### `classifyCommand()` — line 136

Add `"sneak"` to the `ClassInstant` list (line 138-142):

```go
case "say", "score", "sc", "inventory", "i", "inv",
    "look", "l", "exits", "help",
    "map", "option", "options", "alias", "unalias",
    "description", "desc", "queued", "color", "colors",
    "colortable", "prompt", "style", "sneak":
    return ClassInstant
```

Add `"steal", "thieve"` to the `ClassActive` list (line 146-151):

```go
case "get", "take", "grab", "pick", "drop",
    "attack", "kill",
    "north", "n", "south", "s", "east", "e",
    "west", "w", "up", "u", "down", "d",
    "quit", "use", "burn", "stoke", "search", "walk", "cook", "smelt", "smith", "craft",
    "steal", "thieve":
    return ClassActive
```

#### `executeCommand()` — line 249

Add `"sneak"` case in the instant section (after the `"colortable"` case, around line 329):

```go
case "sneak":
    g.doSneak(sess)
```

Add `"steal", "thieve"` case in the active section (after the `"search"` block, around line 417):

```go
case "steal", "thieve":
    g.CancelAction(p)
    if len(args) == 0 {
        g.doSteal(sess, "")
    } else {
        g.doSteal(sess, strings.Join(args, " "))
    }
    return
```

#### `ProcessQueuedCommands()` — line 457

Add `ActionStealing` to the list of persistent action states that don't get cleared (line 472):

```go
case ActionGathering, ActionCombating, ActionUsing, ActionTalking,
    ActionToggling, ActionBurning, ActionStoking, ActionResting, ActionWalking, ActionProducing,
    ActionStealing:
```

### `cmd/mud/main.go`

Add `SneakTick()` to the tick subscriber (after `g.VisualTick()` on line 55):

```go
g.SneakTick()
```

### `internal/world/mob.go`

Add steal-related fields to `MobDef` struct (after `Drops` field, line 36):

```go
StealTable    string  `yaml:"steal_table"`
StealLevel    int     `yaml:"steal_level"`
StealXP       int     `yaml:"steal_xp"`
StealSpeed    float64 `yaml:"steal_speed"`
```

Add corresponding runtime fields to `MobInstance` struct (after `regenerateTick` field, line 61):

```go
StealTable    string
StealLevel    int
StealXP       int
StealSpeed    float64
```

In the mob instantiation function (wherever `MobInstance` is created from `MobDef`, in `mob.go`), copy the steal fields:

```go
inst.StealTable = def.StealTable
inst.StealLevel = def.StealLevel
inst.StealXP = def.StealXP
inst.StealSpeed = def.StealSpeed
```

Search for `func (s *MobStore) spawnMob` or equivalent — it's the function that creates `MobInstance` from `MobDef`. The steal fields must be copied there. Around line 160-200 in `mob.go`, find where instances are built and add the four field copies.

### `internal/object/object.go`

Add steal-related fields to `ObjectDef` struct:

```go
StealTable    string `yaml:"steal_table"`
StealLevel    int    `yaml:"steal_level"`
StealXP       int    `yaml:"steal_xp"`
StealSpeed    float64 `yaml:"steal_speed"`
GuardMob      string `yaml:"guard_mob"`
```

- `steal_table`: Drop table ID for loot when stealing from this object
- `steal_level`: Required thieving level
- `steal_xp`: XP awarded per successful steal
- `steal_speed`: Ticks per steal attempt (base wait)
- `guard_mob`: Mob def ID that guards this object (watches it)

---

## 5. Items

### `data/items/credit_stick.yaml`

```yaml
id: credit_stick
name: credit stick
color: "220"
description: "A small electronic stick loaded with credits. You can search it to extract the credits."
value: 10
stackable: false
search_table: credit_stick_drop
search_ticks: 2
search_message: "cracking open the credit stick"
```

### `data/items/bread.yaml`

```yaml
id: bread
name: bread
color: "179"
description: "A crusty loaf of bread."
value: 5
stackable: false
heal_value: 3
eat_message: "You eat the bread. Not bad."
```

### `data/items/apple.yaml`

```yaml
id: apple
name: apple
color: "196"
description: "A bright red apple."
value: 3
stackable: false
heal_value: 2
eat_message: "You eat the apple. Refreshing."
```

### `data/items/cheese.yaml`

```yaml
id: cheese
name: cheese
color: "226"
description: "A wedge of sharp cheese."
value: 4
stackable: false
heal_value: 2
eat_message: "You eat the cheese. Tasty."
```

### `data/items/potato_seed.yaml`

```yaml
id: potato_seed
name: potato seed
color: "94"
description: "A seed for growing potatoes."
value: 2
stackable: true
```

### `data/items/onion_seed.yaml`

```yaml
id: onion_seed
name: onion seed
color: "229"
description: "A seed for growing onions."
value: 3
stackable: true
```

### `data/items/cabbage_seed.yaml`

```yaml
id: cabbage_seed
name: cabbage seed
color: "34"
description: "A seed for growing cabbages."
value: 4
stackable: true
```

### `data/items/tomato_seed.yaml`

```yaml
id: tomato_seed
name: tomato seed
color: "196"
description: "A seed for growing tomatoes."
value: 8
stackable: true
```

### `data/items/sweetcorn_seed.yaml`

```yaml
id: sweetcorn_seed
name: sweetcorn seed
color: "226"
description: "A seed for growing sweetcorn."
value: 25
stackable: true
```

### `data/items/strawberry_seed.yaml`

```yaml
id: strawberry_seed
name: strawberry seed
color: "197"
description: "A seed for growing strawberries."
value: 40
stackable: true
```

### `data/items/watermelon_seed.yaml`

```yaml
id: watermelon_seed
name: watermelon seed
color: "34"
description: "A seed for growing watermelons."
value: 80
stackable: true
```

### `data/items/ranarr_seed.yaml`

```yaml
id: ranarr_seed
name: ranarr seed
color: "28"
description: "A rare herb seed with potent alchemical properties."
value: 500
stackable: true
```

### `data/items/snapdragon_seed.yaml`

```yaml
id: snapdragon_seed
name: snapdragon seed
color: "92"
description: "An extremely rare herb seed. Highly valued by alchemists."
value: 1500
stackable: true
```

### `data/items/torstol_seed.yaml`

```yaml
id: torstol_seed
name: torstol seed
color: "46"
description: "The rarest of herb seeds. Worth a small fortune."
value: 5000
stackable: true
```

---

## 6. Mobs

### `data/mobs/man.yaml` (UPDATE existing file)

Add `steal_table`, `steal_level`, `steal_xp`, and `steal_speed` fields:

```yaml
id: man
name: man
description: "A shabby-looking man loitering in the town square."
combat_descriptions:
  - "is engaged in a fight to the death with %s"
  - "is getting pummelled by %s"
  - "is locked in combat with %s"
  - "trades blows with %s"
  - "circles warily around %s"
idle_descriptions:
  - "scribbles something in a small notebook"
  - "gazes skyward at the clouds"
  - "leans against a wall, looking bored"
  - "scratches his head thoughtfully"
  - "stares off into the distance"
  - "adjusts his tunic and stretches"
attack: 1
strength: 1
defense: 1
hp: 7
speed: 5
aggressive: false
respawn_ticks: 30
steal_table: man_steal
steal_level: 1
steal_xp: 8
steal_speed: 4
drops:
  remains: "bones"
  loot:
    - item_id: "credits"
      weight: 98
      quantity: 10
    - item_id: "credits"
      weight: 2
      quantity: 150
```

### `data/mobs/farmer.yaml`

```yaml
id: farmer
name: Farmer
description: "A weathered farmer in muddy overalls, pockets bulging with seeds."
combat_descriptions:
  - "swings a shovel at %s"
  - "is getting beaten by %s"
  - "grapples with %s"
idle_descriptions:
  - "examines a handful of seeds"
  - "wipes dirt from his hands"
  - "mutters about the growing season"
  - "adjusts his wide-brimmed hat"
attack: 3
strength: 3
defense: 3
hp: 15
speed: 5
aggressive: false
respawn_ticks: 40
steal_table: farmer_steal
steal_level: 10
steal_xp: 15
steal_speed: 4
drops:
  remains: "bones"
  loot:
    - item_id: "potato_seed"
      weight: 40
      quantity: 3
    - item_id: "onion_seed"
      weight: 30
      quantity: 2
    - item_id: "cabbage_seed"
      weight: 20
      quantity: 2
    - item_id: "tomato_seed"
      weight: 10
      quantity: 1
```

### `data/mobs/bioengineer.yaml`

```yaml
id: bioengineer
name: Bioengineer
description: "A lab-coated scientist carrying a satchel of genetically modified seeds. Her pockets are stuffed with rare specimens."
combat_descriptions:
  - "jabs a syringe at %s"
  - "is being overpowered by %s"
  - "fights desperately against %s"
idle_descriptions:
  - "scribbles notes on a clipboard"
  - "carefully inspects a vial of green liquid"
  - "adjusts her safety goggles"
  - "mutters about gene splicing yields"
attack: 6
strength: 4
defense: 5
hp: 25
speed: 5
aggressive: false
respawn_ticks: 50
steal_table: bioengineer_steal
steal_level: 38
steal_xp: 45
steal_speed: 4
drops:
  remains: "bones"
  loot:
    - item_id: "sweetcorn_seed"
      weight: 30
      quantity: 2
    - item_id: "strawberry_seed"
      weight: 25
      quantity: 1
    - item_id: "watermelon_seed"
      weight: 15
      quantity: 1
    - item_id: "ranarr_seed"
      weight: 5
      quantity: 1
```

---

## 7. Objects

### `data/objects/market_stall.yaml`

```yaml
id: market_stall
name: Market Stall
description: "A wooden stall piled with food and sundries. The vendor doesn't seem particularly attentive."
inroom_description: "A bustling {179}market stall{/} is set up here."
hidden: false
steal_table: market_stall_steal
steal_level: 5
steal_xp: 12
steal_speed: 5
guard_mob: guard
```

Note: `guard_mob: guard` means a mob with def ID `guard` in the same room is watching this stall. The `guard_mob` field is a reference — the actual mob must be placed in the room YAML via the `mobs:` list. If the guard mob is present in the room at the time of the steal, the watching mechanic activates.

---

## 8. Rooms

### `data/rooms/150.yaml` — Market Square

```yaml
id: 150
name: "Market Square"
description: "A noisy open-air market wedged between crumbling hab-blocks. Vendors hawk salvaged tech and reconstituted food from makeshift stalls. A {220 bold}Guard{/} watches over the area with a stern expression."
map_symbol: "M"
exits:
  south: 100
objects:
  - id: market_stall
mobs:
  - id: man
    wander_interval: 15
  - id: man
    wander_interval: 18
  - id: man
    wander_interval: 20
  - id: guard
```

### `data/rooms/151.yaml` — Farm Outpost

```yaml
id: 151
name: "Farm Outpost"
description: "A cluster of hydroponic grow-pods on the asteroid's surface, shielded by a flickering atmospheric dome. Rows of bio-luminescent crops stretch into the distance."
map_symbol: "F"
exits:
  west: 150
mobs:
  - id: farmer
    wander_rooms: [151]
  - id: farmer
    wander_rooms: [151]
  - id: bioengineer
    wander_rooms: [151]
```

### `data/rooms/152.yaml` — Detention Cell

```yaml
id: 152
name: "Detention Cell"
description: "A small, grimy holding cell. The walls are scratched with tally marks from previous occupants. A heavy door bars the only exit."
map_symbol: "J"
exits:
  south: 100
```

### Room connectivity

Add an exit from room 100 (Grand Concourse) to room 150:

In `data/rooms/100.yaml`, add `north: 110` already exists. Add `south: 150`:

```yaml
id: 100
name: "Grand Concourse"
description: "The expansive white platform of Station X1's main thoroughfare. Neon strips pulse along the ceiling, reflecting off polished permacrete floors. Citizens and synthetics stream past in a constant dance of commerce and purpose."
map_symbol: "+"
exits:
  east: 101
  north: 110
  south: 150
```

Add an exit from room 150 to 151:

Already handled: room 150 has `south: 100`, and room 151 has `west: 150`. Add `east: 151` to room 150's exits.

Updated room 150 exits:
```yaml
exits:
  south: 100
  east: 151
```

---

## 9. Mechanics

### Steal Success Formula

Uses the existing `SuccessChance` pattern from `internal/action/store.go`:

```
chance = base + (thievingLevel - requiredLevel) * perLevel
clamped to [0, cap]
```

Constants (hardcoded in `action_steal.go`):

```go
var stealSuccess = action.SuccessFormula{
    Base:     0.5,
    PerLevel: 0.03,
    Cap:      0.95,
}
```

When a guard mob is watching (see Guard Watching Cycle), the chance is halved:

```go
if guardWatching {
    chance *= 0.5
}
```

Minimum chance is 0.05 (5%) even when halved.

### Steal from Mob — Failure Consequence

On a failed steal against a mob:
1. The mob turns aggressive **toward the player only** — initiates combat.
2. Message: `"The <mob name> notices you! They attack!"`
3. Combat starts via the existing `g.startCombat(sess, p, mob)` call.
4. The mob must not already be in combat (`combat.IsMobInCombat`). If it is, output `"The <mob name> is busy."` and cancel.

### Steal from Object — Failure Consequence

On a failed steal against a guarded object:
- **If the guard mob is watching:** The guard calls for backup. A `stall_guard` mob instance is spawned in the room (or the existing guard initiates a talk dialog). The player enters `StateTalk` with the `stall_guard_talk` behavior offering: bribe, jail, or fight.
- **If the guard mob is NOT watching:** Simple failure message. `"You fail to steal anything."` No consequences.
- **If no guard mob exists in the room:** Simple failure, no consequences.

### Sneak Mode Toggle

- `sneak` toggles `p.Sneaking` bool.
- When enabled: `"You begin sneaking."` — the player is now in sneak mode.
- When disabled: `"You stop sneaking."` — normal mode.
- Sneak mode is **transient** (not saved to YAML). Lost on disconnect.
- Sneak mode does NOT affect movement or other actions — it only enables guard-watching notifications and improves steal chance on guarded objects.

### Guard Watching Cycle

Each tick, `SneakTick()` runs for all sneaking players. For each sneaking player:

1. Find all objects in the room with a `guard_mob` field.
2. For each such object, check if a living mob with that def ID is in the room.
3. If a guard is present, use a tick-based watching cycle:
   - The guard watches the object for `watchDuration` ticks (8 ticks), then looks away for `lookAwayDuration` ticks (4 ticks), cycling.
   - Tracked via world-level state: `guardWatchTimers map[string]int` on the `Game` struct, keyed by `"roomID:objDefID"`.
   - Each tick the counter increments. If `counter % (watchDuration + lookAwayDuration) < watchDuration`, the guard is watching.
4. Send a message to the sneaking player:
   - Watching: `"The Guard is watching the Market Stall."`
   - Not watching: `"The Guard looks away from the Market Stall."`
   - Only send on state **transitions** (watching→not watching, not watching→watching), not every tick. Track last-known state per player per object.

To track per-player notification state, add a transient field to Player:

```go
SneakNotified map[string]bool `yaml:"-"` // key: "roomID:objDefID", value: last known watching state
```

### Guard Watching — Implementation on Game struct

Add to `Game` struct:

```go
guardWatchTimers map[string]int // key: "roomID:objDefID", value: tick counter
```

Initialize in `New()`:

```go
guardWatchTimers: make(map[string]int),
```

---

## 10. Action Lifecycle

### File: `internal/game/action_steal.go`

```go
package game

import (
    "fmt"
    "math/rand"
    "sort"
    "strconv"
    "strings"

    "thehouseoficarus/internal/action"
    "thehouseoficarus/internal/combat"
    "thehouseoficarus/internal/engine"
    "thehouseoficarus/internal/net"
    "thehouseoficarus/internal/object"
    "thehouseoficarus/internal/player"
    "thehouseoficarus/internal/world"
)

var stealSuccess = action.SuccessFormula{
    Base:     0.5,
    PerLevel: 0.03,
    Cap:      0.95,
}
```

### `doSteal(sess *net.Session, input string)`

Entry point called from `executeCommand`. Signature:

```go
func (g *Game) doSteal(sess *net.Session, input string)
```

Logic:
1. `p := sess.Player.(*player.Player)`
2. Check `combat.GetCombat(p.Name) != nil` → `"You can't do that during combat!"`
3. `g.CancelAction(p)`
4. Call `g.resolveStealTarget(sess, p, input)` → returns `(targetType string, mob *world.MobInstance, obj *object.ObjectDef, err string)`
5. If err != "" → `sess.WriteLine(err); return`
6. Call `g.startSteal(sess, p, targetType, mob, obj)`

### `resolveStealTarget(sess *net.Session, p *player.Player, input string) (targetType string, mob *world.MobInstance, obj *object.ObjectDef, errMsg string)`

Logic:
1. Parse `input` for numbered targeting (`N.name` → `instanceIdx`, `name`).
2. If `input == ""` (no target specified):
   a. Collect all stealable mobs in room (those with `StealTable != ""`).
   b. Collect all stealable objects in room (those with `StealTable != ""`).
   c. Combined count: if 0 → return `"", nil, nil, "There's nothing here to steal from."`
   d. If all stealable targets are the same mob def → auto-select first mob. Return `"mob", mob, nil, ""`.
   e. If exactly 1 stealable object and 0 stealable mobs → auto-select object. Return `"object", nil, obj, ""`.
   f. If multiple different types → return `"", nil, nil, "Steal from what?"`.
3. If `input != ""`:
   a. Search mobs in room with `StealTable != ""` matching input (using `mob.MatchQuality(name)`).
   b. If multiple mobs found with different def IDs → `"Which one?"`.
   c. If mobs found → apply `instanceIdx`, return `"mob", selectedMob, nil, ""`.
   d. If no mob found, search objects in room with `StealTable != ""` matching input (using `world.WordPrefixMatch`).
   e. If object found → return `"object", nil, objDef, ""`.
   f. If nothing → return `"", nil, nil, "There's nothing here to steal from."`.

### `startSteal(sess *net.Session, p *player.Player, targetType string, mob *world.MobInstance, obj *object.ObjectDef)`

Logic:
1. Determine `stealTable`, `stealLevel`, `stealXP`, `stealSpeed`, `targetName`, `targetID`:
   - If `targetType == "mob"`: from `mob.StealTable`, `mob.StealLevel`, `mob.StealXP`, `mob.StealSpeed`, `mob.Name`, `mob.InstanceID`
   - If `targetType == "object"`: from `obj.StealTable`, `obj.StealLevel`, `obj.StealXP`, `obj.StealSpeed`, `obj.Name`, `obj.ID`
2. Check `stealTable == ""` → `"You can't steal from the <name>."`
3. Check level requirement: `p.Level(player.Thieving) < stealLevel` → `"You need level <N> thieving to steal from the <name>."`
4. Check inventory space: `p.FirstFreeSlot() == -1` → `"Your inventory is too full!"`
5. If mob target, check `mob.HP <= 0` → `"That is already dead."`. Check `combat.IsMobInCombat(mob.InstanceID)` → `"The <name> is busy."`
6. Determine `guardWatching` (only for object targets with `obj.GuardMob != ""`):
   - Check if a mob with DefID == `obj.GuardMob` exists in room and is alive.
   - If so, check the guard watch timer cycle to determine if watching.
7. Create action:

```go
sess.WriteLine(fmt.Sprintf("You attempt to steal from the %s...", targetName))

p.ActionState = &ActionState{Type: ActionStealing, TargetName: targetName}

p.Action = &action.Action{
    Type:       "steal",
    TargetID:   targetID,
    TargetName: targetName,
    WaitLeft:   engine.ToTicks(stealSpeed),
    Data: map[string]any{
        "target_type":    targetType,
        "steal_table":    stealTable,
        "steal_level":    stealLevel,
        "steal_xp":       stealXP,
        "target_name":    targetName,
        "mob_instance_id": mobInstanceID, // "" if object
        "obj_def_id":     objDefID,       // "" if mob
        "guard_mob":      guardMob,       // "" if no guard
        "guard_watching": guardWatching,
    },
}
```

### `advanceSteal(sess *net.Session, p *player.Player)`

Called from `AdvanceActions()` when `p.Action.Type == "steal"` and timer reaches 0.

Logic:
1. Extract all data fields from `p.Action.Data`.
2. Validate target still exists:
   - If mob: check `g.MobStore.GetInstance(mobInstanceID)` is non-nil, still alive, still in same room.
   - If object: check object still exists in room (via `g.World.FindObjInstances`).
   - If gone: `"Your target is gone."` → `g.CancelAction(p); return`
3. Calculate success chance:
   ```go
   level := p.Level(player.Thieving)
   chance := action.SuccessChance(stealSuccess, level, stealLevel)
   if guardWatching {
       chance *= 0.5
       if chance < 0.05 {
           chance = 0.05
       }
   }
   ```
4. Roll: `rand.Float64() < chance`
5. **On success:**
   a. Load drop table: `g.BehaviorStore.LoadDropTable(stealTable)`
   b. Resolve drop: `g.BehaviorStore.ResolveDrop(dt.Drops)`
   c. If drop is nil or empty → `"You steal nothing of value."` (edge case)
   d. Give item to player using same pattern as `giveSearchLoot` (check free slot, handle credits specially, drop to ground if full).
   e. Award XP:
      ```go
      if stealXP > 0 {
          if newLevel := p.AddSkillXP(player.Thieving, stealXP); newLevel > 0 {
              sess.WriteLine(g.colorize(sess, "level_up", fmt.Sprintf("*** You are now level %d thieving! ***", newLevel)))
          }
      }
      ```
   f. XP drop message (if `xp_drops` option on):
      ```go
      if stealXP > 0 && p.OptionBool("xp_drops") {
          msg += g.colorize(sess, "xp", fmt.Sprintf(" (+%dxp %s)", stealXP, player.SkillAbbr[player.Thieving]))
      }
      ```
   g. Save character: `g.AccountStore.SaveCharacter(p)`
   h. Restart action for continuous stealing (like gather loops):
      ```go
      p.Action.WaitLeft = engine.ToTicks(stealSpeed)
      ```
      Check inventory space before restarting. If full → cancel action.
6. **On failure (mob target):**
   a. `sess.WriteLine(fmt.Sprintf("The %s notices you! They attack!", targetName))`
   b. Initiate combat: `g.startCombat(sess, p, mob)` — reuse existing combat start.
   c. Cancel steal action: `g.CancelAction(p)`
7. **On failure (object target):**
   a. If `guardMob != ""` and guard is alive in room and `guardWatching`:
      - `sess.WriteLine("You fumble and the Guard spots you!")`
      - Start the guard talk interaction:
        ```go
        guardMob := g.findGuardInRoom(p.RoomID, data["guard_mob"].(string))
        if guardMob != nil {
            g.CancelAction(p)
            g.startMobTalk(sess, p, guardMob)
            return
        }
        ```
      - This requires the guard mob to have `behavior: stall_guard_talk` set in its YAML def. BUT: the existing `guard` mob already has `behavior: guard_talk`. We need a **separate** behavior for the caught-stealing scenario. Options:
        - Create a new talk behavior `stall_guard_talk` and **temporarily** override the guard's behavior when the steal fails. Since `startMobTalk` uses `mob.BehaviorID`, we can set `guardMob.BehaviorID = "stall_guard_talk"` before calling it, then restore after. This is hacky.
        - Better: Use `g.startTalkFromBehavior(sess, p, "stall_guard_talk", guardMob.Name)` — create a small helper that starts a talk without requiring the mob's own behavior field. This is cleaner.
      - Cleanest approach: Add a helper `startStealGuardTalk(sess, p, guardMob)` that loads `stall_guard_talk` behavior directly and initiates the talk state, bypassing the mob's own behavior ID.
   b. If guard not watching or no guard:
      - `sess.WriteLine("You fail to steal anything.")`
      - Restart action for retry: `p.Action.WaitLeft = engine.ToTicks(stealSpeed)`

### Helper: `findGuardInRoom(roomID int, guardDefID string) *world.MobInstance`

```go
func (g *Game) findGuardInRoom(roomID int, guardDefID string) *world.MobInstance {
    mobs := g.MobStore.MobsInRoom(roomID)
    for _, m := range mobs {
        if m.DefID == guardDefID && m.HP > 0 {
            return m
        }
    }
    return nil
}
```

### Helper: `isGuardWatching(roomID int, objDefID string) bool`

```go
const guardWatchDuration = 8
const guardLookAwayDuration = 4
const guardCycleLength = guardWatchDuration + guardLookAwayDuration // 12

func (g *Game) isGuardWatching(roomID int, objDefID string) bool {
    key := fmt.Sprintf("%d:%s", roomID, objDefID)
    counter := g.guardWatchTimers[key]
    return counter % guardCycleLength < guardWatchDuration
}
```

### Helper: `startStealGuardTalk(sess *net.Session, p *player.Player, guardMob *world.MobInstance)`

```go
func (g *Game) startStealGuardTalk(sess *net.Session, p *player.Player, guardMob *world.MobInstance) {
    cfg, err := g.BehaviorStore.LoadTalk("stall_guard_talk")
    if err != nil {
        sess.WriteLine("The Guard glares at you but says nothing.")
        return
    }

    p.ActionState = &ActionState{Type: ActionTalking, TargetName: guardMob.Name}

    startNode := cfg.Nodes["start"]
    sess.WriteLine(fmt.Sprintf("\n%s says: \"%s\"", g.colorize(sess, "mob_name", guardMob.Name), startNode.Message))

    // Show options (reuse existing talk option display pattern)
    g.showTalkOptions(sess, p, cfg, "start")

    sess.State = net.StateTalk
    sess.TalkData = &net.TalkData{
        BehaviorID: "stall_guard_talk",
        NodeID:     "start",
        TargetName: guardMob.Name,
    }
}
```

Note: The above uses `sess.TalkData` — check how the existing talk system stores state. Look at `internal/net/server.go` for `TalkData`. The existing talk system stores talk state in the session. The `startStealGuardTalk` function must follow the exact same pattern as `startMobTalk` / `startTalk` in `action_talk.go` — read that file to match precisely. The key point is that the talk behavior `stall_guard_talk` is loaded by ID rather than from the mob's own `BehaviorID`.

---

## 11. Sneak Mode

### File: `internal/game/cmd_sneak.go`

```go
package game

import (
    "fmt"

    "thehouseoficarus/internal/net"
    "thehouseoficarus/internal/player"
)

func (g *Game) doSneak(sess *net.Session) {
    p := sess.Player.(*player.Player)
    p.Sneaking = !p.Sneaking
    if p.Sneaking {
        p.SneakNotified = make(map[string]bool)
        sess.WriteLine("You begin sneaking.")
    } else {
        p.SneakNotified = nil
        sess.WriteLine("You stop sneaking.")
    }
}

func (g *Game) SneakTick() {
    if g.Hub == nil {
        return
    }

    // Advance all guard watch timers
    for key := range g.guardWatchTimers {
        g.guardWatchTimers[key]++
    }

    for _, sess := range g.Hub.AllSessions() {
        p, ok := sess.Player.(*player.Player)
        if !ok || p == nil || !p.Sneaking {
            continue
        }

        objs := g.World.AllObjInstances(p.RoomID)
        for _, st := range objs {
            objDef, err := g.ObjectStore.Load(st.DefID)
            if err != nil || objDef.GuardMob == "" {
                continue
            }

            guard := g.findGuardInRoom(p.RoomID, objDef.GuardMob)
            if guard == nil {
                continue
            }

            // Ensure timer exists
            timerKey := fmt.Sprintf("%d:%s", p.RoomID, st.DefID)
            if _, exists := g.guardWatchTimers[timerKey]; !exists {
                g.guardWatchTimers[timerKey] = 0
            }

            watching := g.isGuardWatching(p.RoomID, st.DefID)
            notifyKey := timerKey

            if p.SneakNotified == nil {
                p.SneakNotified = make(map[string]bool)
            }

            lastState, known := p.SneakNotified[notifyKey]
            if !known || lastState != watching {
                if watching {
                    sess.WriteLine(g.colorize(sess, "warning", fmt.Sprintf("The %s is watching the %s.", guard.Name, objDef.Name)))
                } else {
                    sess.WriteLine(g.colorize(sess, "success", fmt.Sprintf("The %s looks away from the %s.", guard.Name, objDef.Name)))
                }
                p.SneakNotified[notifyKey] = watching
            }
        }
    }
}
```

### Player struct additions (in `internal/player/player.go`)

After `Sneaking bool`:

```go
SneakNotified    map[string]bool              `yaml:"-"`
```

---

## 12. Guard Interaction

### Talk Behavior: `data/behaviors/stall_guard_talk.yaml`

```yaml
id: stall_guard_talk
type: talk
nodes:
  start:
    message: "Caught you red-handed! You have three options, thief."
    options:
      - text: "I'll pay a fine. (500 credits)"
        goto: bribe
        condition:
          min_credits: 500
      - text: "Take me to jail."
        goto: jail
      - text: "You'll have to catch me first!"
        goto: fight
      - text: "I can't afford that..."
        goto: jail
        condition:
          min_credits: 500
          not: true
  bribe:
    message: "Smart choice. Hand over 500 credits and we'll forget this happened."
    action:
      cost: 500
      set_player_flags:
        bribed_guard: true
    options:
      - text: "Fine, take it."
        end: true
  jail:
    message: "Off to the detention cell with you!"
    action:
      teleport: 152
      set_player_flags:
        been_to_jail: true
    options:
      - text: "(You are dragged away)"
        end: true
  fight:
    message: "Then defend yourself!"
    action:
      set_flags:
        guard_hostile: true
    options:
      - text: "(The guard attacks!)"
        end: true
```

**Fight option handling:** When the `fight` node ends and `guard_hostile` flag is set, the guard should attack the player. This is handled in a post-talk hook. After the talk ends (when the player selects the end option for the `fight` node), check the world flag `guard_hostile`. If set:

1. Clear the flag immediately: `delete(g.WorldFlags, "guard_hostile")`
2. Find the guard mob in the room
3. If guard exists and is not protected for combat purposes: temporarily set `guard.Protected = false`, start combat via `g.startCombat(sess, p, guardMob)`, then restore `guard.Protected = true` afterward (or just leave it false during this combat).

**Implementation note:** The existing talk system processes `NodeAction` fields automatically via `executeTalkAction`. The `teleport` action already works. The `cost` action deducts credits. The only custom behavior needed is the "fight" trigger. Since the talk system already handles `set_flags`, we need a post-talk check in `handleTalkInput` (in `internal/game/action_talk.go`) or in the talk end handler:

Add to the end of talk processing (where `end: true` is handled), after executing the node action:

```go
if g.WorldFlags["guard_hostile"] != nil {
    delete(g.WorldFlags, "guard_hostile")
    guardMob := g.findGuardInRoom(p.RoomID, "guard")
    if guardMob != nil {
        guardMob.Protected = false
        g.startCombat(sess, p, guardMob)
    }
}
```

This check goes in the talk-end code path in `action_talk.go` (or `game.go` where `handleTalkInput` processes choices).

---

## 13. XP Table

| Target | Thieving Level Required | XP per Steal | Steal Speed (ticks) |
|---|---|---|---|
| Man | 1 | 8 | 4 |
| Market Stall | 5 | 12 | 5 |
| Farmer | 10 | 15 | 4 |
| Bioengineer | 38 | 45 | 4 |

These values are set in the mob/object YAML files via `steal_level`, `steal_xp`, and `steal_speed` fields.

**XP progression reference (RSC table):**
- Level 1: 0 XP
- Level 10: 1,154 XP (~144 man steals)
- Level 38: 31,191 XP (~668 farmer steals from level 10)
- Level 50: 101,333 XP (~1,559 bioengineer steals from level 38)
- Level 99: 13,034,431 XP

---

## 14. Drop Tables

### `data/drops/credit_stick_drop.yaml`

```yaml
id: credit_stick_drop
drops:
  - item_id: credits
    weight: 40
    quantity: 15
  - item_id: credits
    weight: 30
    quantity: 30
  - item_id: credits
    weight: 20
    quantity: 50
  - item_id: credits
    weight: 8
    quantity: 100
  - item_id: credits
    weight: 2
    quantity: 250
```

### `data/drops/man_steal.yaml`

```yaml
id: man_steal
drops:
  - item_id: credit_stick
    weight: 80
    quantity: 1
  - item_id: credits
    weight: 20
    quantity: 5
```

### `data/drops/farmer_steal.yaml`

```yaml
id: farmer_steal
drops:
  - item_id: potato_seed
    weight: 30
    quantity: 1
  - item_id: onion_seed
    weight: 25
    quantity: 1
  - item_id: cabbage_seed
    weight: 20
    quantity: 1
  - item_id: tomato_seed
    weight: 15
    quantity: 1
  - item_id: sweetcorn_seed
    weight: 8
    quantity: 1
  - item_id: strawberry_seed
    weight: 2
    quantity: 1
```

### `data/drops/bioengineer_steal.yaml`

```yaml
id: bioengineer_steal
drops:
  - item_id: sweetcorn_seed
    weight: 25
    quantity: 1
  - item_id: strawberry_seed
    weight: 20
    quantity: 1
  - item_id: watermelon_seed
    weight: 20
    quantity: 1
  - item_id: ranarr_seed
    weight: 15
    quantity: 1
  - item_id: snapdragon_seed
    weight: 12
    quantity: 1
  - item_id: torstol_seed
    weight: 8
    quantity: 1
```

### `data/drops/market_stall_steal.yaml`

```yaml
id: market_stall_steal
drops:
  - item_id: bread
    weight: 40
    quantity: 1
  - item_id: apple
    weight: 35
    quantity: 1
  - item_id: cheese
    weight: 25
    quantity: 1
```

---

## 15. Help Files

### `data/help/steal.yaml`

```yaml
name: "steal"
category: "Skills"
description: |
  Steal from mobs or objects.

  Usage: steal [target]

  Attempts to pickpocket a mob or shoplift from an object. Requires
  a minimum thieving level depending on the target.

  If there is only one stealable target in the room, you can type
  just "steal". If there are multiple different targets, you must
  specify: "steal man", "steal stall", "steal 2.man".

  On success, you receive a random item from the target's loot table
  and gain thieving XP. The action repeats automatically until you
  run out of inventory space or are interrupted.

  On failure against a mob, the mob turns hostile and attacks you.

  On failure against a guarded object (while the guard is watching),
  the guard confronts you with options to pay a bribe, go to jail,
  or fight.

  Use "sneak" to see when guards are watching or looking away.

  Aliases: thieve

  See also: help sneak, help thieving
```

### `data/help/sneak.yaml`

```yaml
name: "sneak"
category: "Skills"
description: |
  Toggle sneak mode on and off.

  Usage: sneak

  While sneaking, you receive messages telling you when guards are
  watching or looking away from objects they protect. Use this
  information to time your steals for when the guard is distracted.

  Stealing from a guarded object while the guard is looking away
  has no penalty on failure. Stealing while the guard is watching
  halves your success chance, and a failure causes the guard to
  confront you.

  Sneak mode is lost when you disconnect.

  See also: help steal, help thieving
```

### `data/help/thieving.yaml`

```yaml
name: "thieving"
category: "Skills"
description: |
  Thieving lets you steal from mobs and objects for loot and XP.

  Targets:
    Man           - Level 1,  8 XP  - Credit sticks
    Market Stall  - Level 5,  12 XP - Food items (guarded)
    Farmer        - Level 10, 15 XP - Low/mid seeds
    Bioengineer   - Level 38, 45 XP - Mid/high seeds

  Success chance increases with your thieving level relative to
  the target's requirement. Failing against a mob starts combat.
  Failing against a guarded object while the guard watches triggers
  a confrontation (bribe, jail, or fight).

  Credit sticks obtained from stealing can be searched for credits.

  Commands: steal, sneak

  See also: help steal, help sneak
```

---

## Summary of All Changes

### New Go files (2):
1. `internal/game/action_steal.go` — `doSteal`, `resolveStealTarget`, `startSteal`, `advanceSteal`, `findGuardInRoom`, `isGuardWatching`, `startStealGuardTalk`, helpers
2. `internal/game/cmd_sneak.go` — `doSneak`, `SneakTick`

### Modified Go files (6):
1. `internal/player/player.go` — Add `Sneaking bool` and `SneakNotified map[string]bool` to Player struct
2. `internal/game/action_state.go` — Add `ActionStealing` constant and `Description()` case
3. `internal/game/action.go` — Add `"steal"/"thieve"` to `verbAliases` and `verbSkill`, add `"steal"` case to `AdvanceActions()`
4. `internal/game/game.go` — Add `"sneak"` to ClassInstant, `"steal"/"thieve"` to ClassActive, add cases to `executeCommand()`, add `ActionStealing` to persistent states in `ProcessQueuedCommands()`, add `guardWatchTimers` to Game struct
5. `internal/world/mob.go` — Add `StealTable`, `StealLevel`, `StealXP`, `StealSpeed` to `MobDef` and `MobInstance`, copy in spawn function
6. `internal/object/object.go` — Add `StealTable`, `StealLevel`, `StealXP`, `StealSpeed`, `GuardMob` to `ObjectDef`
7. `cmd/mud/main.go` — Add `g.SneakTick()` to tick subscriber
8. `internal/game/action_talk.go` — Add post-talk `guard_hostile` flag check for fight option

### Modified YAML files (2):
1. `data/mobs/man.yaml` — Add steal fields
2. `data/rooms/100.yaml` — Add `south: 150` exit

### New YAML files (24):
- 13 items: `credit_stick`, `bread`, `apple`, `cheese`, `potato_seed`, `onion_seed`, `cabbage_seed`, `tomato_seed`, `sweetcorn_seed`, `strawberry_seed`, `watermelon_seed`, `ranarr_seed`, `snapdragon_seed`, `torstol_seed`
- 2 mobs: `farmer`, `bioengineer`
- 1 object: `market_stall`
- 1 behavior: `stall_guard_talk`
- 4 drop tables: `credit_stick_drop`, `man_steal`, `farmer_steal`, `bioengineer_steal`, `market_stall_steal`
- 3 rooms: `150`, `151`, `152`
- 3 help files: `steal`, `sneak`, `thieving`