add pick_lock skill and command

Author: neph1

tale/accounts.py

@@ -109,11 +109,13 @@ def _create_database(self) -> None:
                             alignment integer NOT NULL,
                             strength integer NOT NULL,
                             dexterity integer NOT NULL,
+                            perception integer NOT NULL,
+                            intelligence integer NOT NULL,
                             weapon_skills varchar NOT NULL,
                             magic_skills varchar NOT NULL,
-                            skils varchar NOT NULL,
-                            combat_points integer NOT NULL,
-                            max_combat_points integer NOT NULL,
+                            skills varchar NOT NULL,
+                            action_points integer NOT NULL,
+                            max_action_points integer NOT NULL,
                             magic_points integer NOT NULL,
                             max_magic_points integer NOT NULL,
                             FOREIGN KEY(account) REFERENCES Account(id)

tale/base.py

@@ -976,12 +976,14 @@ def __init__(self) -> None:
         self.race = ""      # the name of the race of this creature
         self.strength = 3
         self.dexterity = 3
+        self.perception = 3
+        self.intelligence = 3
         self.unarmed_attack = Weapon(UnarmedAttack.FISTS.name, weapon_type=WeaponType.UNARMED)
         self.weapon_skills = {}  # type: Dict[WeaponType, int]  # weapon type -> skill level
         self.magic_skills  = {}  # type: Dict[MagicType, MagicSkill]
         self.skills = {}  # type: Dict[str, int]  # skill name -> skill level
         self.action_points = 0 # combat points
-        self.max_combat_points = 5 # max combat points
+        self.max_action_points = 5 # max combat points
         self.max_magic_points = 5 # max magic points
         self.magic_points = 0 # magic points
 
@@ -1001,7 +1003,7 @@ def from_race(cls: type, race: builtins.str, gender: builtins.str='n') -> 'Stats
     def set_stats_from_race(self) -> None:
         # the stats that are static are always initialized from the races table
         # we look it up via the name, not needed to store the actual Race object here
-        r = races.races[self.race]
+        r = races.races[self.race] # type: Race
         self.bodytype = r.body
         self.language = r.language
         self.weight = r.mass
@@ -1028,9 +1030,9 @@ def replenish_combat_points(self, amount: int = None) -> None:
         if amount:
             self.action_points += amount
         else:
-            self.action_points = self.max_combat_points
-        if self.action_points > self.max_combat_points:
-            self.action_points = self.max_combat_points
+            self.action_points = self.max_action_points
+        if self.action_points > self.max_action_points:
+            self.action_points = self.max_action_points
 
     def replenish_magic_points(self, amount: int = None) -> None:
         if amount:
@@ -1650,6 +1652,8 @@ def do_on_death(self) -> 'Container':
         return remains
 
     def hide(self, hide: bool = True):
+        """ Hide or reveal the living entity. """
+
         if not hide:
             self.hidden = False
             self.hidden = False
@@ -1673,19 +1677,29 @@ def hide(self, hide: bool = True):
         self.tell("You hide yourself.")
         self.location.tell("%s hides" % self.title, exclude_living=self)
 
-    def search_hidden(self):
+    def search_hidden(self, silent: bool = False):
+        """ Search for hidden entities in the room.
+         For automatic searches (like when entering a room),
+         no fail messages will show, and no action points will be used."""
+        
         if self.stats.action_points < 1:
             raise ActionRefused("You don't have enough action points to search.")
 
         livings = self.location.livings
 
-        self.location.tell("%s searches for something in the room." % (self.title), exclude_living=self)
+        if not silent:
+            self.stats.action_points -= 1
+            self.location.tell("%s searches for something in the room." % (self.title), exclude_living=self)
 
         if len(self.location.livings) == 1:
-            self.tell("You don't find anything.")
+            if not silent:
+                self.tell("You don't find anything.")
             return
 
-        skillValue = self.stats.skills.get(SkillType.SEARCH, 0)
+        if silent:
+            skillValue = self.stats.perception * 5
+        else:
+            skillValue = self.stats.skills.get(SkillType.SEARCH, 0)
 
         found = False
 
