rhysu-droll-182-190

/repo/droll/heroes/spellsword.py
/repo/droll/heroes/__init__.py
/repo/droll/party.py
/repo/droll/player.py
/repo/droll/regular.py
/repo/droll/shell.py
/repo/droll/special.py
/repo/droll/struct.py
/repo/droll/treasure.py
/repo/droll/world.py
/repo/droll/__init__.py
/repo/droll/__main__.py
/repo/tests/heroes/test_crusader.py
/repo/tests/heroes/test_enchantress.py
/repo/tests/heroes/test_halfgoblin.py
/repo/tests/heroes/test_knight.py
/repo/tests/heroes/test_mercenary.py
/repo/tests/heroes/test_minstrel.py
/repo/tests/heroes/test_occultist.py
/repo/tests/heroes/test_spellsword.py
/repo/tests/heroes/__init__.py
/repo/tests/test_ability.py
/repo/tests/test_display.py
/repo/tests/test_game.py
/repo/tests/test_party.py
/repo/tests/test_player.py
/repo/tests/test_regular.py
/repo/tests/test_shell.py
/repo/tests/test_special.py
/repo/tests/test_treasure.py
/repo/tests/test_world.py
---
LICENSE
README.md
droll
droll.egg-info
pyproject.toml
tests

from .game import Game, GameState
from .struct import DrollError

__all__ = ("Shell",)

_ABSENT = "\033[90m"
_COMMAND = "\033[96m"
_DRAGON = "\033[31m"
_ERROR = "\033[91m"
_HELP = "\033[93m"
_MONSTER = "\033[91m"
_PROMPT = "\033[92m"
_RESET = "\033[0m"


class Shell(cmd.Cmd):
    """REPL permitting playing a Game via tab-completion shell."""

    def __init__(
        self,
        game: Game,
        *,
        display_mode: display.DisplayMode = display.DisplayMode.CURRENT,
    ) -> None:
        """Initialize the shell with a game 
…[8629 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}),
    )

        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."""
        _no
…[1084 chars omitted]…
    def do_undo(self, line) -> GameState:
178:    def do_EOF(self, line) -> GameState:
191:    def do_ability(self, line) -> GameState:
201:    def do_descend(self, line) -> GameState:
207:    def do_reroll(self, line) -> GameState:
212:    def do_retire(self, line) -> GameState:
218:    def do_retreat(self, line) -> GameState:
265:    def do_help(self, arg):
285:        print(self.do_ability.__doc__)

__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__ = (
    "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
…[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),

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 
…[4297 chars omitted]…
   }


def complete(
    world: struct.World,
    tokens: Sequence[str],
    text: str,
    position: int,
) -> Sequence[str]:
    """Possible completions for text with position among (partial) tokens."""
    if position == 0:
        candidates = _available_nouns(world)
    elif position == 1 and tokens[0] == "elixir":
        candidates = set(struct.field_names(struct.Party))
    elif position == 1:

)
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_
…[8629 chars omitted]…
, ...]
) -> World:
    """Update world after hero handles all of one type of target."""
    if len(targets) != 1:
        raise DrollError(f"Exactly 1 target required but {len(targets)} given.")
    return replace(
        world,
        dungeon=eliminate_dungeon(world.dungeon, targets[0]),
        party=decrement_party(world.party, hero),
        regroup=decrement_regroup(world.regroup, hero),
    )

/repo/droll/heroes/crusader.py:63:# Defined after Paladin to permit advance(...) closure

-rolls chests via the scroll mechanic
tests/test_player.py:176:    def test_scroll_not_reroll(self):
tests/test_player.py:177:        """Using 'scroll' as a noun for rerolling raises DrollError (#133)."""
tests/test_regular.py:42:        result = regular.reroll(self.world, randrange, "scroll", ("fighter",))
tests/test_regular.py:84:            regular.reroll(self.world, randrange, "scroll", ("mage",))

…[3104 chars omitted]…
d, _UNUSED, "ability", ("elixir", "mage"))


def test_paladin_ability_requires_treasure():
    """Paladin ability fails without specifying treasure."""
    world = struct.World(
        ability=True,
        party=struct.Party(fighter=1),
        treasure=struct.Treasure(own=struct.Artifacts(elixir=1)),
    )
    with pytest.raises(struct.DrollError):
        paladin_ability(world, _UNUSED, "ability")

    "DRAGON_BLOCKING_THRESHOLD",
    "blocking_dragon",
    "decrement_dungeon",
    "defeated_dungeon",
    "defeated_monsters",
    "eliminate_dungeon",
    "finished_dungeon",
    "increment_dungeon",
)

# A dragon blocks progress when this many or more dragon dice are present.
DRAGON_BLOCKING_THRESHOLD = 3


