Bot and conn now have a memory DefaultDict, where command can stick data they want to keep in memory

Author: dmptrluke

cloudbot/bot.py

@@ -1,6 +1,7 @@
 import asyncio
 import time
 import logging
+import collections
 import re
 import os
 import gc
@@ -61,6 +62,9 @@ def __init__(self, loop=asyncio.get_event_loop()):
         # for plugins
         self.logger = logger
 
+        # for plugins to abuse
+        self.memory = collections.defaultdict()
+
         # declare and create data folder
         self.data_dir = os.path.abspath('data')
         if not os.path.exists(self.data_dir):

cloudbot/client.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+import collections
 
 from cloudbot.permissions import PermissionManager
 
@@ -48,6 +49,9 @@ def __init__(self, bot, name, nick, *, channels=None, config=None):
         # create permissions manager
         self.permissions = PermissionManager(self)
 
+        # for plugins to abuse
+        self.memory = collections.defaultdict()
+
     def describe_server(self):
         raise NotImplementedError
 

plugins/randoms.py

@@ -1,9 +1,104 @@
+"""
+randoms.py
+Dice, coins, and other randomized things!
+"""
+
 import asyncio
 import random
 import re
 
 from cloudbot import hook
 
+whitespace_re = re.compile(r'\s+')
+valid_diceroll = re.compile(r'^([+-]?(?:\d+|\d*d(?:\d+|F))(?:[+-](?:\d+|\d*d(?:\d+|F)))*)( .+)?$', re.I)
+sign_re = re.compile(r'[+-]?(?:\d*d)?(?:\d+|F)', re.I)
+split_re = re.compile(r'([\d+-]*)d?(F|\d*)', re.I)
+
+
+def n_rolls(count, n):
+    """roll an n-sided die count times
+    :type count: int
+    :type n: int | str
+    """
+    if n == "F":
+        return [random.randint(-1, 1) for x in range(min(count, 100))]
+    if n < 2:  # it's a coin
+        if count < 100:
+            return [random.randint(0, 1) for x in range(count)]
+        else:  # fake it
+            return [int(random.normalvariate(.5 * count, (.75 * count) ** .5))]
+    else:
+        if count < 100:
+            return [random.randint(1, n) for x in range(count)]
+        else:  # fake it
+            return [int(random.normalvariate(.5 * (1 + n) * count,
+                                             (((n + 1) * (2 * n + 1) / 6. -
+                                               (.5 * (1 + n)) ** 2) * count) ** .5))]
+
+
+@asyncio.coroutine
+@hook.command("roll", "dice")
+def dice(text, notice):
+    """<dice roll> - simulates dice rolls. Example: 'dice 2d20-d5+4 roll 2': D20s, subtract 1D5, add 4
+    :type text: str
+    """
+
+    if hasattr(text, "groups"):
+        text, desc = text.groups()
+    else:  # type(text) == str
+        match = valid_diceroll.match(whitespace_re.sub("", text))
+        if match:
+            text, desc = match.groups()
+        else:
+            notice("Invalid dice roll '{}'".format(text))
+            return
+
+    if "d" not in text:
+        return
+
+    spec = whitespace_re.sub('', text)
+    if not valid_diceroll.match(spec):
+        notice("Invalid dice roll '{}'".format(text))
+        return
+    groups = sign_re.findall(spec)
+
+    total = 0
+    rolls = []
+
+    for roll in groups:
+        count, side = split_re.match(roll).groups()
+        count = int(count) if count not in " +-" else 1
+        if side.upper() == "F":  # fudge dice are basically 1d3-2
+            for fudge in n_rolls(count, "F"):
+                if fudge == 1:
+                    rolls.append("\x033+\x0F")
+                elif fudge == -1:
+                    rolls.append("\x034-\x0F")
+                else:
+                    rolls.append("0")
+                total += fudge
+        elif side == "":
+            total += count
+        else:
+            side = int(side)
+            try:
+                if count > 0:
+                    d = n_rolls(count, side)
+                    rolls += list(map(str, d))
+                    total += sum(d)
+                else:
+                    d = n_rolls(-count, side)
+                    rolls += [str(-x) for x in d]
+                    total -= sum(d)
+            except OverflowError:
+                # I have never seen this happen. If you make this happen, you win a cookie
+                return "Thanks for overflowing a float, jerk >:["
+
+    if desc:
+        return "{}: {} ({})".format(desc.strip(), total, ", ".join(rolls))
+    else:
+        return "{} ({})".format(total, ", ".join(rolls))
+
 
 @asyncio.coroutine
 @hook.command