Create the consumables

typeclasses/consumables.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python
+
+from evennia import Command, CmdSet
+from evennia.prototypes.spawner import spawn
+
+from typeclasses.objects import Object
+from utils.word_list import routput
+
+from datetime import date
+import random
+
+
+class CmdEat(Command):
+    """
+    Eat something
+    """
+    key = "eat"
+    aliases = "bite"
+
+    def func(self):
+        self.obj.do_eat(self.caller)
+
+
+class CmdSetEat(CmdSet):
+    def at_cmdset_creation(self):
+        self.add(CmdEat)
+
+
+class Consumable(Object):
+    """
+    Create with a command:
+
+    @create/drop berries;berry : typeclasses.consumables.Consumable
+    @desc berries = Bright red, almost violet, berry.
+    # How many berries are there?
+    @set berries/amount = 10
+    # How many berries do you eat at a time:
+    @set berries/eat_amount = 3
+    @set berries/eat_msg = "Sweet and slightly tart. [Delicious|Tangy|Mmmm]."
+    @set berries/finish_msg = "Those were [delicious|great]."
+    """
+    amount = 4
+    eat_amount = 1
+
+    def at_object_creation(self):
+        self.cmdset.add_default(CmdSetEat)
+        self.db.amount = self.amount
+        self.db.eat_amount = self.eat_amount
+
+    def do_eat(self, eater):
+        tea_type = self.db.tea_type or "tea"
+        tea_details = self.db.tea_details
+
+        self.db.amount = self.db.amount - self.db.eat_amount
+        if self.db.eat_msgs:
+            msg = random.choice(self.db.eat_msgs)
+        elif self.db.eat_msg:
+            msg = self.db.eat_msg
+        else:
+            msg = "You take a bite."
+        eater.msg(routput(msg))
+
+        if self.db.amount <= 0:
+            if self.db.finish_msgs:
+                msg = random.choice(self.db.finish_msgs)
+            elif self.db.finish_msg:
+                msg = self.db.finish_msg
+            else:
+                msg = "You finished it."
+            eater.msg(routput(msg))
+            self.delete()
+
+
+class CmdMakeConsumable(Command):
+    """
+    Generate a new thing and give it to the caller.
+    """
+    key = "pick"
+    # aliases = "pick"
+
+    def func(self):
+        self.obj.do_make(self.caller, self.args)
+
+
+class CmdSetMakeConsumable(CmdSet):
+    def at_cmdset_creation(self):
+        self.add(CmdMakeConsumable)
+
+
+class Producer(Object):
+    """
+    An object that produces a Consumable object.
+    Use it to create a 'berry bush', for instance:
+
+    @create/drop berry bush;bush : typeclasses.consumables.Producer
+    @desc bush = A bush laden with bright red brambleberries.
+
+    # Then describe what to produce:
+    @set bush/make_name = "berries"
+    @set bush/make_aliases = ["berry"]
+    @set bush/make_verb = "pick some"
+    # This one is optional as it defaults to Consumable:
+    @set bush/make_class = "typeclasses.consumables.Consumable"
+    @set bush/make_desc = "Bright red berry with flecks of [purple|violet|orange]."
+
+    # How many berries are there when you pick them?
+    @set bush/make_amount = 10
+    # How many berries do you eat at a time:
+    @set bush/make_eat_amount = 3
+
+    # Either a single msg:
+    @set bush/make_eat_msg = "Sweet and slightly tart. [Delicious|Tangy|Mmmm]."
+    # Or many:
+    @set bush/make_eat_msgs = [ "Sweet and slightly tart.", "[Delicious|Tangy|Mmmm].", "Ooo...that one was sour.", "That was a bit ripe, but still good.", "So sweet with a hint of [orange|maple]." ]
+    @set bush/make_finish_msg = "Those were [delicious|great]."
+    """
+    def at_object_creation(self):
+        self.cmdset.add_default(CmdSetMakeConsumable)
+
+    def do_make(self, picker, args):
+        consumable = spawn({
+            "typeclass": self.db.make_class or "typeclasses.consumables.Consumable",
+            "key": self.db.make_name,
+            "aliases": self.db.make_aliases,
+            "desc": routput(self.db.make_desc),
+        })[0]
+        consumable.db.amount = self.db.make_amount or 3
+        consumable.db.eat_amount = self.db.make_eat_amount or 1
+
+        if self.db.make_eat_msg:
+            consumable.db.eat_msg = self.db.make_eat_msg
+        if self.db.make_eat_msgs:
+            consumable.db.eat_msgs = self.db.make_eat_msgs
+        if self.db.make_finish_msg:
+            consumable.db.finish_msg = self.db.make_finish_msg
+        if self.db.make_finish_msgs:
+            consumable.db.finish_msgs = self.db.make_finish_msgs
+
+        consumable.location = picker
+        picker.msg(f"You {self.db.make_verb or 'get'} {self.db.make_name}.")
+
+
+# ----------------------------------------------------------------------
+
+class CmdMakeScone(Command):
+    """
+    Generate a new thing and give it to the caller.
+    """
+    key = "get scone"
+    # aliases = "take scone"
+
+    def func(self):
+        self.obj.do_make(self.caller, self.args)
+
+
+class CmdSetMakeScone(CmdSet):
+    def at_cmdset_creation(self):
+        self.add(CmdMakeScone)
+
+
+class Trolley(Producer):
+    """
+    A special producer that has a plate of specific dishes for
+    that day. I need this special because I'm not sure how to populate
+    the database with complex arrays of data.
+
+    """
+    scones = [
+        {
+            "name": "blueberry scone",
+            "taste": "blueberries",
+        },
+        {
+            "name": "chocolate chip scone",
+            "taste": "chocolate",
+        },
+        {
+            "name": "lemon poppy seed scone",
+            "taste": "lemon",
+        },
+        {
+            "name": "cinnamon scone",
+            "taste": "spice",
+        },
+        {
+            "name": "cranberry orange scone",
+            "tastes": ["tartness of the cranberries", "orange"],
+        },
+        {
+            "name": "pumpkin scone",
+            "taste": "spices",
+        },
+        {
+            "name": "cheddar cheese and chive scone",
+            "expression": "cheesy"
+        },
+        {
+            "name": "cherry almond scone",
+            "expression": "nutty",
+        },
+        {
+            "name": "apple cinnamon scone",
+            "tastes": ["apple", "cinnamon"],
+        },
+    ]
+
+    def at_object_creation(self):
+        self.cmdset.add_default(CmdSetMakeScone)
+
+    def do_bake(self):
+        """
+        Set the scone that we bake today.
+        """
+        todays_scone = self.scones[date.today().day % len(self.scones)]
+        name = todays_scone.get("name")
+
+        self.db.make_name =  name
+        self.db.make_aliases = ["scone", "scones"]
+        self.db.make_desc = routput(f"A [tasty|yummy|delicious]-looking {name}")
+        self.db.make_amount = 3
+        self.db.make_eat_amount = 1
+
+        msgs = [
+            "[Delicious|Mmmm|So good|Really good].",
+        ]
+        if todays_scone.get('taste'):
+            msgs += [f"You [can|] [really|] [notice|taste] the {todays_scone.get('taste')}."]
+        if todays_scone.get('tastes'):
+            for taste in todays_scone.get('tastes'):
+                msgs += [f"You [can|] [really|] [notice|taste] the {taste}."]
+        if todays_scone.get('expression'):
+            msgs += [f"[Really|So] {todays_scone.get('expression')}."]
+
+        self.db.make_eat_msgs = msgs
+        self.db.make_finish_msg = "That was [delicious|great|really good]."