def defeated_monsters(dungeon: Optional[Dungeon]) -> bool:
    """Are all non-dragon monsters on this dungeon defeated?"""
    return (dungeon is None) or (
        dung
…[1326 chars omitted]…
tattr(dungeon, target, 0)
    return replace(dungeon, **{target: prior_targets + 1})


def eliminate_dungeon(dungeon: Dungeon, target: str) -> Dungeon:
    """Remove all targets of the specified type from the dungeon."""
    prior_targets = getattr(dungeon, target)
    if not prior_targets:
        raise DrollError(f"At least 1 {target} required in dungeon.")
    return replace(dungeon, **{target: 0})

    *,
    after_monsters=True,
) -> World:
    """Update world after hero quaffs all available potions.

    Unlike {defeat,open}_{one,all}(...), heroes to revive are arguments."""
    if not targets:
        raise DrollError("At least 1 target required.")
    howmany = getattr(world.dungeon, targets[0])
    if not howmany:
        raise DrollError(f"At least 1 {targets[0]} required.")
    if len(targets) - 1 != howmany:
        raise DrollError(f"Exactly {howmany} heroes to revive required.")
    if after_monsters and not defeated_monsters(world.dungeon):
        raise DrollError("Mons
…[4320 chars omitted]…



def defeat_dragon(
    world: World,
    randrange: RandRange,
    hero: str,
    targets: tuple[str, ...],
    *,
    hero_validator: Callable[..., None] = defeat_dragon_heroes,
    _min_dragon_count: int = DRAGON_BLOCKING_THRESHOLD,
) -> World:
    """Update world after hero handles a dragon using multiple distinct heroes.

    Additional required heroes are specified within the targets tuple."""

droll/regular.py-346-        raise DrollError(f"Can only {command} dragon dice.")
droll/regular.py-347-    if require_treasure:
droll/regular.py-348-        world = replace(world, treasure=replace_treasure(world.treasure, command))
dr
…[1043 chars omitted]…
ro die of any type."""
droll/regular.py-377-    if not targets:
droll/regular.py-378-        raise DrollError(f"Hero required for {command}.")
droll/regular.py-379-    return replace(
droll/regular.py-380-        world,
droll/regular.py-381-        treasure=replace_treasure(world.treasure, command),
droll/regular.py-382-        party=increment_party(world.party, targets[0]),
droll/regular.py-383-    )

…[784 chars omitted]…
r.py:416:        game = player.apply(
tests/test_regular.py:442:        game = player.apply(
tests/test_regular.py:463:            player.apply(
tests/test_regular.py:476:            player.apply(
tests/test_regular.py:486:            player.apply(
tests/test_regular.py:496:            player.apply(
tests/test_regular.py:507:            player.apply(
tests/test_regular.py:520:            player.apply(

        """Test fighter hero attacking goblins and oozes."""
        game = player.apply(
            player.Default, self.game, None, "fighter", "goblin"
        )
        assert game.party.fighter == 1
        assert game.dungeon.goblin == 0

        game = player.apply(player.Default, game, None, "fighter", "ooze")
        assert game.party.fighter == 0
        assert game.dungeon.ooze == 1

        with pytest.raises(struct.DrollError):
            player.apply(player.
…[558 chars omitted]…
  player.Default, game, self.randrange, "cleric", "chest"
        )
tests/test_game.py:124:    assert "ability" in names
tests/test_game.py:129:        n not in ("ability", "descend", "retire", "retreat") for n in names
tests/test_shell.py:88:    s.help_ability()
tests/test_shell.py:197:    # Execute undoable command (ability doesn't change random state)
tests/test_shell.py:198:    s.onecmd("ability")

    g._world = replace(g._world, dungeon=struct.Dungeon(goblin=1))
    names = g.completenames(text="", head=[], tail=[])
    assert "ability" in names
    assert "retreat" in names
    assert "retire" not in names
    # Hero-related completions appear (dungeon not exhausted)
    assert any(
        n not in ("ability", "descend", "retire", "retreat") for n in names
    )

    # With cleared dungeon: retire is possible
    g._world = replace(g._world, dungeon=struct.Dungeon())
    names = g.completenames(text="", head=[], 
…[590 chars omitted]…
ity doesn't change random state)
    s.onecmd("ability")

    # Now undo stack has one item, so "undo" should be available
    available = s._available_commands()
    assert "undo" in available

    # Execute undo to restore previous state
    s.onecmd("undo")

    # Undo stack is empty again, so "undo" should not be available
    available = s._available_commands()
    assert "undo" not in available

__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
…[1213 chars omitted]…
rgets:
        raise DrollError("At least 1 target required.")
    world = defeat_one(
        world=world, randrange=randrange, hero=hero, targets=targets[:1]
    )
    return _defeat_plus_additional(world, randrange, hero, targets[1:])


def convert_dungeon_to_party(
20:def _defeat_plus_additional(
50:def defeat_all_plus_additional(
65:def defeat_one_plus_additional(
80:def convert_dungeon_to_party(

     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 corresponding hero types.
+    # Ability targets are exempt: some abilities (e.g. Paladin) consume
+    # treasures named as artifacts rather than targeting heroes.
+    command, targets = _partify_all(
+        player.artifacts, comman
…[2094 chars omitted]…
treasure: Treasure, item: str) -> Treasure:
     """Replace a single item from the player's own artifacts into the box."""
+    if not hasattr(treasure.own, item) or not hasattr(treasure.box, item):
+        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.")