@@ -69,18 +69,6 @@ Karma Phy - Looks better spelt with a K
 
 Karma Pi - Phy for physics, pi for math.
 
-# Install
-
-To install from source:
-
-   python setup.py install
-
-
-To install in development mode:
-
-   python setup.py develop --user
-
-
 ## Ubuntu on Pi
 
 
@@ -140,15 +128,62 @@ Docs need a fair bit of work, but better docstrings in the code turn into pretty
 
 ## Release
 
+pip3.x install karmapi
+
+x = 5 or 6, may be just 3.6 soon.
+
+### Making a new release
+
+Install some stuff needed to help with building releases:
+
+   pip3.6 install twine wheel
+
+Build a source releas (this just creates a tarball in the dists/ subfolder):
+
+   python setup.py sdist
+
+Build a binary release as a wheel (:
+
+   python setup.py bdist_wheel
+
+Upload to PyPi with twine (you will need a username and password that
+has access to the project you are trying to update):
+
+   twine upload dist/*
 
 ## Develop
 
 git clone https://github.com/openbermuda/karmapi
 
 cd karmapi
 
-python3 setup.py develop --user
+pip3.6 -e ,
+
+## Python3.6 on Ubuntu 16.04
+
+    git clone https://github.com/python/cpython
+
+checkout 3.6 branch, then:
+
+    ./configure
+    make
+    make install
+
+Note: python3.6 can be installed (from universe) with apt on Ubuntu >= 16.10.
+
+### Things to do first
+
+Some dev libraries need installing into Ubuntu for certain features to be built into the python.
+
+tkinter is one part you need to make sure *tk-8.6-dev* is installed before ./configure.
+
+The good news is that after the intitial build it all runs pretty fast.
+
+* tk-8.6-dev -- for tkinter
+
+* libbz2-dev -- compression library
 
+* libssl-dev -- for ssl support required for pip3.6 to work.
 
 ## TODO
 
 
@@ -0,0 +1,49 @@
+===========
+ Eric Idle
+===========
+
+Eric Idle was a python.
+
+So when Guido needed a simple development environment to show people
+python, IDLE was born,
+
+
+IDLE gives you a python prompt and a simple editor that knows a little
+about python,
+
+
+Python Console
+==============
+
+Since *currie* is currently running using tkinter and *currie* could
+do with a console, time to take a look at IDLE.
+
+
+Editor
+======
+
+An editor might be handy too,
+
+It might be easy to get these working in a *PigFarm*.
+
+
+idlelib
+=======
+
+The code for IDLE comes with python, you can import it with *idlelib*.
+
+A quick look at the code and pig farm integration does not look too
+hard.
+
+The main obstacle is that *idlelib* had solved a lot of what *PigFarm*
+and *piglets* are doing here.
+
+Who knew that a library called *idlelib* written 20 years ago might
+have saved some work?
+
+async idle
+==========
+
+On a PigFarm the eventloop will be run by *curio*.
+
+
@@ -49,6 +49,14 @@ Astro pi
    astro_pi
 
 
+Eric
+====
+
+.. toctree::
+
+   eric
+
+
 Indices and tables
 ==================
 
 
@@ -15,6 +15,7 @@
 """
 from collections import deque
 import curio
+from pathlib import Path
 
 from karmapi import hush
 
@@ -249,7 +250,7 @@ def main():
 
     parser.add_argument('--monitor', action='store_true')
     parser.add_argument('--nomon', action='store_false', default=True)
-
+    parser.add_argument('--words', default='diceware.wordlist.asc')
 
     args = parser.parse_args()
 
@@ -302,12 +303,19 @@ def main():
             im_info.update(im)
             farm.add(piglet.Image, im_info.copy())
 
+
+    words = Path(args.words)
+    if words.exists():
+        words = words.open()
+    else:
+        words = None
+        
     farm.add(talk.Talk)
-    farm.add(dice.StingingBats)
+    farm.add(dice.StingingBats, dict(words=words))
     farm.add(StingingBats)
 
     farm.add(TankRain)
-    farm.add(sunny.Sunspot)
+    #farm.add(sunny.Sunspot)
     farm.add(sonogram.SonoGram)
     farm.add(piglet.XKCD)
     farm.add(widgets.InfinitySlalom)
 
@@ -14,14 +14,25 @@
 import random
 import math
 
+BIGLY = 'helvetica 20 bold'
 
 class StingingBats(pig.Canvas):
 
-    def __init__(self, parent):
+    def __init__(self, parent, words=None):
 
         super().__init__(parent)
 
         self.width = self.height = 200
+
+        if words:
+            self.words = load_words(words)
+        else:
+            self.words = None
+
+        self.size = 5
+        self.sides = 6
+        self.canvas_text = None
+        
         self.minswarms = 20
         self.maxswarms = 50
         self.themes = []
@@ -44,7 +55,21 @@ def create_event_map(self):
         self.add_event_map('k', self.more)
         self.add_event_map('f', self.fast)
         self.add_event_map('s', self.slow)
+        self.add_event_map('r', self.roll)
         self.add_event_map('t', self.next_theme)
+        self.add_event_map('u', self.up)
+        self.add_event_map('d', self.down)
+
+    async def up(self):
+        """ Increase the number of dice """
+
+        self.size += 1
+
+
+    async def down(self):
+        """ Decrease the number of dice """
+
+        self.size -= 1
 
 
     async def next_theme(self):
@@ -77,9 +102,24 @@ async def slow(self):
 
         self.sleep += 0.05
 
+    async def roll(self):
+        ''' roll the dice '''
+
+        self.data = [random.randint(1, self.sides) for die in range(self.size)]
+
+        total = 0
+        for die in self.data:
+            total += (total * self.size) + die
+
+        self.total = total
+
+        print(f'{self.data} {total}')
+
+        self.canvas_text = f'{self.data}    {total}   {self.sides ** self.size}'
+        
+
     def create_swarms(self):
 
-        print('new swarms')
         self.swarms = [Swarm()
                            for x in range(random.randint(self.minswarms, self.maxswarms))]
 
@@ -95,6 +135,80 @@ def recalc(self, width, height):
         self.canvas.configure(scrollregion=(0, 0, width, height))
 
 
+    def draw_digit(self, x, y, size, die):
+        """ Draw a digit like a die """
+        digits = {
+            1: ((0,0,0), (0,1,0), (0,0,0)),
+            2: ((1,0,0), (0,0,0), (0,0,1)),
+            3: ((1,0,0), (0,1,0), (0,0,1)),
+            4: ((1,0,1), (0,0,0), (1,0,1)),
+            5: ((1,0,1), (0,1,0), (1,0,1)),
+            6: ((1,0,1), (1,0,1), (1,0,1))}
+
+        
+        self.draw_pixel(digits[die], x, y, size, size, 10)
+
+    def draw_pixel(self, data, x, y, width, height, size, colour=None):
+
+        #colour = 'red'
+        colour = colour or self.random_colour()
+        
+        for ix, row in enumerate(data):
+            for jx, col in enumerate(row):
+
+                xx = (ix * width) + x
+                
+                yy = (jx * height) + x
+
+                #print(f'zzzz {xx} {yy} {size}, {colour}')
+                
+                if col:
+                    self.canvas.create_arc(xx-size, yy-size, xx+size, yy+size,
+                        start=0, extent=180, fill=colour)
+
+    def random_colour(self):
+
+        colours = self.theme.colours
+
+        return colours[random.randint(0, len(colours) - 1)]
+
+
+    def dice_ware_text(self):
+        """ Return password for current data """
+
+        # FIXME get a diceware list of words
+        # Also, remind me to write a bit about why real dice are better
+
+        try:
+            return self.words[tuple(self.data)]
+        except:
+            return "no dice"
+
+    def draw_dice(self):
+        """ Draw the dice """
+
+        #FIXME make the tkinter part async
+        totsize = min(self.width, self.height)
+
+        gap = totsize / (1 + self.size)
+
+        xx = gap / 2
+        yy = gap / 2
+
+        ygap = (self.height / 3) / (self.size - 1)
+
+        text = self.dice_ware_text()
+        self.canvas.create_text(totsize - (2 * gap), yy, fill=self.random_colour(),
+                                text=text, font=BIGLY)
+        
+        for die in self.data:
+            self.draw_digit(xx, yy, gap * 0.4, die)
+
+            xx += gap
+            yy += gap
+
+            
+
     async def run(self):
         self.sleep = 0.1
 
@@ -112,6 +226,13 @@ async def run(self):
                 ray.draw(self.canvas, self.width, self.height,
                             self.theme.colours)
 
+            if self.canvas_text:
+                self.canvas.create_text((self.width * 0.3, self.height * 0.9),
+                                        text=self.canvas_text, fill='yellow',
+                                        font=BIGLY)
+                self.draw_dice()
+
+
             await curio.sleep(self.sleep)
 
 
@@ -132,7 +253,6 @@ def __init__(self):
         self.step = 0
         self.this_step = random.randint(40, 100)
 
-
     def draw(self, canvas, width, height, colours):
 
 
@@ -176,3 +296,18 @@ def draw(self, canvas, width, height, colours):
             self.this_step = random.randint(40, 100)
 
         # FIXME: draw tail -- sine wave angle of dangle based on dx, dy
+
+
+def load_words(infile):
+
+    words = {}
+    six = set([str(x) for x in range(1, 7)])
+    for row in infile:
+        if row[0] in six:
+
+            fields = row.split()
+            key = tuple(int(x) for x in fields[0])
+            
+            words[key] = fields[-1]
+
+    return words