rhysu-droll-182-190

./.circleci/config.yml
./.git/COMMIT_EDITMSG
./.git/config
./.git/description
./.git/HEAD
./.git/index
./.gitignore
./droll/ability.py
./droll/dice.py
./droll/display.py
./droll/dungeon.py
./droll/game.py
./droll/party.py
./droll/player.py
./droll/regular.py
./droll/shell.py
./droll/special.py
./droll/struct.py
./droll/treasure.py
./
…[108 chars omitted]…
o/entry_points.txt
./droll.egg-info/PKG-INFO
./droll.egg-info/requires.txt
./droll.egg-info/SOURCES.txt
./droll.egg-info/top_level.txt
./LICENSE
./pyproject.toml
./README.md
./tests/test_ability.py
./tests/test_display.py
./tests/test_game.py
./tests/test_party.py
./tests/test_player.py
./tests/test_regular.py
./tests/test_shell.py
./tests/test_special.py
./tests/test_treasure.py
./tests/test_world.py

__all__ = (
    "Game",
    "GameState",
)


class GameState(enum.Enum):
    """Game should STOP or one can still PLAY?"""

    STOP = 0
    PLAY = 1


class Game:
    """Tracks all state associated with a programmatically driven game."""

    def __init__(
        self,
        player: struct.Player = player.Default,
        random: Optional[Random] = None,
    ) -> None:
        """Initialize a new game with the given player and RNG."""
        self._player = player
    
…[6524 chars omitted]…
l)
        return results

    def completedefault(
        self,
        text: str,
        head: Sequence[str],
        tail: Sequence[str],
    ) -> Sequence[str]:
        """Complete loosely based upon available heroes/treasures/dungeon."""
        return player.complete(
            world=self._world,
            tokens=head + tail,
            text=text,
            position=len(head),
        )

__all__ = (
    "delve",
    "descend",
    "new_world",
    "retire",
    "retreat",
    "score",
)