@@ -1698,9 +1712,31 @@ def search_hidden(self):
                     self.location.tell("%s reveals %s" % (self.title, living.title), exclude_living=self)
                     found = True
 
-        if not found:
+        if not found and not silent:
             self.tell("You don't find anything.")
 
+    def pick_lock(self, door: 'Door'):
+        """ Pick a lock on an exit. """
+        if not door.locked:
+            raise ActionRefused("The door is not locked.")
+        
+        if self.stats.action_points < 1:
+            raise ActionRefused("You don't have enough action points to pick the lock.")
+        
+        self.stats.action_points -= 1
+        
+        skillValue = self.stats.skills.get(SkillType.PICK_LOCK, 0)
+
+        if random.randint(1, 100) > skillValue:
+            self.tell("You fail to pick the lock.")
+            return
+        
+        door.unlock()
+
+        self.tell("You successfully pick the lock.", evoke=True)
+
+        if not self.hidden:
+            self.location.tell("%s picks the lock on the door." % self.title, exclude_living=self)
 
 class Container(Item):
     """
@@ -2044,6 +2080,33 @@ def insert(self, item: Union[Living, Item], actor: Optional[Living]) -> None:
             else:
                 raise ActionRefused("You could try to lock the door with it instead.")
         raise ActionRefused("The %s doesn't fit." % item.title)
+    
+    def pick_lock(self, actor: Living) -> None:
+        if not self.locked:
+            raise ActionRefused("The door is not locked.")
+        
+        if actor.stats.action_points < 1:
+            raise ActionRefused("You don't have enough action points to pick the lock.")
+        
+        actor.stats.action_points -= 1
+        
+        skillValue = actor.stats.skills.get(SkillType.PICK_LOCK, 0)
+
+        if random.randint(1, 100) > skillValue:
+            actor.tell("You fail to pick the lock.")
+            return
+        
+        self.locked = False
+        self.opened = True
+
+        actor.tell("You successfully pick the %s." % (self.name), evoke=True, short_len=True)
+        if not actor.hidden:
+            actor.location.tell("%s picks the lock on the door." % actor.title, exclude_living=actor)
+            actor.tell_others("{Actor} picks the %s, and opens it." % (self.name), evoke=True, short_len=True)
+        if self.linked_door:
+            self.linked_door.locked = False
+            self.linked_door.opened = True
+            self.target.tell("The %s is unlocked and opened from the other side." % self.linked_door.name, evoke=False, short_len=True)
 
 
 class Key(Item):

tale/cmds/normal.py

@@ -1868,5 +1868,21 @@ def do_search_hidden(player: Player, parsed: base.ParseResult, ctx: util.Context
 
     player.search_hidden()
 
+@cmd("pick_lock")
+def do_pick_lock(player: Player, parsed: base.ParseResult, ctx: util.Context) -> None:
+    """Pick a lock on a door."""
+    if len(parsed.args) < 1:
+        raise ParseError("You need to specify the door to pick")
+    try:
+        exit = str(parsed.args[0])
+    except ValueError as x:
+        raise ActionRefused(str(x))
+    if exit in player.location.exits:
+        door = player.location.exits[exit]
+
+        if not isinstance(door, base.Door) or not door.locked:
+            raise ActionRefused("You can't pick that")
+        
+        door.pick_lock(player)
 
 

tale/cmds/spells.py

@@ -112,7 +112,7 @@ def do_rejuvenate(player: Player, parsed: base.ParseResult, ctx: util.Context) -
 def do_hide(player: Player, parsed: base.ParseResult, ctx: util.Context) -> None:
     """ Hide from view """
 
-    skillValue, spell = _check_spell_skill(player, MagicType.HIDE, "You don't know how the 'hide' spell.")
+    skillValue, spell = _check_spell_skill(player, MagicType.HIDE, "You don't know the 'hide' spell.")
     level = _parse_level(player, parsed)
 
     if not spell.check_cost(player.stats.magic_points, level):
@@ -135,7 +135,7 @@ def do_hide(player: Player, parsed: base.ParseResult, ctx: util.Context) -> None
 def do_reveal(player: Player, parsed: base.ParseResult, ctx: util.Context) -> None:
     """ Reveal hidden things. """
 
-    skillValue, spell = _check_spell_skill(player, MagicType.REVEAL, "You don't know how the 'reveal' spell.")
+    skillValue, spell = _check_spell_skill(player, MagicType.REVEAL, "You don't know the 'reveal' spell.")
     level = _parse_level(player, parsed, 0)
 
     if not spell.check_cost(player.stats.magic_points, level):

tale/skills/skills.py

@@ -6,4 +6,5 @@
 class SkillType(Enum):
 
     HIDE = 1
-    SEARCH = 2
+    SEARCH = 2
+    PICK_LOCK = 3

tests/test_normal_commands.py

@@ -3,7 +3,7 @@
 import pytest
 import tale
 from tale import wearable
-from tale.base import Item, Location, ParseResult, Weapon, Wearable
+from tale.base import Door, Item, Location, ParseResult, Weapon, Wearable
 from tale.cmds import normal
 from tale.errors import ActionRefused, ParseError
 from tale.llm.LivingNpc import LivingNpc
@@ -193,4 +193,36 @@ def test_search_hidden(self):
 
         normal.do_search_hidden(self.test_player, ParseResult(verb='search', args=[]), self.context)
 
-        assert not test_npc.hidden
+        assert not test_npc.hidden
+
+    def test_pick_lock(self):
+        self.test_player.stats.skills[SkillType.PICK_LOCK] = 100
+        self.test_player.stats.action_points = 1
+
+        hall = Location("hall")
+        door = Door("north", hall, "a locked door", locked=True, opened=False)
+        hall.add_exits([door])
+        hall.insert(self.test_player, actor=None)
+        
+        parse_result = ParseResult(verb='pick_lock', args=['north'])
+        normal.do_pick_lock(self.test_player, parse_result, self.context)
+        assert not door.locked
+
+        # Test failure
+
+        door.locked = True
+
+        self.test_player.stats.skills[SkillType.PICK_LOCK] = 0
+        self.test_player.stats.action_points = 1
+
+        normal.do_pick_lock(self.test_player, parse_result, self.context)
+
+        assert door.locked
+
+        # Test no action points
+
+        self.test_player.stats.skills[SkillType.PICK_LOCK] = 100
+        self.test_player.stats.action_points = 0
+
+        with pytest.raises(ActionRefused, match="You don't have enough action points to pick the lock."):
+            normal.do_pick_lock(self.test_player, parse_result, self.context)

tests/test_player.py

@@ -811,6 +811,8 @@ def test_dbcreate(self):
             self.assertEqual(races.BodySize.HUMAN_SIZED, account.stats.size)
             self.assertEqual("Edhellen", account.stats.language)
             self.assertEqual({}, account.stats.weapon_skills)
+            self.assertEqual({}, account.stats.magic_skills)
+            self.assertEqual({}, account.stats.skills)
         finally:
             dbfile.unlink()
 

tests/test_spells.py

@@ -226,7 +226,7 @@ def test_hide_fail(self):
 
     def test_hide_refused(self):
         parse_result = ParseResult(verb='hide', args=[])
-        with pytest.raises(ActionRefused, match="You don't know how the 'hide' spell."):
+        with pytest.raises(ActionRefused, match="You don't know the 'hide' spell."):
             spells.do_hide(self.player, parse_result, None)
 
         self.player.stats.magic_skills[MagicType.HIDE] = 10
@@ -283,7 +283,7 @@ def test_reveal_fail(self):
 
     def test_reveal_refused(self):
         parse_result = ParseResult(verb='reveal', args=[])
-        with pytest.raises(ActionRefused, match="You don't know how the 'reveal' spell."):
+        with pytest.raises(ActionRefused, match="You don't know the 'reveal' spell."):
             spells.do_reveal(self.player, parse_result, None)
 
         self.player.stats.magic_skills[MagicType.REVEAL] = 10

tests/test_stats.py

@@ -20,7 +20,7 @@ def test_replenish_hp(self):
 
     def test_replenish_combat_points(self):
         stats = Stats()
-        stats.max_combat_points = 100
+        stats.max_action_points = 100
         stats.action_points = 0
 
         stats.replenish_combat_points(10)