def new_world() -> struct.World:
    """Establish a new world independent of a delve/dungeon."""
    return struct.World(
        treasure=struct.Treasure(
            box=struct.Artifacts(
                sword=3,
                talisman=3,
                sceptre=3,
                tools=3,
                scroll=3,
     
…[5635 chars omitted]…
-> struct.World:
    """Attempt to use a town portal towards retiring to town."""
    # No need to reset monsters/dragon as dungeon will be wholly replaced
    if defeated_dungeon(world.dungeon):
        raise DrollError(f"No need to apply {noun} when dungeon clear.")
    return replace(
        world,
        treasure=replace_treasure(world.treasure, "portal"),
        dungeon=struct.Dungeon(),
    )

def _remove_monsters(world: struct.World) -> struct.World:
    """Remove all monsters from dungeon for testing treasure interactions."""
    return replace(
        world, dungeon=replace(world.dungeon, goblin=0, skeleton=0, ooze=0)
    )


class TestPlayer:

    def setup_method(self):
        """Fixtures with a game containing 2 of each dungeon and party item."""
        self.game = replace(
            world.new_world(),
            dungeon=struct.Dungeon(*([2] * len(fields(struct.Dungeon)))),
          
…[8628 chars omitted]…
n the second position."""
        game = replace(self.game, party=replace(self.game.party, fighter=0))
        game = _remove_monsters(game)
        assert complete(game, ("X", "Y", "fig"), "fig", 2) == ["fighter"]
        assert complete(game, ("X", "Y", "gob"), "gob", 2) == ["goblin"]
        assert complete(game, ("X", "Y", "ch"), "ch", 2) == [
            "champion",
            "chest",
        ]

class TestTreasure:

    def setup_method(self):
        """Fixture with a game containing dungeon items but no party."""
        self.game = replace(
            world.new_world(),
            dungeon=struct.Dungeon(*([2] * len(fields(struct.Dungeon)))),
            party=struct.Party(),
        )
        self.randrange = random.Random(4).randrange

    def test_elixir(self):
        """Test elixir treasure used to revive a party member."""
        game = replace(
            self.game,
            treasur
…[7910 chars omitted]…
es ring or portal."""
        pre = world.new_world()
        pre = world.delve(pre, dice.roll_party, self.state.randrange)
        pre = replace(
            pre,
            depth=3,
            dungeon=struct.Dungeon(
                goblin=0, skeleton=0, ooze=0, chest=2, potion=5, dragon=3
            ),
        )
        assert pre.depth > 0

        # Neither town portal nor ring of invisibility

    decrement_dungeon,
    eliminate_dungeon,
)
from .party import decrement_party, decrement_regroup, increment_party
from .struct import (
    DrollError,
    Dungeon,
    Party,
    RandRange,
    World,
    field_names,
    field_values,
)
from .treasure import draw_treasure, replace_treasure

__all__ = (
    "bait_dragon",
    "defeat_all",
    "defeat_dragon",
    "defeat_dragon_heroes",
    "defeat_one"
…[8629 chars omitted]…

def elixir(
    world: World, randrange: RandRange, command: str, targets: tuple[str, ...] = ()
) -> World:
    """Consume an elixir to add one hero die of any type."""
    if not targets:
        raise DrollError(f"Hero required for {command}.")
    return replace(
        world,
        treasure=replace_treasure(world.treasure, command),
        party=increment_party(world.party, targets[0]),
    )

from droll.player import Default


def test_game_repr():
    """Game has a meaningful repr showing player, score, delve, and depth."""
    g = Game(random=random.Random(4), player=Default)
    r = repr(g)
    assert r.startswith("Game(")
    assert "player=Default" in r
    assert "score=" in r
    assert "delve=" in r
    assert "depth=" in r


def test_reroll_dungeon_dice():
    """Test rerolling dungeon dice using a scroll."""
    g = Game(random=random.Random(4), pl
…[6020 chars omitted]…
    # Play through 3 delves by retiring from each
    for _ in range(2):
        g.descend()
        g._world = replace(g._world, dungeon=struct.Dungeon())
        result = g.retire()
        assert result == GameState.PLAY
    # Third delve: retire should trigger STOP
    g.descend()
    g._world = replace(g._world, dungeon=struct.Dungeon())
    result = g.retire()
    assert result == GameState.STOP

_UNUSED = object()


def test_enchantress_transforms_monster_to_potion():
    """Enchantress transforms 1 monster into 1 potion."""
    world = struct.World(
        ability=True,
        dungeon=struct.Dungeon(goblin=2, skeleton=1),
        party=struct.Party(fighter=1),
    )
    result = enchantress_ability(world, _UNUSED, "ability", ("goblin",))
    assert result.dungeon.goblin == 1
    assert result.dungeo
…[8629 chars omitted]…
ult1.dungeon.chest == 0
    assert result1.dungeon.goblin == 1
    assert result1.party.fighter == 4
    assert result1.treasure.own.scale == 1

    result2 = HalfGoblin.party.fighter.potion(
        world, randrange, "fighter", ("potion", "mage")
    )
    assert result2.dungeon.goblin == 1
    assert result2.dungeon.potion == 0
    assert result2.party.fighter == 4
    assert result2.party.mage == 1

…[977 chars omitted]…
rgets[0])
droll/regular.py:145:    howmany = getattr(world.dungeon, targets[0])
droll/regular.py:304:    if world.dungeon.dragon < _min_dragon_count:
droll/special.py:89:    count = min(getattr(world.dungeon, source), max_count)
droll/special.py:96:            **{source: getattr(world.dungeon, source) - count},
droll/world.py:114:    prior_dragons = 0 if world.dungeon is None else world.dungeon.dragon

from droll import struct
from droll.display import DisplayMode
from droll.struct import DrollError
from droll.game import Game
from droll.player import Default
from droll.shell import Shell, _RESET


def _mechanical_shell(game: Game) -> Shell:
    return Shell(game, display_mode=DisplayMode.MECHANICAL)


def test_precmd_emits_reset_when_color_enabled():
    with patch("sys.stdout.isatty", return_value=True):
        s = Shell(Game(), display_mode=DisplayMode.CURRENT)
    s.preloop()
    with patch("sys.stdou
…[7528 chars omitted]…
 s._command_count == 2
    s.onecmd("cleric ooze")  # count -> 3; undo stack: [before_1st, before_2nd]
    assert s._command_count == 3
    s.onecmd("undo")  # success: count -> 2
    assert s._command_count == 2
    s.onecmd("undo")  # success: count -> 1
    assert s._command_count == 1

    # Failed undo (nothing left to undo) does not decrement
    s.onecmd("undo")
    assert s._command_count == 1

194-    dungeon_targets, party_targets = _classify_reroll_targets(
195-        targets, allow_dragon
196-    )
197-
198-    # Decrement hero and regroup BEFORE any dice are rolled to prevent
199-    # stochastic exploitation: a rolled result cannot be immediately spent.
200-    party = decrement_party(world.party, hero)
201-    regroup = decrement_regroup(world.regroup, hero)
202-
203-    dungeon = world.dungeon
204-    if dungeon_targets:
205-        for target in dungeon_targets:
206-            dungeon = decrement_dungeon(dungeon, target)
…[2197 chars omitted]…
sallowed_heroes}:
274-        raise DrollError(
275-            f"A {', '.join(sorted(disallowed_heroes))} cannot defeat a dragon."
276-        )
277-    if len(heroes) != required:
278-        raise DrollError(f"Exactly {required} heroes required.")
279-    n_distinct = distinct_heroes(
280-        heroes, wildcard=wildcard, interchangeable=interchangeable
281-    )
282-    if n_distinct != required:

314:| Hero        | Ability                          | Syntax example                    | Requires                |
316:| Crusader    | Add 1 fighter or cleric          | `ability` or `ability cleric`     | —                       |
317:| Enchantress | Transform 1 monster into potion  | `ability goblin`                  | 1 monster target        |
318:| Half
…[8629 chars omitted]…
deltas)
    dungeon_str = _format_dungeon(w.dungeon)

    # Build lines with aligned colons
    lines = [
        f"{'Score ' + str(score) + ':':<{width}} {location}",
        f"{'Treasure:':<{width}} {treasure_str}",
        f"{'Consider:':<{width}} {available_str}",
        f"{'Party:':<{width}} {party_str}",
    ]
    lines.append(f"{'Dungeon:':<{width}} {dungeon_str}")

    return "\n".join(lines)

drwxr-xr-x   2 root root 4096 Aug  3 00:00 mnt
drwxr-xr-x   2 root root 4096 Aug  3 00:00 opt
dr-xr-xr-x 317 root root    0 Nov  5 05:45 proc
drwxr-xr-x   1 root root 4096 Nov  5 05:46 repo
drwx------   1 root root 4096 Nov  5 05:46 root
drwxr-xr-x   1 root root 4096 Nov  5 05:46 run
lrwxrwxrwx   1 root root    8 Jul  4 09:0
…[369 chars omitted]…
 root root  607 Jul  4 09:05 .bashrc
drwxr-xr-x 3 root root 4096 Nov  5 05:46 .cache
-rw-r--r-- 1 root root  132 Jul  4 09:05 .profile
-rw-r--r-- 1 root root  169 Aug  5 01:04 .wget-hsts

/tmp:
total 8
drwxrwxrwt 1 root root 4096 Nov  5 05:46 .
drwxr-xr-x 1 root root 4096 Nov  5 05:45 ..
-rw-r--r-- 1 root root    0 Nov  5 05:46 install.log
/tmp/install.log
/root/.bashrc
/root/.profile
/root/.wget-hsts

Editable project location: /repo
Requires: 
Required-by: 
total 232
drwxr-xr-x 1 root root   4096 Nov  5 05:46 .
drwxr-xr-x 1 root root   4096 Aug  5 01:12 ..
-rw-r--r-- 1 root root    119 Aug  5 01:12 README.txt
-rw-r--r-- 1 root root     77 Nov  5 05:46 __editable__.droll-0.1.pth
-rw-r--r-- 1 root root   3356 Nov  5 05:46 __editable___droll_0_1_finder.py
drwxr-xr-x 2 root root   4096 Nov  5 05:46 __pycache__
drwxr-xr-x 9 root root   4096 Nov  5 05:46 _pytest
drwxr-xr-x 3 root root   4096 Nov  5 05:46 droll-0.1.dist-info
drwxr-xr-x 8 root root   4096 Nov  5 05:46 flake8

173:            self._game = self._undo.pop()
178:    def do_EOF(self, line) -> GameState:
191:    def do_ability(self, line) -> GameState:
201:    def do_descend(self, line) -> GameState:
207:    def do_r
…[6855 chars omitted]…
           Fighters defeat ALL goblins but only ONE skeleton or ooze:

                    fighter goblin                # Defeat all goblins
                    fighter skeleton              # Defeat one skeleton
                    fighter ooze                  # Defeat one ooze
                    fighter chest                 # Open one chest
            {self.doc_potion_example.format("fighter")}

…[1597 chars omitted]…
player.Default, game, None, artifact, specialty)
tests/test_treasure.py:78:        game = player.apply(player.Default, game, None, artifact, other)
tests/test_treasure.py:84:            player.apply(player.Default, game, None, artifact, other)
tests/test_treasure.py:107:        game = player.apply(player.Default, game, None, "tools", "goblin")
tests/test_world.py:29:        assert game.ability is True

def apply(
    player: struct.Player,
    world: struct.World,
    randrange: struct.RandRange,
    command: str,
    *targets: str,
) -> struct.World:
    """Apply command to targets within world, returning a new version.

    Processes hero-like artifacts (i.e. not rings/portals/scales).
    For example, what heroes to revive when quaffing a potion."""
    # Convert any artifacts in the command into any corresponding hero types
    command, targets = _partify_all(player.artifacts, command, targets)

    # One-off handling of some treasures, with 
…[4576 chars omitted]…
reasure:
    """Replace a single item from the player's own artifacts into the box."""
    prior_count = getattr(treasure.own, item)
    if not prior_count:
        raise DrollError(f"'{item}' not in player's treasure.")
    return replace(
        treasure,
        own=replace(treasure.own, **{item: prior_count - 1}),
        box=replace(treasure.box, **{item: getattr(treasure.box, item) + 1}),
    )

+    # must remain an artifact name rather than becoming a hero name.
+    preserve_first = (
+        command == "ability" and player.ability is ability.paladin_ability
+    )
+    command, targets = _partify_all(
+        player.artifacts, command, targets, preserve_first=preserve_first
+    )
+
+
…[1845 chars omitted]…
ure:
 
 def replace_treasure(treasure: Treasure, item: str) -> Treasure:
     """Replace a single item from the player's own artifacts into the box."""
+    if item not in field_names(treasure.own):
+        raise DrollError(f"'{item}' is not a valid treasure type.")
     prior_count = getattr(treasure.own, item)
     if not prior_count:
         raise DrollError(f"'{item}' not in player's treasure.")

nodungeon ability Crusader ERR DrollError 'You must descend first.'
nodungeon default ability: False
replace invalid ERR DrollError "'cleric' is not a valid treasure type."

dditional(w, _UNUSED, "fighter", ("goblin",))
tests/test_special.py:127:        special.defeat_one_plus_additional(
tests/test_special.py:141:    result = special.defeat_one_plus_additional(
tests/test_special.py:155:    result = special.convert_dungeon_to_party(
tests/test_special.py:170:        special.convert_dungeon_to_party(
tests/test_special.py:181:    result = special.convert_dungeon_to_party(

from droll import special, struct
from droll.struct import DrollError

# Known to be unused because it would raise NameErrors on any use
_UNUSED = object()


def test_defeats_all_plus_one_additional():
    """Defeats all of one type plus one additional."""

…[4991 chars omitted]…
"Converts only available count when fewer than max_count."""
    w = struct.World(
        dungeon=struct.Dungeon(skeleton=1),
        party=struct.Party(),
    )
    result = special.convert_dungeon_to_party(
        w, source="skeleton", destination="fighter", max_count=2
    )
    assert result.dungeon.skeleton == 0
    assert result.party.fighter == 1
    assert result.regroup.discard.fighter == 1

   172	            ]
   173	            hint = f" Available: {', '.join(valid)}." if valid else ""
   174	            raise DrollError(f'"{command}" requires a target.{hint}')
   175	        if not hasattr(action_, targets[0]):
   176	            raise DrollError(f'Unknown target "{targets[0]}".')
   177	        try:
   178	            action_ = getattr(action_, targets[0])

_UNUSED = object()


def test_minstrel_ability_discards_dragons():
    """Minstrel/Bard ability discards all dragon dice."""
    world = struct.World(
        ability=True,
        dungeon=struct.Dungeon(goblin=1, dragon=3),
        party=struct.Party(fighter=1),
    )
    result = minstrel_ability(world, _UNUSED, "ability")
    assert result.dungeon.dragon == 0
    assert result.dungeon.goblin == 1
    assert not result.ability


def test_minstrel
…[7557 chars omitted]…
ert result.dungeon.ooze == 0
    assert result.party.fighter == 1


def test_mercenary_advances_to_commander():
    """Mercenary advances to Commander at 5+ experience."""
    low_xp = struct.World(experience=4)
    high_xp = struct.World(experience=5)
    assert Mercenary.advance(low_xp) == Mercenary
    assert Mercenary.advance(high_xp) == Commander
    assert Commander.advance(high_xp) == Commander

            result = super().onecmd(line)
        except DrollError as e:
            if raises:
                raise
            if self._color:
                print(_ERROR, " ".join(e.args), _RESET, sep="")
            else:
                print(*e.args)
            return result

        # Retain only undo candidates that disallow cheating.
        # Okay would be 'Oh! I should have used a fighter on the goblin!'
        #
…[336 chars omitted]…
         self._undo.append(before)  # Same random state so undo permitted
        else:
            self._undo.clear()  # Random state mutated so no undo permitted

        if self._game != before:
            self._command_count += -1 if line == "undo" else 1

        return result

    def do_undo(self, line) -> GameState:
        """Undo prior commands.  Only permitted when nothing rolled/drawn."""

175-        elif target in _PARTY_NAMES:
176-            party_targets.append(target)
177-        else:
178-            raise DrollError(f"{target} cannot be re-rolled.")
179-    return dungeon_targets, party_targets
180-
181-
182-def reroll(
183-    world: World,
184-    randrange: RandRange,
185-    hero: str,
186-    targets: tuple[str, ...],
187-    *,
188-    allow_dragon
…[1826 chars omitted]…
the given list represent?
245-
246-    Wildcards are fungible for any other hero type.
247-    Interchangeable heroes may substitute for one another.
248-    """
249-    n_wildcard = sum(1 for h in heroes if h in wildcard)
250-    inter = [h for h in heroes if h not in wildcard and h in interchangeable]
251-    regular = [
252-        h for h in heroes if h not in wildcard and h not in interchangeable

 
     Processes hero-like artifacts (i.e. not rings/portals/scales).
     For example, what heroes to revive when quaffing a potion."""
-    # Convert any artifacts in the command into any corresponding hero types
-    command, targets = _partify_all(player.artifacts, command, targets)
+    # Convert any artifacts in the command into any corre
…[2254 chars omitted]…
ure:
 
 def replace_treasure(treasure: Treasure, item: str) -> Treasure:
     """Replace a single item from the player's own artifacts into the box."""
+    if item not in field_names(treasure.own):
+        raise DrollError(f"'{item}' is not a valid treasure type.")
     prior_count = getattr(treasure.own, item)
     if not prior_count:
         raise DrollError(f"'{item}' not in player's treasure.")

     # stochastic exploitation: a rolled result cannot be immediately spent.
........................................................................ [ 68%]
..................................................................       [100%]
210 passed in 0.70s
goblin DrollError You must descend first.
dragon DrollError dragon cannot be re-rolled.
fighter DrollError At least 1 fighter required in party.

droll/dungeon.py:14:    "decrement_dungeon",
droll/dungeon.py:17:    "eliminate_dungeon",
dr
…[552 chars omitted]…
l/regular.py:98:        dungeon=decrement_dungeon(world.dungeon, targets[0]),
droll/regular.py:126:        dungeon=eliminate_dungeon(world.dungeon, targets[0]),
droll/regular.py:157:        dungeon=eliminate_dungeon(world.dungeon, targets[0]),
droll/regular.py:208:            dungeon = decrement_dungeon(dungeon, target)
droll/regular.py:331:        dungeon=eliminate_dungeon(world.dungeon, targets[0]),

convert_dungeon_to_party DrollError You must descend first.

_UNUSED = object()


def test_spellsword_ability_adds_fighter():
    """Spellsword ability adds a fighter to party."""
    world = struct.World(
        ability=True,
        party=struct.Party(fighter=1, mage=1),
    )
    result = spellsword_ability(world, _UNUSED, "ability", ("fighter",))
    assert result.party.fighter == 2
    assert not result.ability


def test_spellsword_ability_adds_mage():
    """Sp
…[2527 chars omitted]…
.pyc: binary file matches
tests/test_ability.py:9:from droll.ability import default_ability
tests/test_ability.py:19:        default_ability(w, _UNUSED, "ability")
tests/test_ability.py:22:def test_default_ability_rejects_target():
tests/test_ability.py:26:        default_ability(w, _UNUSED, "ability", ("fighter",))
grep: tests/__pycache__/test_ability.cpython-312-pytest-9.2.0.pyc: binary file matches

         raise DrollError(f"At least 1 {target} required in dungeon.")
@@ -62,12 +64,16 @@ def decrement_dungeon(dungeon: Dungeon, target: str) -> Dungeon:
 
 def increment_dungeon(dungeon: Dungeon, target: str) -> Dungeon:
     """Increase the count of the specified target type by one."""
+    if dungeon is None:
+        raise DrollError("You must descend first.")
     prior_targets = getattr(dungeon, tar
…[6398 chars omitted]…
> 79 characters)
droll/regular.py:94:80: E501 line too long (80 > 79 characters)
droll/regular.py:118:80: E501 line too long (80 > 79 characters)
droll/regular.py:358:80: E501 line too long (82 > 79 characters)
droll/regular.py:369:80: E501 line too long (83 > 79 characters)
droll/regular.py:384:80: E501 line too long (83 > 79 characters)
droll/special.py:30:80: E501 line too long (82 > 79 characters)

drwxr-xr-x 1 root root  4096 Nov  2 10:38 tests
./.circleci/config.yml
./.git/COMMIT_EDITMSG
./.git/HEAD
./.git/config
./.git/description
./.git/index
./.gitignore
./LICENSE
./README.md
./droll.egg-info/PKG-INFO
./droll.egg-info/SOURCES.txt
./droll.egg-info/dependency_links.txt
./droll.egg-info/entry_points.txt
./droll.egg-info/requires.txt
./droll.egg-info/top_level.txt
./d
…[114 chars omitted]…
oll/game.py
./droll/party.py
./droll/player.py
./droll/regular.py
./droll/shell.py
./droll/special.py
./droll/struct.py
./droll/treasure.py
./droll/world.py
./pyproject.toml
./tests/test_ability.py
./tests/test_display.py
./tests/test_game.py
./tests/test_party.py
./tests/test_player.py
./tests/test_regular.py
./tests/test_shell.py
./tests/test_special.py
./tests/test_treasure.py
./tests/test_world.py

    field_items,
    field_values,
)

__all__ = (
    "draw_treasure",
    "replace_treasure",
)


def _draw(box: Artifacts, randrange: RandRange) -> str:
    """Draw a random treasure from the box, weighted by counts."""
    total = sum(field_values(box))
    if not total:
        raise DrollError("No items remaining in the box")
    choice = randrange(0, total)
    cumulative = 0
    for name, count in field_items(box):
        cumulative += count
        if choice < cumulative:
            return name
    r
…[8630 chars omitted]…
, directly "descend" or "retire".')
droll/player.py:133:    if command in {"ability", "bait", "elixir"}:
droll/player.py:136:            return action_(world, randrange, command, targets)
droll/player.py:138:            raise DrollError(str(cause)) from cause
droll/player.py:145:    # everything else is hero-target
droll/player.py:147:        world = regular.reroll(world, randrange, "scroll", targets)

__all__ = (
    "Default",
    "apply",
    "complete",
)

# Rules governing a default player lacking any special abilities.
# Effectively, this data is one large, dense dispatch table.
# Other players will generally be defined in terms of this one.
Default = struct.Player(
    name="Default",
    # Behavior of special commands?
    ability=ability.default_ability,
    # Advance maps struct.World -> struct.Player, permitting promotion.
    # Howe
…[8630 chars omitted]…
yer]


def brief(o: Any) -> str:
    """A __str__(...) variant suppressing False fields within dataclasses."""
    try:
        names = field_names(o)
        values = field_values(o)
    except TypeError:
        return str(o)

    keyvalues = []
    for field, value in zip(names, values):
        if value:
            keyvalues.append(f"{field}={brief(value)}")
    return f"({', '.join(keyvalues)})"

__all__ = (
    "Default",
    "apply",
    "complete",
)

# Rules governing a default player lacking any special abilities.
# Effectively, this data is one large, dense dispatch table.
# Other players will generally be defined in terms of this one.
Default = struct.Player(
    name="Default",
    # Behavior of special commands?
    ability=ability.default_ability,
    # Advance maps struct.World -> struct.Player, permitting promotion.
    # Howe
…[8630 chars omitted]…
ure.py:92:        self._helper_artifact("talisman", "cleric", "skeleton", "ooze")
tests/test_world.py:29:        assert game.ability is True
tests/test_world.py:65:    def test_replace_treasure(self):
tests/test_world.py:74:        post_treasure = treasure.replace_treasure(pre.treasure, "elixir")
tests/test_world.py:430:            ability=False,
tests/test_world.py:435:                    talisman=0,

tests/test_party.py
tests/test_player.py
tests/test_regular.py
tests/test_shell.py
tests/test_special.py
tests/test_treasure.py
tests/test_world.py
[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "droll"
version = "0.1"
authors = [
    {name = "Rhys Ulerich"},
]
description = "Implementation of game mechanics for Dungeon Roll"
readme = "README.md"
requires-python = ">=3.9"
classifiers = [
    "Programming Language :: Python :: 3",
]

[project.optional-dependencies]
dev = [
    "flake8",
    "pytest",
]

[project.scripts]
droll = "droll.__main__:main"

[tool.pytest.ini_options]
testpaths = ["tests"]
pythonpath = ["."]

[tool.setuptools.packages.find]
where = ["."]
include = ["droll*"]

[tool.setuptools.package-data]
"*" = ["*"]

ange: struct.RandRange,
    command: str,
    targets: tuple[str, ...] = (),
    *,
    _acceptable_targets: frozenset[str] = frozenset({"fighter", "mage"}),
) -> struct.World:
    """Spellsword usable as a fighter or a mage, adding one hero to party.

    Optionally, specify 'fighter' or 'mage' to select which to choose."""
    return _choose_and_add_hero(world, command, targets, _acceptable_targets)

    decrement_dungeon,
    eliminate_dungeon,
)
from .party import decrement_party, decrement_regroup, increment_party
from .struct import (
    DrollError,
    Dungeon,
    Party,
    RandRange,
    World,
    field_names,
    field_values,
)
from .treasure import draw_treasure, replace_treasure

__all__ = (
    "bait_dragon",
    "defeat_all",
    "defeat_dragon",
    "defeat_dragon_heroes",
    "defeat_one"
…[8630 chars omitted]…
idx:])
        )
        if self._undo and "undo".startswith(text):
            names.append("undo")
        # Trailing space causes tab completion to insert token separators
        return [x + " " for x in names]

    def completenames(self, text, line, begidx, endidx):
        """Provide tab completion suggestions for command names."""
        return self.completedefault(text, line, begidx, endidx)

)
from .party import increment_party
from .struct import DrollError
from .treasure import draw_treasure, replace_treasure

__all__ = (
    "default_ability",
    "battlemage_ability",
    "beguiler_ability",
    "chieftain_ability",
    "commander_ability",
    "crusader_ability",
    "enchantress_ability",
    "halfgoblin_ability",
    "knight_ability",
    "mercenary_ability",
    "minstrel_ability",
    "necromancer_ability",
    "occultist_ability",
    "paladin_
…[8630 chars omitted]…
agon=_crusader_defeat_dragon,
        ),
        scroll=replace(
            Default.party.scroll,
            dragon=_crusader_defeat_dragon,
        ),
    ),
)

# Defined after Paladin to permit advance(...) closure
Crusader = replace(
    Paladin,
    name="Crusader",
    ability=crusader_ability,
    advance=(lambda world: Crusader if world.experience < 5 else Paladin),
    party=Paladin.party,
)

99:Treasure: None
106:Treasure: None
113:Treasure: None
114:Consider: ability retreat(+0 XP)
117:06 Knight> help ability
118:Invoke the player's ability.
123:Treasure: None
124:Consider: ability retreat(+0 XP)
127:06 Knight> ability
130:Treasure: None
137:Treasure: None
144:Treasure: None
151:Treasure: elixir talisman
158:Treasure: elixir talisman
165:Treasure: elixir talisman
172:Treasure: elixir talisman
179:Treasure
…[8629 chars omitted]…
eon(dungeon, target)
        increased = roll_dungeon(
            dice=len(dungeon_targets), randrange=randrange
        )
        dungeon = Dungeon(
            *map(
                add,
                field_values(dungeon),
                field_values(increased),
            )
        )

    if party_targets:
        for target in party_targets:
            party = decrement_party(party, target)

    def test_scroll_reroll(self):
        """Test reroll command to reroll dungeon dice (issue #133)."""
        # Consumed by canned_sequence just below
        sequence = [0, 1, 2]

        def canned_sequence(start, stop):
            """Predetermined sequence values for deterministic testing."""
            return start + sequence.pop(0)

        # 'reroll' re-rolls chests via the scroll mechanic
        game = player.apply(
            player.Default,
            self.gam
…[8630 chars omitted]…
liminate_dungeon(world.dungeon, targets[0]),
        party=party,
        regroup=decrement_regroup(world.regroup, hero),
    )


def _classify_reroll_targets(
    dungeon_or_party: tuple[str, ...],
    allow_dragon: bool,
) -> tuple[list[str], list[str]]:
    """Classify reroll targets into dungeon and party lists."""
    dungeon_targets = []
    party_targets = []
    for target in dungeon_or_party:

droll/regular.py-46-
droll/regular.py-47-def not_reroll(
droll/regular.py-48-    world: World, randrange: RandRange, hero: str, targets: tuple[str, ...]
droll/regular.py-49-) -> World:
droll/regular.py-50-    """Scrolls cannot target dungeon dice directly; use 'reroll' instead."""
droll/regular.py-51-    raise DrollError(f'Use "reroll {targets[0]}" to re-roll with a scroll.')
droll/regular.py-52-
droll/regular.py-53-
droll/regular.py:54:def 
…[8630 chars omitted]…
completions."""
        names = self._game.completenames(text="", head=[], tail=[])
        if self._undo:
            names.append("undo")
        return (
            ["do_" + x for x in names]
            + [
                "help_" + x
                for x in names
                if not getattr(self, "do_" + x, None)
            ]
            + ["help_" + x for x in self._HELP_TOPICS]
        )

194-    dungeon_targets, party_targets = _classify_reroll_targets(
195-        targets, allow_dragon
196-    )
197-
198-    # Decrement hero and regroup BEFORE any dice are rolled to prevent
199-    # stochastic exploitation: a rolled result cannot be immediately spent.
200-    party = decrement_party(world.party, hero)
201-    regroup = decrement_regroup(world.regroup, hero)
202-
203-    dungeon = world.dungeon
204-    if dungeon_targets:
205-        for target in dungeon_targets:
206-            dungeon = decrement_dungeon(dungeon, target)
…[4482 chars omitted]…
ise DrollError(f"Hero required for {command}.")
379-    return replace(
380-        world,
381-        treasure=replace_treasure(world.treasure, command),
382-        party=increment_party(world.party, targets[0]),
383-    )
./droll.egg-info/PKG-INFO:269:   experience equal to your depth.  You must descend at least once
./README.md:255:   experience equal to your depth.  You must descend at least once

21 DragonSlayer> ^D
```

Beyond the "Consider:" line, party members and treasures in
your possession are valid commands.  Type "help" to see
the full list.

The default display uses color when writing to a terminal.
Press Ctrl+D to exit at any time.

## How to play

You get 3 delves into the dungeon per game.  Each delve proceeds
as follows:

1. Roll 7 party dice producing random fighters, clerics, mages,
   thieves, champions, and scrolls.
2. Descend one depth at a time.  At each depth, new dungeon dice
   appear: goblins, ske
…[8629 chars omitted]…
xt_depth > _max_depth:
        raise DrollError(f"Maximum depth is {_max_depth}.")
    prior_dragons = 0 if world.dungeon is None else world.dungeon.dragon
    new_dice = max(1, min(_dungeon_dice - prior_dragons, next_depth))
    rolled = roll_dungeon(new_dice, randrange)
    return replace(
        world,
        depth=next_depth,
        dungeon=replace(rolled, dragon=rolled.dragon + prior_dragons),

__all__ = (
    "Beguiler",
    "Enchantress",
)

# Scrolls act as wildcards for dragon defeats
_beguiler_defeat_dragon = partial(
    regular.defeat_dragon,
    hero_validator=partial(
        regular.defeat_dragon_heroes,
        disallowed_heroes=frozenset(),
        wildcard=frozenset({"scroll"}),
    ),
)

# Defined in terms of Default, not Enchantress, to permit advance(...) closure
Beguiler = replace(
    Default,
    name="Beguiler",
    a
…[8629 chars omitted]…
pply("portal")


def test_apply_ring_directly_fails():
    """Test that using ring directly gives helpful error."""
    g = Game(random=random.Random(4), player=Default)
    g.descend()
    g._world = replace(
        g._world,
        treasure=replace(
            g._world.treasure, own=replace(g._world.treasure.own, ring=1)
        ),
    )
    with pytest.raises(DrollError):
        g.apply("ring")

   130	        raise DrollError('To use a portal, directly "retire".')
   131	    if command == "ring":
   132	        raise DrollError('To use a ring, directly "descend" or "retire".')
   133	    if command in {"ability", "bait", "elixir"}:
   134	        try:
   135	            action_ = geta
…[8628 chars omitted]…
           results += self.completedefault(text, head, tail)
   221	        return results
   222	
   223	    def completedefault(
   224	        self,
   225	        text: str,
   226	        head: Sequence[str],
   227	        tail: Sequence[str],
   228	    ) -> Sequence[str]:
   229	        """Complete loosely based upon available heroes/treasures/dungeon."""
   230	        return player.complete(

…[3563 chars omitted]…
it")
tests/test_treasure.py:73:        game = player.apply(player.Default, game, None, artifact, specialty)
tests/test_treasure.py:78:        game = player.apply(player.Default, game, None, artifact, other)
tests/test_treasure.py:84:            player.apply(player.Default, game, None, artifact, other)
tests/test_treasure.py:107:        game = player.apply(player.Default, game, None, "tools", "goblin")

Treasure: None
Consider: retreat(+0 XP)
Party:    fighter cleric mage thief champion
Dungeon:  goblin×2 chest×2 dragon×2
08 Knight> fighter goblin

Score 0:  depth 4 in delve 1 with 0 XP
Treasure: None
Consider: descend retire(+4 XP) undo
Party:    cleric mage thief champion
Dungeon:  chest×2 dragon×2
09 Knight> thief chest

Score 2:  depth 4 in delve 1 with 0 XP
Treasure: elixir talisman
Consider: descend retire(+4 XP)
Party:    cleric mage champion
Dungeon:  dragon×2
10 Knight> descend

Score 2:  depth 5 in delve 1 with 0 XP
Treasure: elixir talisman
Consider: retreat(+
…[6547 chars omitted]…
 to retreat from; use 'retire' to leave the dungeon.")

    experience = world.experience
    try:
        world = _apply_portal(world)
        experience += world.depth
    except DrollError:
        pass

    return replace(_regroup(world), depth=0, experience=experience, dungeon=None)


def score(world: struct.World) -> int:
    """Compute the present score for the world, including all treasure."""

from droll import struct
from droll.display import DisplayMode
from droll.struct import DrollError
from droll.game import Game
from droll.player import Default
from droll.shell import Shell, _RESET


def _mechanical_shell(game: Game) -> Shell:
    return Shell(game, display_mode=DisplayMode.MECHANICAL)


def test_precmd_emits_reset_when_color_enabled():
    with patch("sys.stdout.isatty", return_value=True):
        s = Shell(Game(), display_mode=DisplayMode.CURRENT)
    s.preloop()
    with patch("sys.stdou
…[8629 chars omitted]…
fi", head=[], tail=[])
    assert "fighter" in results


def test_score_deltas_retire_cleared():
    """score_deltas returns +depth for retire with cleared dungeon."""
    g = Game(random=random.Random(4), player=Default)
    g.descend()
    g._world = replace(g._world, dungeon=struct.Dungeon())
    deltas = g.score_deltas()
    assert "retire" in deltas
    assert deltas["retire"] == g._world.depth

+        # only later arguments (heroes revived by potions) are partified.
+        if raw_targets:
+            targets = (raw_targets[0],) + targets[1:]
+
+    if world.dungeon is None and (
+        command == "ability" or hasattr(player.party, command)
+    ):
+        raise
…[496 chars omitted]…
ure:
 
 def replace_treasure(treasure: Treasure, item: str) -> Treasure:
     """Replace a single item from the player's own artifacts into the box."""
+    if item not in field_names(treasure.own):
+        raise DrollError(f"'{item}' is not a valid treasure type.")
     prior_count = getattr(treasure.own, item)
     if not prior_count:
         raise DrollError(f"'{item}' not in player's treasure.")

| portal     | 2      | Town portal to escape the dungeon      |
| ring       | 1      | Sneak past a dragon                    |
| scale      | 1      | But a pair of scales scor
…[3980 chars omitted]…
arty members and treasures."""
    candidates = {
        key
        for source in (world.party, world.treasure.own)
        if source is not None
        for key, value in struct.field_items(source)
        if value and key not in _TREASURE_NO_COMMAND
    }
    if "scroll" in candidates:
        candidates.add("reroll")
    return candidates


def _available_targets(world: struct.World) -> set[str]:

        available = s._available_commands()
        assert "undo" not in available
    
        # Execute undoable command (ability doesn't change random state)
        s.onecmd("ability")
    
        #
…[340 chars omitted]…
2, cleric=2, mage=1, scroll=2), ability=True, regroup=(discard=()), treasure=(own=(), box=(sword=3, talisman=3, sceptre=3, tools=3, scroll=3, elixir=3, bait=4, portal=4, ring=4, scale=6)))
You must descend first.
=========================== short test summary info ============================
FAILED tests/test_shell.py::test_undo_in_available_commands - AssertionError:...
1 failed, 209 passed in 0.86s

__all__ = (
    "convert_dungeon_to_party",
    "defeat_all_plus_additional",
    "defeat_one_plus_additional",
)


def _defeat_plus_additional(
    world: World,
    randrange: RandRange,
    hero: str,
    additional: tuple,
) -> World:
    """After the initial defeat, optionally defeat one additional monster."""
    if defeated_monsters(world.dungeon):
        if additional:
            raise DrollError(
                f"Additional t
…[2795 chars omitted]…
       f"Exactly {world.dungeon.potion} heroes to revive required."
droll/ability.py:307:        for _ in range(world.dungeon.chest):
droll/special.py:27:    if defeated_monsters(world.dungeon):
droll/special.py:89:    count = min(getattr(world.dungeon, source), max_count)
droll/special.py:95:            world.dungeon,
droll/special.py:96:            **{source: getattr(world.dungeon, source) - count},

+    raw_targets = targets
     command, targets = _partify_all(player.artifacts, command, targets)
+    if command == "ability" and player.ability is ability.paladin_ability:
+        # The P
…[928 chars omitted]…
ure:
 
 def replace_treasure(treasure: Treasure, item: str) -> Treasure:
     """Replace a single item from the player's own artifacts into the box."""
+    if item not in field_names(treasure.own):
+        raise DrollError(f"'{item}' is not a valid treasure type.")
     prior_count = getattr(treasure.own, item)
     if not prior_count:
         raise DrollError(f"'{item}' not in player's treasure.")

+    raw_targets = targets
     command, targets = _partify_all(player.artifacts, command, targets)
+    if command == "ability" and player.ability is ability.paladin_ability:
+        # The Paladin's first ability argument is the treasure to consume;
+        # only lat
…[926 chars omitted]…
reasure, item: str) -> Treasure:
     """Replace a single item from the player's own artifacts into the box."""
+    if item not in field_names(treasure.own):
+        raise DrollError(f"'{item}' is not a valid treasure type.")
     prior_count = getattr(treasure.own, item)
     if not prior_count:
         raise DrollError(f"'{item}' not in player's treasure.")
 M droll/player.py
 M droll/treasure.py