Merge lp:~ashfall/divmod.org/1320678-remove-imaginary into lp:divmod.org

[Ashwini Oruganti]

Removes Imaginary from lp:divmod.org

[Tristan Seligmann (mithrandi)]

Looks good, please merge (I'm assuming you have commit access to lp:divmod.org; let me know if this isn't the case).

review: Approve

=== modified file 'Divmod.pth'
--- Divmod.pth	2013-06-27 06:02:46 +0000
+++ Divmod.pth	2014-05-18 17:55:49 +0000
@@ -1,4 +1,4 @@
-# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,xquotient,reverend,sine,hyperbola,imaginary,examplegame -*-
+# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,xquotient,reverend,sine,hyperbola -*-
 Axiom
 Combinator
 Epsilon
@@ -8,6 +8,4 @@
 Reverend
 Sine
 Hyperbola
-Imaginary
-Imaginary/ExampleGame
 Prime

=== removed directory 'Imaginary'
=== removed file 'Imaginary/COMPATIBILITY.txt'
--- Imaginary/COMPATIBILITY.txt	2009-08-17 02:40:03 +0000
+++ Imaginary/COMPATIBILITY.txt	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-Imaginary provides _no_ source-level compatibility from one release to the next.
-
-Efforts will be made to provide database level compatibility (i.e. data from
-one release can be loaded with the next).  However, although we will try to
-ensure that data will load, there is no guarantee that it will be meaningfully
-upgraded yet.

=== removed file 'Imaginary/DEPS.txt'
--- Imaginary/DEPS.txt	2013-07-10 00:22:10 +0000
+++ Imaginary/DEPS.txt	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-Python 2.7
-Twisted 13.1
-Epsilon SVN-Trunk
-Axiom SVN-Trunk

=== removed directory 'Imaginary/ExampleGame'
=== removed directory 'Imaginary/ExampleGame/examplegame'
=== removed file 'Imaginary/ExampleGame/examplegame/__init__.py'
=== removed file 'Imaginary/ExampleGame/examplegame/furniture.py'
--- Imaginary/ExampleGame/examplegame/furniture.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/furniture.py	1970-01-01 00:00:00 +0000
@@ -1,139 +0,0 @@
-# -*- test-case-name: examplegame.test.test_furniture -*-
-
-"""
-
-    Furniture is the mass noun for the movable objects which may support the
-    human body (seating furniture and beds), provide storage, or hold objects
-    on horizontal surfaces above the ground.
-
-        -- Wikipedia, http://en.wikipedia.org/wiki/Furniture
-
-L{imaginary.furniture} contains L{Action}s which allow players to interact with
-household objects such as chairs and tables, and L{Enhancement}s which allow
-L{Thing}s to behave as same.
-
-This has the same implementation weakness as L{examplegame.tether}, in that it
-needs to make some assumptions about who is moving what in its restrictions of
-movement; it should be moved into imaginary proper when that can be properly
-addressed.  It's also a bit too draconian in terms of preventing the player
-from moving for any reason just because they're seated.  However, it's a
-workable approximation for some uses, and thus useful as an example.
-"""
-
-from zope.interface import implements
-
-from axiom.item import Item
-from axiom.attributes import reference
-
-from imaginary.iimaginary import ISittable, IContainer, IMovementRestriction
-from imaginary.eimaginary import ActionFailure
-from imaginary.events import ThatDoesntWork
-from imaginary.language import Noun
-from imaginary.action import Action, TargetAction
-from imaginary.events import Success
-from imaginary.enhancement import Enhancement
-from imaginary.objects import Container
-from imaginary.pyparsing import Literal, Optional, restOfLine
-
-class Sit(TargetAction):
-    """
-    An action allowing a player to sit down in a chair.
-    """
-    expr = (Literal("sit") + Optional(Literal("on")) +
-            restOfLine.setResultsName("target"))
-
-    targetInterface = ISittable
-
-    def do(self, player, line, target):
-        """
-        Do the action; sit down.
-        """
-        target.seat(player)
-
-        actorMessage=["You sit in ",
-                      Noun(target.thing).definiteNounPhrase(),"."]
-        otherMessage=[player.thing, " sits in ",
-                      Noun(target.thing).definiteNounPhrase(),"."]
-        Success(actor=player.thing, location=player.thing.location,
-                actorMessage=actorMessage,
-                otherMessage=otherMessage).broadcast()
-
-
-class Stand(Action):
-    """
-    Stand up from a sitting position.
-    """
-    expr = (Literal("stand") + Optional(Literal("up")))
-
-    def do(self, player, line):
-        """
-        Do the action; stand up.
-        """
-        # XXX This is wrong.  I should be issuing an obtain() query to find
-        # something that qualifies as "my location" or "the thing I'm already
-        # sitting in".
-        chair = ISittable(player.thing.location, None)
-        if chair is None:
-            raise ActionFailure(ThatDoesntWork(
-                    actor=player.thing,
-                    actorMessage=["You're already standing."]))
-        chair.unseat(player)
-        Success(actor=player.thing, location=player.thing.location,
-                actorMessage=["You stand up."],
-                otherMessage=[player.thing, " stands up."]).broadcast()
-
-
-
-class Chair(Enhancement, Item):
-    """
-    A chair is a thing you can sit in.
-    """
-
-    implements(ISittable, IMovementRestriction)
-
-    powerupInterfaces = [ISittable]
-
-    thing = reference()
-    container = reference()
-
-
-    def movementImminent(self, movee, destination):
-        """
-        A player tried to move while they were seated.  Prevent them from doing
-        so, noting that they must stand first.
-
-        (Assume the player was trying to move themselves, although there's no
-        way to know currently.)
-        """
-        raise ActionFailure(ThatDoesntWork(
-                actor=movee,
-                actorMessage=u"You can't do that while sitting down."))
-
-
-    def applyEnhancement(self):
-        """
-        Apply this enhancement to this L{Chair}'s thing, creating a
-        L{Container} to hold the seated player, if necessary.
-        """
-        super(Chair, self).applyEnhancement()
-        container = IContainer(self.thing, None)
-        if container is None:
-            container = Container.createFor(self.thing, capacity=300)
-        self.container = container
-
-
-    def seat(self, player):
-        """
-        The player sat down on this chair; place them into it and prevent them
-        from moving elsewhere until they stand up.
-        """
-        player.thing.moveTo(self.container)
-        player.thing.powerUp(self, IMovementRestriction)
-
-
-    def unseat(self, player):
-        """
-        The player stood up; remove them from this chair.
-        """
-        player.thing.powerDown(self, IMovementRestriction)
-        player.thing.moveTo(self.container.thing.location)

=== removed file 'Imaginary/ExampleGame/examplegame/glass.py'
--- Imaginary/ExampleGame/examplegame/glass.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/glass.py	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-# -*- test-case-name: examplegame.test.test_glass -*-
-"""
-This example implements a transparent container that you can see, but not
-reach, the contents of.
-"""
-from zope.interface import implements
-
-from axiom.item import Item
-from axiom.attributes import reference
-
-from imaginary.iimaginary import (
-    ILinkContributor, IWhyNot, IObstruction, IContainer)
-from imaginary.enhancement import Enhancement
-from imaginary.objects import ContainmentRelationship
-from imaginary.idea import Link
-
-class _CantReachThroughGlassBox(object):
-    """
-    This object provides an explanation for why the user cannot access a target
-    that is inside a L{imaginary.objects.Thing} enhanced with a L{GlassBox}.
-    """
-    implements(IWhyNot)
-
-    def tellMeWhyNot(self):
-        """
-        Return a simple message explaining that the user can't reach through
-        the glass box.
-        """
-        return "You can't reach through the glass box."
-
-
-
-class _ObstructedByGlass(object):
-    """
-    This is an annotation on a link between two objects which represents a
-    physical obstruction between them.  It is used to annotate between a
-    L{GlassBox} and its contents, so you can see them without reaching them.
-    """
-    implements(IObstruction)
-
-    def whyNot(self):
-        """
-        @return: an object which explains why you can't reach through the glass
-        box.
-        """
-        return _CantReachThroughGlassBox()
-
-
-
-class GlassBox(Item, Enhancement):
-    """
-    L{GlassBox} is an L{Enhancement} which modifies a container such that it is
-    contained.
-    """
-
-    powerupInterfaces = (ILinkContributor,)
-
-    thing = reference()
-
-    def links(self):
-        """
-        If the container attached to this L{GlassBox}'s C{thing} is closed,
-        yield its list of contents with each link annotated with
-        L{_ObstructedByGlass}, indicating that the object cannot be reached.
-        """
-        container = IContainer(self.thing)
-        if container.closed:
-            for content in container.getContents():
-                link = Link(self.thing.idea, content.idea)
-                link.annotate([_ObstructedByGlass(),
-                               ContainmentRelationship(container)])
-                yield link

=== removed file 'Imaginary/ExampleGame/examplegame/japanese.py'
--- Imaginary/ExampleGame/examplegame/japanese.py	2007-08-17 04:46:38 +0000
+++ Imaginary/ExampleGame/examplegame/japanese.py	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-"""
-Japanese language data.
-
-This module contains a dict named 'hiragana' which maps hiragana
-unicode characters to romaji pronunciations, as well as a
-'romajiToHiragana' dict which maps romaji pronunciation to *lists* of
-hiragana characters. There are multiple hiragana characters with the
-same pronunciation, thus the multiple values per romaji in the
-romajiToHiragana dict.
-
-"""
-
-
-# Hiragana.
-hiragana = {
-    u'\u3042': 'A', u'\u3044': 'I', u'\u3046': 'U', u'\u3048': 'E',
-    u'\u3081': 'ME', u'\u3080': 'MU', u'\u3082': 'MO', u'\u3084': 'YA',
-    u'\u3086': 'YU', u'\u3089': 'RA', u'\u3088': 'YO', u'\u308b': 'RU',
-    u'\u308a': 'RI', u'\u308d': 'RO', u'\u308c': 'RE', u'\u308f': 'WA',
-    u'\u3091': 'WE', u'\u3090': 'WI', u'\u3093': 'N', u'\u3092': 'WO',
-    u'\u304b': 'KA', u'\u304a': 'O', u'\u304d': 'KI', u'\u304c': 'GA',
-    u'\u304f': 'KU', u'\u304e': 'GI', u'\u3051': 'KE', u'\u3050': 'GU',
-    u'\u3053': 'KO', u'\u3052': 'GE', u'\u3055': 'SA', u'\u3054': 'GO',
-    u'\u3057': 'SHI',u'\u3056': 'ZA', u'\u3059': 'SU', u'\u3058': 'JI',
-    u'\u305b': 'SE', u'\u305a': 'ZU', u'\u305d': 'SO', u'\u305c': 'ZE',
-    u'\u305f': 'TA', u'\u305e': 'ZO', u'\u3061': 'CHI', u'\u3060': 'DA',
-    u'\u3062': 'JI', u'\u3065': 'ZU', u'\u3064': 'TSU', u'\u3067': 'DE',
-    u'\u3066': 'TE', u'\u3069': 'DO', u'\u3068': 'TO', u'\u306b': 'NI',
-    u'\u306a': 'NA', u'\u306d': 'NE', u'\u306c': 'NU', u'\u306f': 'HA',
-    u'\u306e': 'NO', u'\u3071': 'PA', u'\u3070': 'BA', u'\u3073': 'BI',
-    u'\u3072': 'HI', u'\u3075': 'FU', u'\u3074': 'PI', u'\u3077': 'PU',
-    u'\u3076': 'BU', u'\u3079': 'BE', u'\u3078': 'HE', u'\u307b': 'HO',
-    u'\u307a': 'PE', u'\u307d': 'PO', u'\u307c': 'BO', u'\u307f': 'MI',
-    u'\u307e': 'MA'}
-
-
-romajiToHiragana = {}
-for k, v in hiragana.iteritems():
-    romajiToHiragana.setdefault(v, []).append(k)
-
-# Katakana.
-# katakana = {
-#     }

=== removed file 'Imaginary/ExampleGame/examplegame/mice.py'
--- Imaginary/ExampleGame/examplegame/mice.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/mice.py	1970-01-01 00:00:00 +0000
@@ -1,264 +0,0 @@
-# -*- test-case-name: examplegame.test.test_mice,examplegame.test.test_japanese -*-
-
-import random
-
-from zope.interface import implements
-
-from axiom import item, attributes
-
-from imaginary import iimaginary, events, objects, action, language
-from examplegame import japanese
-
-
-class Mouse(item.Item):
-    """
-    A silly mouse which squeaks when actors enter the room it is in.
-
-    @ivar _callLater: The scheduling function to use. Override in unit
-    tests only.
-    """
-
-    implements(iimaginary.IEventObserver)
-
-    squeakiness = attributes.integer(doc="""
-    How likely the mouse is to squeak when intruded upon (0 - 100).
-
-    This mouse is so angry that he will pretty much always squeak.
-    """, default=100)
-
-    _callLater = attributes.inmemory()
-
-    def activate(self):
-        from twisted.internet import reactor
-        self._callLater = reactor.callLater
-
-
-    def prepare(self, concept):
-        """
-        An event was received. Squeak if it represents the arrival of a dude.
-        """
-        if isinstance(concept, events.ArrivalEvent):
-            return lambda: self._callLater(0, self.squeak)
-        return lambda: None
-
-
-    def squeak(self):
-        actor = self.store.findUnique(
-            objects.Actor,
-            objects.Actor._enduringIntelligence == self)
-        evt = events.Success(
-            actor=actor.thing,
-            otherMessage=u"SQUEAK!")
-        evt.broadcast()
-
-
-
-class ChallengeCollision(Exception):
-    """
-    Raised when a L{HiraganaMouse} is asked to start issuing challenges when it
-    is already issuing challenges.
-    """
-
-
-
-class ChallengeVacuum(Exception):
-    """
-    Raised when a L{HiraganaMouse} is asked to stop issuing challenges when it
-    is already not issuing challenges.
-    """
-
-
-
-class HiraganaMouse(item.Item):
-    """
-    A mouse which occasionally challenges those in its location to
-    transliterate Hiragana.
-
-    @ivar _callLater: The scheduling function to use. Defaults to the
-    reactor's callLater method. This is parameterized for the sake of
-    unit tests.
-    """
-
-    implements(iimaginary.IEventObserver)
-
-    challenging = attributes.boolean(doc="""
-    Whether or not this mouse is currently creating random challenges.
-    """, default=False)
-
-    challengeInterval = attributes.integer(doc="""
-    Number of seconds between challenges.
-    """, default=15, allowNone=False)
-
-    _currentChallenge = attributes.text(doc="""
-    The Hiragana character which the mouse has most recently issued as a
-    challenge.
-    """, default=None)
-
-
-    _callLater = attributes.inmemory()
-    _currentChallengeCall = attributes.inmemory()
-
-    def activate(self):
-        from twisted.internet import reactor
-        self._callLater = reactor.callLater
-
-    def _actor(self):
-        """
-        Get the h-mouse's associated actor. PRIVATE. WHY DID I DOCUMENT THIS.
-        """
-        return self.store.findUnique(
-            objects.Actor,
-            objects.Actor._enduringIntelligence == self)
-
-
-    def _numDudes(self):
-        """
-        Get the number of actors (other than the h-mouse) in the
-        h-mouse's location. PRIVATE.
-        """
-        actor = self._actor()
-        numDudes = len([actor
-                        for dude
-                        in actor.thing.findProviders(iimaginary.IActor, 1)
-                        if dude is not actor])
-        return numDudes
-
-
-    def maybeChallenge(self):
-        """ 
-        Start challenging if there is anyone around to challenge (and
-        this h-mouse isn't already challenging).
-        """
-        if not self.challenging and self._numDudes() >= 1:
-            self.startChallenging()
-
-
-    def prepare(self, concept):
-        """
-        An event was received. Start or stop challenging as
-        appropriate, based on whether there is anyone to challenge.
-        """
-        if isinstance(concept, events.ArrivalEvent):
-            self.maybeChallenge()
-        elif isinstance(concept, events.DepartureEvent) and self._numDudes() == 0:
-            self.stopChallenging()
-        elif isinstance(concept, events.SpeechEvent) and concept.speaker is not self._actor().thing:
-            self.responseReceived(concept.speaker, concept.text)
-        return lambda: None
-
-
-    def startChallenging(self):
-        """
-        Start shouting hiragana in the hope that someone knows what it means.
-
-        @raises ChallengeCollision: If this h-mouse is already challenging.
-        """
-        if self.challenging:
-            raise ChallengeCollision()
-
-        self.challenging = True
-        self._scheduleChallenge()
-
-
-    def _scheduleChallenge(self):
-        """
-        Schedule a challenge to happen in the number of seconds set in
-        the instance attribute 'challengeInterval'.
-        """
-        self._currentChallengeCall = self._callLater(self.challengeInterval, 
-                                                     self._challengeAndRepeat)
-
-
-    def stopChallenging(self):
-        """
-        Stop shouting hiragana.
-        
-        @raises ChallengeVacuum: If this h-mouse is not currently challenging.
-        """
-        if not self.challenging:
-            raise ChallengeVacuum()
-
-        self.challenging = False
-
-        self._currentChallenge = None
-        self._currentChallengeCall.cancel()
-        self._currentChallengeCall = None
-
-
-    def _challengeAndRepeat(self):
-        """
-        Shout a challenge and then schedule another one.
-        """
-        self.challenge()
-        self._scheduleChallenge()
-
-
-    def getCurrentChallenge(self):
-        """
-        Return the Hiragana character which is this mouse's current challenge,
-        if it has one.
-
-        @rtype: C{unicode} or C{None}
-        """
-        return self._currentChallenge
-
-
-    def vetteChallengeResponse(self, romajiResponse):
-        """
-        Return True if the given response matches the current challenge, False
-        otherwise.
-        """
-        hiragana = japanese.romajiToHiragana.get(romajiResponse.upper(), None)
-        return hiragana is not None and self.getCurrentChallenge() in hiragana
-
-
-    def responseReceived(self, responder, romajiResponse):
-        """
-        Called when some speech is observed.
-        """
-        me = self._actor().thing
-        if self.vetteChallengeResponse(romajiResponse):
-            self._currentChallenge = None
-            verb = u"salute"
-        else:
-            verb = u"bite"
-        evt = events.Success(
-            actor=me,
-            target=responder,
-            actorMessage=language.Sentence(["You ", verb, " ", responder, "."]),
-            targetMessage=language.Sentence([language.Noun(me).shortName(), " ", verb, "s you!"]),
-            otherMessage=language.Sentence([me, " ", verb, "s ", responder, "."]))
-        # Fuck the reactor, Fuck scheduling, why does responseReceived
-        # need to be concerned with these stupid scheduling details
-        # when all it wants to do is respond basically-immediately.
-        self._callLater(0, evt.broadcast)
-
-
-    def challenge(self, character=None):
-        """
-        Say only a single random hiragana character.
-        """
-        if character is None:
-            character = random.choice(japanese.hiragana.keys())
-        self._currentChallenge = character
-        actor = self._actor()
-        action.Say().do(actor, None, character)
-
-
-
-def createMouseCreator(mouseIntelligenceFactory):
-    """
-    Create a createMouse function, which can be called to create a
-    mouse object. Used for the 'Create' command plugin system.
-    """
-    def createMouse(**kw):
-        store = kw['store']
-        mouse = objects.Thing(**kw)
-        mouseActor = objects.Actor.createFor(mouse)
-        mousehood = mouseIntelligenceFactory(store=store)
-        mouseActor.setEnduringIntelligence(mousehood)
-        return mouse
-    return createMouse
-
-createMouse = createMouseCreator(Mouse)
-createHiraganaMouse = createMouseCreator(HiraganaMouse)

=== removed file 'Imaginary/ExampleGame/examplegame/quiche.py'
--- Imaginary/ExampleGame/examplegame/quiche.py	2009-06-29 04:03:17 +0000
+++ Imaginary/ExampleGame/examplegame/quiche.py	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-# -*- test-case-name: examplegame.test.test_quiche -*-
-
-"""
-This module is a mid-level proof of concept of various features in Imaginary.
-
-Currently its implementation is a bit messy and it assumes lots of things about
-the reader's knowledge, but we are working on more thoroughly documenting it
-and making it into a good example of how to build functionality that interacts
-with multiple systems (currency, containment, object creation) in Imaginary.
-
-"""
-
-from zope.interface import implements, Interface
-
-from axiom import item, attributes
-
-from imaginary import iimaginary, objects, events, language
-from imaginary.enhancement import Enhancement
-
-from imaginary.creation import createCreator
-
-
-class ICoin(Interface):
-    """
-    Something small and probably flat and round and which probably serves as
-    some form of currency.
-    """
-
-
-
-class Coinage(object):
-    implements(ICoin)
-    powerupInterfaces = (ICoin,)
-
-
-
-class Quarter(item.Item, Coinage, Enhancement):
-    thing = attributes.reference(doc="""
-    The object this coin powers up.
-    """)
-
-
-
-class VendingMachine(item.Item, objects.Containment, Enhancement):
-    implements(iimaginary.IContainer)
-
-    capacity = attributes.integer(doc="""
-    Units of weight which can be contained.
-    """, allowNone=False, default=1)
-
-    closed = attributes.boolean(doc="""
-    Indicates whether the container is currently closed or open.
-    """, allowNone=False, default=True)
-
-    thing = attributes.reference(doc="""
-    The object this container powers up.
-    """)
-
-    _currencyCounter = attributes.integer(doc="""
-    The number of coins which have been added to this vending machine since it
-    last ejected an item.
-    """, allowNone=False, default=0)
-
-    def coinAdded(self, coin):
-        """
-        Called when a coin is added to this thing.
-
-        @type coin: C{ICoin} provider
-        """
-        self._currencyCounter += 1
-        if self._currencyCounter >= 5 and self.getContents():
-            self._currencyCounter = 0
-            try:
-                obj = iter(self.getContents()).next()
-            except StopIteration:
-                evt = events.Success(
-                    actor=self.thing,
-                    target=obj,
-                    otherMessage=language.Sentence([self.thing, " thumps loudly."]))
-            else:
-                evt = events.Success(
-                    actor=self.thing,
-                    target=obj,
-                    otherMessage=language.Sentence([
-                        language.Noun(self.thing).definiteNounPhrase(),
-                        " thumps loudly and spits out ", obj,
-                        " onto the ground."]))
-                state = self.closed
-                self.closed = False
-                try:
-                    obj.moveTo(self.thing.location)
-                finally:
-                    self.closed = state
-            evt.broadcast()
-
-
-    def add(self, obj):
-        coin = ICoin(obj, None)
-        if coin is not None:
-            self.coinAdded(coin)
-        else:
-            return super(VendingMachine, self).add(obj)
-
-
-
-def createVendingMachine(store, name, description=u""):
-    o = objects.Thing(store=store, name=name, description=description)
-    VendingMachine.createFor(o)
-    return o
-
-
-
-createCoin = createCreator((Quarter, {}))
-createVendingMachine = createCreator((VendingMachine, {}))
-createQuiche = createCreator()
-

=== removed file 'Imaginary/ExampleGame/examplegame/squeaky.py'
--- Imaginary/ExampleGame/examplegame/squeaky.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/squeaky.py	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-# -*- test-case-name: examplegame.test.test_squeaky -*-
-
-"""
-This module implements an L{ILinkAnnotator} which causes an object to squeak
-when it is moved.  It should serve as a simple example for overriding what
-happens when an action is executed (in this case, 'take' and 'drop').
-"""
-
-from zope.interface import implements
-
-from axiom.item import Item
-from axiom.attributes import reference
-
-from imaginary.iimaginary import IMovementRestriction, IConcept
-from imaginary.events import Success
-from imaginary.enhancement import Enhancement
-from imaginary.objects import Thing
-
-
-class Squeaker(Item, Enhancement):
-    """
-    This is an L{Enhancement} which, when installed on a L{Thing}, causes that
-    L{Thing} to squeak when you pick it up.
-    """
-
-    implements(IMovementRestriction)
-
-    powerupInterfaces = [IMovementRestriction]
-
-    thing = reference(allowNone=False,
-                      whenDeleted=reference.CASCADE,
-                      reftype=Thing)
-
-
-    def movementImminent(self, movee, destination):
-        """
-        The object enhanced by this L{Squeaker} is about to move - emit a
-        L{Success} event which describes its squeak.
-        """
-        Success(otherMessage=(IConcept(self.thing).capitalizeConcept(),
-                              " emits a faint squeak."),
-                location=self.thing.location).broadcast()

=== removed directory 'Imaginary/ExampleGame/examplegame/test'
=== removed file 'Imaginary/ExampleGame/examplegame/test/__init__.py'
=== removed file 'Imaginary/ExampleGame/examplegame/test/test_furniture.py'
--- Imaginary/ExampleGame/examplegame/test/test_furniture.py	2013-07-03 23:55:37 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_furniture.py	1970-01-01 00:00:00 +0000
@@ -1,104 +0,0 @@
-
-"""
-This module contains tests for the examplegame.furniture module.
-"""
-
-from twisted.trial.unittest import TestCase
-
-from imaginary.test.commandutils import CommandTestCaseMixin, E, createLocation
-
-from imaginary.objects import Thing, Exit
-from examplegame.furniture import Chair
-
-class SitAndStandTests(CommandTestCaseMixin, TestCase):
-    """
-    Tests for the 'sit' and 'stand' actions.
-    """
-
-    def setUp(self):
-        """
-        Create a room, with a dude in it, and a chair he can sit in.
-        """
-        CommandTestCaseMixin.setUp(self)
-        self.chairThing = Thing(store=self.store, name=u"chair")
-        self.chairThing.moveTo(self.location)
-        self.chair = Chair.createFor(self.chairThing)
-
-
-    def test_sitDown(self):
-        """
-        Sitting in a chair should move your location to that chair.
-        """
-        self.assertCommandOutput(
-            "sit chair",
-            ["You sit in the chair."],
-            ["Test Player sits in the chair."])
-        self.assertEquals(self.player.location, self.chair.thing)
-
-
-    def test_standWhenStanding(self):
-        """
-        You can't stand up - you're already standing up.
-        """
-        self.assertCommandOutput(
-            "stand up",
-            ["You're already standing."])
-
-
-    def test_standWhenSitting(self):
-        """
-        If a player stands up when sitting in a chair, they should be seen to
-        stand up, and they should be placed back into the room where the chair
-        is located.
-        """
-        self.test_sitDown()
-        self.assertCommandOutput(
-            "stand up",
-            ["You stand up."],
-            ["Test Player stands up."])
-        self.assertEquals(self.player.location, self.location)
-
-
-    def test_takeWhenSitting(self):
-        """
-        When a player is seated, they should still be able to take objects on
-        the floor around them.
-        """
-        self.test_sitDown()
-        self.ball = Thing(store=self.store, name=u'ball')
-        self.ball.moveTo(self.location)
-        self.assertCommandOutput(
-            "take ball",
-            ["You take a ball."],
-            ["Test Player takes a ball."])
-
-
-    def test_moveWhenSitting(self):
-        """
-        A player who is sitting shouldn't be able to move without standing up
-        first.
-        """
-        self.test_sitDown()
-        otherRoom = createLocation(self.store, u"elsewhere", None).thing
-        Exit.link(self.location, otherRoom, u'north')
-        self.assertCommandOutput(
-            "go north",
-            ["You can't do that while sitting down."])
-        self.assertCommandOutput(
-            "go south",
-            ["You can't go that way."])
-
-
-    def test_lookWhenSitting(self):
-        """
-        Looking around when sitting should display the description of the room.
-        """
-        self.test_sitDown()
-        self.assertCommandOutput(
-            "look",
-            # I'd like to add ', in the chair' to this test, but there's
-            # currently no way to modify the name of the object being looked
-            # at.
-            [E("[ Test Location ]"),
-             "Location for testing.",
-             "Here, you see Observer Player and a chair."])

=== removed file 'Imaginary/ExampleGame/examplegame/test/test_glass.py'
--- Imaginary/ExampleGame/examplegame/test/test_glass.py	2013-07-03 23:55:37 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_glass.py	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-
-"""
-Tests for L{examplegame.glass}
-"""
-
-from twisted.trial.unittest import TestCase
-
-from imaginary.test.commandutils import CommandTestCaseMixin, E
-
-from imaginary.objects import Thing, Container
-
-from examplegame.glass import GlassBox
-
-class GlassBoxTests(CommandTestCaseMixin, TestCase):
-    """
-    Tests for L{GlassBox}
-    """
-
-    def setUp(self):
-        """
-        Create a room with a L{GlassBox} in it, which itself contains a ball.
-        """
-        CommandTestCaseMixin.setUp(self)
-        self.box = Thing(store=self.store, name=u'box',
-                         description=u'The system under test.')
-        self.ball = Thing(store=self.store, name=u'ball',
-                          description=u'an interesting object')
-        self.container = Container.createFor(self.box)
-        GlassBox.createFor(self.box)
-        self.ball.moveTo(self.box)
-        self.box.moveTo(self.location)
-        self.container.closed = True
-
-
-    def test_lookThrough(self):
-        """
-        You can see items within a glass box by looking at them directly.
-        """
-        self.assertCommandOutput(
-            "look at ball",
-            [E("[ ball ]"),
-             "an interesting object"])
-
-
-    def test_lookAt(self):
-        """
-        You can see the contents within a glass box by looking at the box.
-        """
-        self.assertCommandOutput(
-            "look at box",
-            [E("[ box ]"),
-             "The system under test.",
-             "It contains a ball."])
-
-
-    def test_take(self):
-        """
-        You can't take items within a glass box.
-        """
-        self.assertCommandOutput(
-            "get ball",
-            ["You can't reach through the glass box."])
-
-
-    def test_openTake(self):
-        """
-        Taking items from a glass box should work if it's open.
-        """
-        self.container.closed = False
-        self.assertCommandOutput(
-            "get ball",
-            ["You take a ball."],
-            ["Test Player takes a ball."])
-
-
-    def test_put(self):
-        """
-        You can't put items into a glass box.
-        """
-        self.container.closed = False
-        self.ball.moveTo(self.location)
-        self.container.closed = True
-        self.assertCommandOutput(
-            "put ball in box",
-            ["The box is closed."])
-
-
-    def test_whyNot(self):
-        """
-        A regression test; there was a bug where glass boxes would interfere
-        with normal target-acquisition error reporting.
-        """
-        self.assertCommandOutput(
-            "get foobar",
-            ["Nothing like that around here."])

=== removed file 'Imaginary/ExampleGame/examplegame/test/test_japanese.py'
--- Imaginary/ExampleGame/examplegame/test/test_japanese.py	2013-07-03 23:55:37 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_japanese.py	1970-01-01 00:00:00 +0000
@@ -1,474 +0,0 @@
-import weakref
-
-from twisted.internet import task
-from twisted.trial import unittest
-
-from axiom import store
-
-from imaginary import iimaginary, objects, events, action
-
-from imaginary.test import commandutils
-
-from examplegame import mice
-from examplegame import japanese
-
-class MouseChallengeMixin(object):
-    """
-    A mixin meant to be used in TestCases which want to assert things
-    about mouse challenges.
-
-    The subclass must be sure to provide a C{player} instance
-    attribute, which is the L{IThing<iimaginary.IThing>} provider of
-    the player which observes the mouse, and a C{mouseName} attribute
-    which should be the mouse's name.
-    """
-    def assertChallenge(self, concept):
-        """
-        Assert that the given concept is a challenge from the mouse
-        named self.mouseName, as observed by self.player.
-        """
-        said = commandutils.flatten(concept.plaintext(self.player))
-        self.failUnless(said.startswith(u"A %s says, '" % (self.mouseName,)), repr(said))
-        self.failUnlessIn(said[-3], japanese.hiragana)
-        self.failUnless(said.endswith("'\n"), repr(said))
-
-
-
-class HiraganaMouseTestCase(MouseChallengeMixin, unittest.TestCase):
-    """
-    Test that there is a mouse that says hiragana and stuff
-    """
-
-    def setUp(self):
-        self.store = store.Store()
-
-        self.clock = objects.Thing(store=self.store, name=u"Clock")
-        self.clockContainer = objects.Container.createFor(self.clock, capacity=10)
-
-        self.mouseName = u"\N{KATAKANA LETTER PI}\N{KATAKANA LETTER SMALL YU}"
-        self.mouse = mice.createHiraganaMouse(
-            store=self.store,
-            name=self.mouseName)
-        self.mouseActor = iimaginary.IActor(self.mouse)
-        self.mousehood = self.mouseActor.getIntelligence()
-        self.mouse.moveTo(self.clock)
-
-        (self.player,
-         self.playerActor,
-         self.playerIntelligence) = commandutils.createPlayer(self.store,
-                                                              u"Mean Old Man")
-
-
-        self.player.moveTo(self.clock)
-
-        self.reactorTime = task.Clock()
-        self.mousehood._callLater = self.reactorTime.callLater
-
-
-    def test_mouseCanSqueak(self):
-        """
-        When explicitly told to challenge with a given romaji syllable, the
-        mouse should say a hiragana letter.
-        """
-        events.runEventTransaction(
-            self.store,
-            self.mousehood.challenge,
-            character=u"\N{HIRAGANA LETTER A}")
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 1)
-        event = self.playerIntelligence.concepts[0]
-        self.assertEquals(
-            commandutils.flatten(event.otherMessage.plaintext(self.player)),
-            u"A %s says, '\N{HIRAGANA LETTER A}'" % (self.mouseName,))
-
-
-    def test_randomHiragana(self):
-        """
-        When explicitly told to challenge without specifying a syllable, the
-        mouse should say a random one.
-        """
-        events.runEventTransaction(self.store, self.mousehood.challenge)
-        self.assertEquals(len(self.playerIntelligence.concepts), 1)
-        event = self.playerIntelligence.concepts[0]
-        self.assertChallenge(event)
-
-
-    def test_ji(self):
-        """
-        Two hiragana characters map to the romaji 'ji'.  Test that we do the
-        right thing for them.
-        """
-        self.mousehood.challenge(character=u"\N{HIRAGANA LETTER DI}")
-        self.failUnless(self.mousehood.vetteChallengeResponse(u"ji"))
-        self.mousehood.challenge(character=u"\N{HIRAGANA LETTER ZI}")
-        self.failUnless(self.mousehood.vetteChallengeResponse(u"ji"))
-
-
-    def test_zu(self):
-        """
-        Two hiragana characters map to the romaji 'zu'.  Test that we do the
-        right thing for them.
-        """
-        self.mousehood.challenge(character=u"\N{HIRAGANA LETTER DU}")
-        self.failUnless(self.mousehood.vetteChallengeResponse(u"zu"))
-        self.mousehood.challenge(character=u"\N{HIRAGANA LETTER ZU}")
-        self.failUnless(self.mousehood.vetteChallengeResponse(u"zu"))
-
-
-    def test_mouseStartsChallengingWhenPlayersArrive(self):
-        """
-        When a player arrives, the mouse should go into the 'I am
-        challenging' state.
-        """
-        # Whitebox
-        self.assertEquals(self.mousehood.challenging, False)
-
-        evt = events.ArrivalEvent(actor=self.player)
-        self.mouseActor.send(evt)
-
-        self.assertEquals(self.mousehood.challenging, True)
-
-
-    def test_mouseSchedulesChallenges(self):
-        """
-        After telling a mouse to start challenging, it should schedule timed
-        events to say challenges.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-        concepts = self.playerIntelligence.concepts
-        self.assertEquals(len(concepts), 1)
-        self.assertChallenge(concepts[0])
-
-
-    def test_mouseStopsChallengingWhenPlayersLeave(self):
-        """
-        When the 'last' player leaves, the mouse stops challenging.
-        """
-        # Whitebox
-        self.mousehood.startChallenging()
-
-        evt = events.DepartureEvent(location=self.clock,
-                                    actor=self.player)
-        self.player.moveTo(None)
-        self.mouseActor.send(evt)
-
-        self.assertEquals(self.mousehood.challenging, False)
-
-
-    def test_mouseStopsSchedulingChallenges(self):
-        """
-        When a mouse is told to stop challenging, it should cancel any
-        challenges it had scheduled.
-        """
-        self.mousehood.startChallenging()
-        self.mousehood.stopChallenging()
-
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-        self.assertEquals(self.playerIntelligence.concepts, [])
-
-
-    def test_stopChallengingWhenNotChallengingFails(self):
-        """
-        Don't stop challenging when you're not challenging.
-        """
-        self.assertRaises(mice.ChallengeVacuum, self.mousehood.stopChallenging)
-
-
-    def test_startChallengingTwiceFails(self):
-        """
-        Don't start challenging twice.
-        """
-        self.mousehood.startChallenging()
-        self.assertRaises(mice.ChallengeCollision, self.mousehood.startChallenging)
-
-
-    def test_challengeRecurrence(self):
-        """
-        After a challenge is issued another one should be issued later.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        self.assertIn(self.mousehood.getCurrentChallenge(), japanese.hiragana)
-
-        self.mousehood._currentChallenge = None # Clear his challenge evilly
-
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        self.assertIn(self.mousehood.getCurrentChallenge(), japanese.hiragana)
-
-
-    def test_twoMenEnter(self):
-        """
-        Test that when *TWO* players join, the mouse doesn't schedule too many
-        challenges.
-        """
-        otherPlayer = commandutils.createPlayer(self.store,
-                                                u"Polite Young Man")[0]
-
-        # Send an arrival event because setUp doesn't
-        firstEvent = events.ArrivalEvent(actor=self.player)
-
-        self.mouseActor.send(firstEvent)
-        otherPlayer.moveTo(self.clock, arrivalEventFactory=events.MovementArrivalEvent)
-
-        self.playerIntelligence.concepts = []
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 1)
-        self.assertChallenge(self.playerIntelligence.concepts[0])
-
-
-    def test_twoMenLeave(self):
-        """
-        Test that when two players are near the mouse, the mouse doesn't
-        unschedule its challenge until they both leave.
-        """
-        otherPlayer = commandutils.createPlayer(self.store,
-                                                u"Polite Young Man")[0]
-        otherPlayer.moveTo(self.clock)
-
-        self.mousehood.startChallenging()
-
-        firstEvent = events.DepartureEvent(location=self.clock,
-                                           actor=self.player)
-        secondEvent = events.DepartureEvent(location=self.clock,
-                                            actor=otherPlayer)
-
-        otherPlayer.moveTo(None)
-        self.mouseActor.send(secondEvent)
-
-        self.playerIntelligence.concepts = []
-
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 1)
-        self.assertChallenge(self.playerIntelligence.concepts[0])
-
-        self.player.moveTo(None)
-        self.mouseActor.send(firstEvent)
-
-        self.failIf(self.mousehood.challenging)
-
-
-    def test_getCurrentChallenge(self):
-        """
-        Test that we can introspect the current challenge of a mouse.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-        self.failUnlessIn(self.mousehood.getCurrentChallenge(), japanese.hiragana)
-
-        self.mousehood.stopChallenging()
-        self.assertIdentical(self.mousehood.getCurrentChallenge(), None)
-
-
-    def test_vetteChallengeResponse(self):
-        """
-        Test that the correct response to the current challenge is accepted by
-        the mouse.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        romaji = japanese.hiragana[self.mousehood.getCurrentChallenge()]
-        self.failUnless(self.mousehood.vetteChallengeResponse(romaji))
-
-        for romaji in japanese.hiragana.values():
-            if romaji != japanese.hiragana[self.mousehood.getCurrentChallenge()]:
-                self.failIf(self.mousehood.vetteChallengeResponse(romaji))
-
-
-    def test_respondToChallengeCorrectly(self):
-        """
-        Test that when a correct response is received, the current challenge is
-        expired and the mouse salutes you.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        correctResponse = japanese.hiragana[
-            self.mousehood.getCurrentChallenge()]
-
-        self.mousehood.responseReceived(self.player, correctResponse)
-        self.reactorTime.advance(0)
-
-        self.assertIdentical(self.mousehood.getCurrentChallenge(), None)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 2)
-        c = self.playerIntelligence.concepts[1]
-        self.assertEquals(
-            commandutils.flatten(c.plaintext(self.player)),
-            u"%s salutes you!\n" % (self.mouseName,))
-
-
-    def test_respondToChallengeInorrectly(self):
-        """
-        Test that when an incorrect response is received, the current challenge
-        is not expired and the mouse bites you.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        correctResponse = japanese.hiragana[
-            self.mousehood.getCurrentChallenge()]
-
-        for ch in japanese.hiragana.values():
-            if ch != correctResponse:
-                self.mousehood.responseReceived(self.player, ch)
-                break
-        else:
-            self.fail("Buggy test")
-
-        self.reactorTime.advance(0)
-
-        self.assertIn(self.mousehood.getCurrentChallenge(),
-                      japanese.romajiToHiragana[correctResponse])
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 2)
-        c = self.playerIntelligence.concepts[1]
-        self.assertEquals(
-            commandutils.flatten(c.plaintext(self.player)),
-            u"%s bites you!\n" % (self.mouseName,))
-
-
-    def test_playerSaysCorrectThing(self):
-        """
-        Test that when someone gives voice to the correct response to a mouse's
-        current challenge, the mouse acknowledges this with a salute.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-        action.Say().do(
-            # http://divmod.org/trac/ticket/2917
-            iimaginary.IActor(self.player),
-            None,
-            japanese.hiragana[self.mousehood.getCurrentChallenge()])
-
-        self.assertIdentical(self.mousehood.getCurrentChallenge(), None)
-        self.reactorTime.advance(0)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 3)
-        c = self.playerIntelligence.concepts[2]
-        self.assertEquals(
-            commandutils.flatten(c.plaintext(self.player)),
-            u"%s salutes you!\n" % (self.mouseName,))
-
-
-    def test_playerSaysIncorrectThing(self):
-        """
-        Test that when someone gives voice to the correct response to a mouse's
-        current challenge, the mouse acknowledges this with a salute.
-        """
-        self.mousehood.startChallenging()
-        self.reactorTime.advance(self.mousehood.challengeInterval)
-
-        action.Say().do(
-            # http://divmod.org/trac/ticket/2917
-            iimaginary.IActor(self.player), None, u"lolololo pew")
-
-        self.failIfIdentical(self.mousehood.getCurrentChallenge(), None)
-        self.reactorTime.advance(0)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 3)
-        c = self.playerIntelligence.concepts[2]
-        self.assertEquals(
-            commandutils.flatten(c.plaintext(self.player)),
-            u"%s bites you!\n" % (self.mouseName,))
-
-
-    def test_activationUsesReactorScheduling(self):
-        """
-        Test that the default scheduler of the mouse is the Twisted
-        reactor, since that is the scheduler that needs to be used
-        with the actual Imaginary server.
-        """
-        deletions = []
-        ref = weakref.ref(self.mousehood, deletions.append)
-        # This is a hack to reload the mouse since it gets its
-        # _callLater set in setUp.
-        del self.mouse
-        del self.mouseActor
-        del self.mousehood
-        self.assertEquals(deletions, [ref])
-        mousehood = self.store.findUnique(mice.HiraganaMouse)
-        from twisted.internet import reactor
-        self.assertEquals(mousehood._callLater, reactor.callLater)
-
-
-
-class HiraganaMouseCommandTestCase(commandutils.CommandTestCaseMixin, unittest.TestCase):
-    """
-    H-mouse tests which use the command system.
-    """
-
-    mouseName = u"\N{KATAKANA LETTER PI}\N{KATAKANA LETTER SMALL YU}"
-    hiraganaCharacterPattern = u"'[" + u''.join(japanese.hiragana.keys()) + u"]'"
-    speechPattern = mouseName + u" says, " + hiraganaCharacterPattern
-
-    def test_oneManEnters(self):
-        """
-        Test that when a fellow jaunts into a venue inhabited by a mouse of the
-        Nipponese persuasion, a hiragana allocution follows.
-        """
-        clock = task.Clock()
-
-        closetContainer = commandutils.createLocation(
-            self.store, u"Closet", None)
-        closet = closetContainer.thing
-
-        mouse = mice.createHiraganaMouse(
-            store=self.store,
-            name=self.mouseName,
-            proper=True)
-        mouseActor = iimaginary.IActor(mouse)
-        mousehood = mouseActor.getIntelligence()
-        mousehood._callLater = clock.callLater
-        mouse.moveTo(closet)
-
-        objects.Exit.link(self.location, closet, u"north")
-
-        self._test(
-            "north",
-            [commandutils.E("[ Closet ]"),
-             commandutils.E("( south )"),
-             commandutils.E(u"Here, you see " + self.mouseName + u".")],
-            ["Test Player leaves north."])
-
-        clock.advance(mousehood.challengeInterval)
-
-        self._test(None, [self.speechPattern])
-
-
-    def test_creation(self):
-        """
-        Test the creation of a hiragana-speaking mouse using the thing creation
-        plugin system.
-        """
-        self._test(
-            u"create the 'hiragana mouse' named " + self.mouseName,
-            [commandutils.E(u"You create " + self.mouseName + u".")],
-            [commandutils.E(u"Test Player creates %s." % (self.mouseName,))])
-
-        for thing in self.location.findProviders(iimaginary.IThing, 0):
-            if thing.name == self.mouseName:
-                break
-        else:
-            self.fail("Could not find the mouse!  Test bug.")
-
-        clock = task.Clock()
-        jimhood = iimaginary.IActor(thing).getIntelligence()
-        jimhood._callLater = clock.callLater
-
-        self._test(
-            u"drop " + self.mouseName,
-            [commandutils.E(u"You drop %s." % (self.mouseName,))],
-            [commandutils.E(u"Test Player drops %s." % (self.mouseName,))])
-
-        clock.advance(jimhood.challengeInterval)
-
-        self._test(
-            None,
-            [self.speechPattern],
-            [self.speechPattern])

=== removed file 'Imaginary/ExampleGame/examplegame/test/test_mice.py'
--- Imaginary/ExampleGame/examplegame/test/test_mice.py	2013-07-03 23:50:20 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_mice.py	1970-01-01 00:00:00 +0000
@@ -1,155 +0,0 @@
-
-from twisted.trial import unittest
-from twisted.internet import task
-
-from axiom import store
-
-from imaginary import iimaginary, events, objects
-from imaginary.test import commandutils
-
-from examplegame import mice
-
-
-class IntelligenceTestCase(unittest.TestCase):
-    def setUp(self):
-        self.store = store.Store()
-
-        self.locationContainer = commandutils.createLocation(
-            self.store, u"Place", None)
-        self.location = self.locationContainer.thing
-
-        self.alice = objects.Thing(store=self.store, name=u"Alice")
-        self.actor = objects.Actor.createFor(self.alice)
-
-        self.alice.moveTo(self.location)
-
-        self.intelligence = commandutils.MockIntelligence(store=self.store)
-        self.actor.setEnduringIntelligence(self.intelligence)
-
-
-    def test_intelligenceReceivesEvent(self):
-        """
-        Enduring intelligences should receive events.
-        """
-        evt = events.Success(
-            location=self.location,
-            otherMessage=u"Hello, how are you?")
-
-        self.actor.send(evt)
-        self.assertEquals(self.intelligence.concepts, [evt])
-
-
-    def test_persistentIntelligence(self):
-        """
-        Whitebox test that enduring intelligencii are actually persistent.
-        """
-        # TB <---- THAT MEANS IT'S TRANSLUCENT
-        self.assertIdentical(
-            self.store.findUnique(
-                objects.Actor,
-                objects.Actor._enduringIntelligence == self.intelligence),
-            self.actor)
-
-
-
-class MouseTestCase(unittest.TestCase):
-    def setUp(self):
-        self.store = store.Store()
-
-        self.clock = objects.Thing(store=self.store, name=u"Clock")
-        self.clockContainer = objects.Container.createFor(self.clock, capacity=10)
-
-        self.mouse = mice.createMouse(store=self.store, name=u"Squeaker McSqueakenson")
-        self.mouseActor = iimaginary.IActor(self.mouse)
-        self.mousehood = self.mouseActor.getIntelligence()
-        self.mouse.moveTo(self.clock)
-
-        self.player = objects.Thing(store=self.store, name=u"Mean Old Man")
-        self.playerActor = objects.Actor.createFor(self.player)
-        self.playerIntelligence = commandutils.MockIntelligence(
-            store=self.store)
-        self.playerActor.setEnduringIntelligence(self.playerIntelligence)
-
-        self.player.moveTo(self.clock)
-
-
-    def test_mouseSqueaksAtIntruders(self):
-        """
-        When a mean old man walks into the mouse's clock, the mouse will squeak
-        ruthlessly.
-        """
-        clock = task.Clock()
-        self.mousehood._callLater = clock.callLater
-        evt = events.ArrivalEvent(actor=self.player)
-        self.mouseActor.send(evt)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 0)
-        clock.advance(0)
-
-        self.assertEquals(len(self.playerIntelligence.concepts), 1)
-        event = self.playerIntelligence.concepts[0]
-        self.assertEquals(
-            commandutils.flatten(event.otherMessage.plaintext(self.player)),
-            u"SQUEAK!")
-
-
-    def test_mouseCanSqueak(self):
-        events.runEventTransaction(self.store, self.mousehood.squeak)
-        self.assertEquals(len(self.playerIntelligence.concepts), 1)
-        event = self.playerIntelligence.concepts[0]
-        self.assertEquals(
-            commandutils.flatten(event.otherMessage.plaintext(self.player)),
-            u"SQUEAK!")
-
-
-    def test_mouseActivation(self):
-        """
-        Activating a mouse should set the scheduling mechanism to the
-        reactor's.
-        """
-        from twisted.internet import reactor
-        self.assertEquals(self.mousehood._callLater, reactor.callLater)
-
-
-
-class MouseReactionTestCase(commandutils.CommandTestCaseMixin,
-                            unittest.TestCase):
-    def testCreation(self):
-        """
-        Test that a mouse can be created with the create command.
-        """
-        self._test(
-            "create the mouse named squeaker",
-            ['You create squeaker.'],
-            ['Test Player creates squeaker.'])
-
-        [mouse] = list(self.playerContainer.getContents())
-        self.failUnless(isinstance(iimaginary.IActor(mouse).getIntelligence(), mice.Mouse))
-
-
-    def testSqueak(self):
-        """
-        Test that when someone walks into a room with a mouse, the mouse
-        squeaks and the person who walked in hears it.
-        """
-        mouse = mice.createMouse(store=self.store, name=u"squeaker")
-        clock = task.Clock()
-        intelligence = iimaginary.IActor(mouse).getIntelligence()
-        intelligence._callLater = clock.callLater
-
-        elsewhere = commandutils.createLocation(
-            self.store, u"Mouse Hole", None).thing
-
-        objects.Exit.link(self.location, elsewhere, u"south")
-
-        mouse.moveTo(elsewhere)
-
-        self._test(
-            "south",
-            [commandutils.E("[ Mouse Hole ]"),
-             commandutils.E("( north )"),
-             commandutils.E("Here, you see a squeaker.")],
-            ['Test Player leaves south.'])
-
-        clock.advance(0)
-        self._test(None, ["SQUEAK!"])

=== removed file 'Imaginary/ExampleGame/examplegame/test/test_quiche.py'
--- Imaginary/ExampleGame/examplegame/test/test_quiche.py	2009-06-29 04:03:17 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_quiche.py	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-from twisted.trial import unittest
-
-from imaginary import objects, iimaginary
-from imaginary.test import commandutils
-
-from examplegame import quiche
-
-
-class VendingTest(commandutils.CommandTestCaseMixin, unittest.TestCase):
-    def testTheyExist(self):
-        self._test("create the 'vending machine' named vendy",
-                   ["You create vendy."],
-                   ["Test Player creates vendy."])
-
-
-    def testPopulateVendingMachine(self):
-        self._test("create the 'vending machine' named vendy",
-                   ["You create vendy."],
-                   ["Test Player creates vendy."])
-
-        self._test("create a quiche named quiche",
-                   ["You create a quiche."],
-                   ["Test Player creates a quiche."])
-
-        self._test("open vendy",
-                   ["You open vendy."],
-                   ["Test Player opens vendy."])
-
-        self._test("put quiche in vendy",
-                   ["You put the quiche in vendy."],
-                   ["Test Player puts a quiche in vendy."])
-
-
-    def testBuyingQuiche(self):
-        self._test("create the 'vending machine' named vendy",
-                   ["You create vendy."],
-                   ["Test Player creates vendy."])
-
-        self._test("drop vendy",
-                   ["You drop vendy."],
-                   ["Test Player drops vendy."])
-
-        self._test("create a quiche named quiche",
-                   ["You create a quiche."],
-                   ["Test Player creates a quiche."])
-
-        self._test("open vendy",
-                   ["You open vendy."],
-                   ["Test Player opens vendy."])
-
-        self._test("put quiche in vendy",
-                   ["You put the quiche in vendy."],
-                   ["Test Player puts a quiche in vendy."])
-
-        for i in range(5):
-            self._test("create the quarter named quarter%s " % i,
-                       ["You create quarter%s." % i],
-                       ["Test Player creates quarter%s." % i])
-
-        for i in range(4):
-            self._test("put quarter%i in vendy" % i,
-                       ["You put quarter%s in vendy." % i],
-                       ["Test Player puts quarter%s in vendy." % i])
-
-        self._test("put quarter4 in vendy",
-                   ["You put quarter4 in vendy.",
-                   "Vendy thumps loudly and spits out a quiche onto the ground."],
-                   ["Test Player puts quarter4 in vendy.",
-                    "Vendy thumps loudly and spits out a quiche onto the ground."])
-
-
-    def testProgrammaticQuichePurchase(self):
-        location = objects.Thing(store=self.store, name=u"room")
-        icloc = objects.Container.createFor(location, capacity=500)
-
-        vm = quiche.createVendingMachine(store=self.store, name=u"Vendy", description=u"VEEEENDYYYYY")
-        vm.moveTo(location)
-
-        icvm = iimaginary.IContainer(vm)
-        icvm.closed = False
-        theQuiche = quiche.createQuiche(store=self.store, name=u"quiche")
-        icvm.add(theQuiche)
-        icvm.closed = True
-
-        for i in range(4):
-            quarter = quiche.createCoin(store=self.store, name=u"quarter%s" % (i,))
-            icvm.add(quarter)
-
-        quarter = quiche.createCoin(store=self.store, name=u"quarter4")
-        icvm.add(quarter)
-
-        self.failUnless(icloc.contains(theQuiche))
-

=== removed file 'Imaginary/ExampleGame/examplegame/test/test_squeaky.py'
--- Imaginary/ExampleGame/examplegame/test/test_squeaky.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_squeaky.py	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-
-from twisted.trial.unittest import TestCase
-
-from imaginary.test.commandutils import CommandTestCaseMixin
-
-from imaginary.objects import Thing, Container
-
-from examplegame.squeaky import Squeaker
-
-class SqueakTest(CommandTestCaseMixin, TestCase):
-    """
-    Squeak Test.
-    """
-
-    def setUp(self):
-        """
-        Set Up.
-        """
-        CommandTestCaseMixin.setUp(self)
-        self.squeaker = Thing(store=self.store, name=u"squeaker")
-        self.squeaker.moveTo(self.location)
-        self.squeakification = Squeaker.createFor(self.squeaker)
-
-
-    def test_itSqueaks(self):
-        """
-        Picking up a squeaky thing makes it emit a squeak.
-        """
-        self.assertCommandOutput(
-            "take squeaker",
-            ["You take a squeaker.",
-             "A squeaker emits a faint squeak."],
-            ["Test Player takes a squeaker.",
-             "A squeaker emits a faint squeak."])
-
-
-    def test_squeakyContainer(self):
-        """
-        If a container is squeaky, that shouldn't interfere with its function
-        as a container.  (i.e. let's make sure that links keep working even
-        though we're using an annotator here.)
-        """
-        cont = Container.createFor(self.squeaker)
-
-        mcguffin = Thing(store=self.store, name=u"mcguffin")
-        mcguffin.moveTo(cont)
-
-        self.assertCommandOutput(
-            "take mcguffin from squeaker",
-            ["You take a mcguffin from the squeaker."],
-            ["Test Player takes a mcguffin from the squeaker."])

=== removed file 'Imaginary/ExampleGame/examplegame/test/test_tether.py'
--- Imaginary/ExampleGame/examplegame/test/test_tether.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/test/test_tether.py	1970-01-01 00:00:00 +0000
@@ -1,96 +0,0 @@
-
-from twisted.trial.unittest import TestCase
-
-from imaginary.test.commandutils import CommandTestCaseMixin, E
-
-from imaginary.objects import Thing, Container, Exit
-from imaginary.garments import Garment
-
-from examplegame.furniture import Chair
-from examplegame.tether import Tether
-
-class TetherTest(CommandTestCaseMixin, TestCase):
-    """
-    A test for tethering an item to its location, such that a player who picks
-    it up can't leave until they drop it.
-    """
-
-    def setUp(self):
-        """
-        Tether a ball to the room.
-        """
-        CommandTestCaseMixin.setUp(self)
-        self.ball = Thing(store=self.store, name=u'ball')
-        self.ball.moveTo(self.location)
-        self.tether = Tether.createFor(self.ball, to=self.location)
-        self.otherPlace = Thing(store=self.store, name=u'elsewhere')
-        Container.createFor(self.otherPlace, capacity=1000)
-        Exit.link(self.location, self.otherPlace, u'north')
-
-
-    def test_takeAndLeave(self):
-        """
-        You can't leave the room if you're holding the ball that's tied to it.
-        """
-        self.assertCommandOutput(
-            "take ball",
-            ["You take a ball."],
-            ["Test Player takes a ball."])
-        self.assertCommandOutput(
-            "go north",
-            ["You can't move, you're still holding a ball."],
-            ["Test Player struggles with a ball."])
-        self.assertCommandOutput(
-            "drop ball",
-            ["You drop the ball."],
-            ["Test Player drops a ball."])
-        self.assertCommandOutput(
-            "go north",
-            [E("[ elsewhere ]"),
-             E("( south )"),
-             ""],
-            ["Test Player leaves north."])
-
-
-    def test_allTiedUp(self):
-        """
-        If you're tied to a chair, you can't leave.
-        """
-        chairThing = Thing(store=self.store, name=u'chair')
-        chairThing.moveTo(self.location)
-        chair = Chair.createFor(chairThing)
-        self.assertCommandOutput("sit chair",
-                                 ["You sit in the chair."],
-                                 ["Test Player sits in the chair."])
-        Tether.createFor(self.player, to=chairThing)
-        self.assertCommandOutput(
-            "stand up",
-            ["You can't move, you're tied to a chair."],
-            ["Test Player struggles."])
-
-
-    def test_tetheredClothing(self):
-        """
-        Clothing that is tethered will also prevent movement if you wear it.
-
-        This isn't just simply a test for clothing; it's an example of
-        integrating with a foreign system which doesn't know about tethering,
-        but can move objects itself.
-
-        Tethering should I{not} have any custom logic related to clothing to
-        make this test pass; if it does get custom clothing code for some
-        reason, more tests should be added to deal with other systems that do
-        not take tethering into account (and vice versa).
-        """
-        Garment.createFor(self.ball, garmentDescription=u"A lovely ball.",
-                          garmentSlots=[u"head"])
-        self.assertCommandOutput(
-            "wear ball",
-            ["You put on the ball."],
-            ["Test Player puts on a ball."])
-        self.assertCommandOutput(
-            "go north",
-            ["You can't move, you're still holding a ball."],
-            ["Test Player struggles with a ball."])
-
-

=== removed file 'Imaginary/ExampleGame/examplegame/tether.py'
--- Imaginary/ExampleGame/examplegame/tether.py	2009-08-17 02:40:03 +0000
+++ Imaginary/ExampleGame/examplegame/tether.py	1970-01-01 00:00:00 +0000
@@ -1,121 +0,0 @@
-# -*- test-case-name: examplegame.test.test_tether -*-
-
-"""
-A simplistic implementation of tethering, which demonstrates how to prevent
-someone from moving around.
-
-This implementation is somewhat limited, as it assumes that tethered objects
-can only be located in players' inventories and on the ground.  It also makes
-several assumptions about who is actually doing the moving in moveTo; in order
-to be really correct, the implementation of movement needs to relay more
-information about what is moving and how.
-"""
-
-from zope.interface import implements
-
-from axiom.item import Item
-from axiom.attributes import reference
-
-from imaginary.iimaginary import IMovementRestriction, IActor
-from imaginary.eimaginary import ActionFailure
-from imaginary.events import ThatDoesntWork
-from imaginary.enhancement import Enhancement
-from imaginary.objects import Thing
-
-
-class Tether(Item, Enhancement):
-    """
-    I am a force that binds two objects together.
-
-    Right now this force isn't symmetric; the idea is that the thing that we
-    are tethered 'to' is immovable for some other reason.  This is why we're in
-    the example rather than a real robust piece of game-library functionality
-    in imaginary proper.
-
-    The C{thing} that we are installed on is prevented from moving more than a
-    certain distance away from the thing it is tethered C{to}.
-
-    This is accomplished by preventing movement of the object's container;
-    i.e. if you pick up a ball that is tied to the ground, you can't move until
-    you drop it.
-    """
-
-    thing = reference(reftype=Thing,
-                      whenDeleted=reference.CASCADE,
-                      allowNone=False)
-
-    # XXX 'thing' and 'to' should be treated more consistently, or at least the
-    # differences between them explained officially.
-    to = reference(reftype=Thing,
-                   whenDeleted=reference.CASCADE,
-                   allowNone=False)
-
-    implements(IMovementRestriction)
-
-    powerupInterfaces = [IMovementRestriction]
-
-    def movementImminent(self, movee, destination):
-        """
-        The object which is tethered is trying to move somewhere.  If it has an
-        IActor, assume that it's a player trying to move on its own, and emit
-        an appropriate message.
-
-        Otherwise, assume that it is moving *to* an actor, and install a
-        L{MovementBlocker} on that actor.
-        """
-        # There isn't enough information provided to moveTo just yet; we need
-        # to know who is doing the moving.  In the meanwhile, if you have an
-        # actor, we'll assume you're a player.
-        if IActor(movee, None) is not None:
-            raise ActionFailure(
-                ThatDoesntWork(
-                    actor=self.thing,
-                    actorMessage=[u"You can't move, you're tied to ",
-                                  self.to,
-                                  "."],
-                    otherMessage=[self.thing, u' struggles.']))
-        MovementBlocker.destroyFor(self.thing.location)
-        if self.to != destination:
-            MovementBlocker.createFor(destination, tether=self)
-
-        return False
-
-
-class MovementBlocker(Item, Enhancement):
-    """
-    A L{MovementBlocker} is an L{Enhancement} which prevents the movement of a
-    player holding a tethered object.
-    """
-    implements(IMovementRestriction)
-
-    powerupInterfaces = [IMovementRestriction]
-
-    thing = reference(
-        doc="""
-        The L{Thing} whose movement is blocked.
-        """, reftype=Thing, allowNone=False,
-        whenDeleted=reference.CASCADE)
-
-    tether = reference(
-        doc="""
-        The L{Tether} ultimely responsible for blocking movement.
-        """,
-        reftype=Tether, allowNone=False,
-        whenDeleted=reference.CASCADE)
-
-
-    def movementImminent(self, movee, destination):
-        """
-        The player this blocker is installed on is trying to move.  Assume that
-        they are trying to move themselves (via a 'go' action) and prevent it
-        by raising an L{ActionFailure} with an appropriate error message for
-        the player.
-        """
-        raise ActionFailure(
-            ThatDoesntWork(
-                actor=self.thing,
-                actorMessage=
-                [u"You can't move, you're still holding ",
-                 self.tether.thing,u'.'],
-                otherMessage=
-                [self.thing, u' struggles with ', self.tether.thing,u'.']))

=== removed directory 'Imaginary/ExampleGame/imaginary'
=== removed directory 'Imaginary/ExampleGame/imaginary/plugins'
=== removed file 'Imaginary/ExampleGame/imaginary/plugins/monsters.py'
--- Imaginary/ExampleGame/imaginary/plugins/monsters.py	2007-08-17 04:46:38 +0000
+++ Imaginary/ExampleGame/imaginary/plugins/monsters.py	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-
-from imaginary.creation import CreationPluginHelper
-from examplegame.mice import createMouse, createHiraganaMouse
-
-mouse = CreationPluginHelper(u'mouse', createMouse)
-hiraganaMouse = CreationPluginHelper(u'hiragana mouse', createHiraganaMouse)

=== removed file 'Imaginary/ExampleGame/imaginary/plugins/quiche.py'
--- Imaginary/ExampleGame/imaginary/plugins/quiche.py	2007-08-17 04:46:38 +0000
+++ Imaginary/ExampleGame/imaginary/plugins/quiche.py	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-# -*- test-case-name: examplegame.test.test_vending -*-
-
-from imaginary.creation import CreationPluginHelper
-from examplegame.quiche import createQuiche, createCoin, createVendingMachine
-
-quichePlugin = CreationPluginHelper('quiche', createQuiche)
-vendingPlugin = CreationPluginHelper('vending machine', createVendingMachine)
-quarterPlugin = CreationPluginHelper('quarter', createCoin)
-

=== removed file 'Imaginary/LICENSE'
--- Imaginary/LICENSE	2006-02-26 02:37:39 +0000
+++ Imaginary/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright (c) 2005 Divmod Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

=== removed file 'Imaginary/MANIFEST.in'
--- Imaginary/MANIFEST.in	2008-07-16 19:12:33 +0000
+++ Imaginary/MANIFEST.in	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-include NAME.txt
-include DEPS.txt
-include NEWS.txt
-include LICENSE
-graft imaginary
-graft axiom

=== removed file 'Imaginary/NAME.txt'
--- Imaginary/NAME.txt	2006-02-26 02:37:39 +0000
+++ Imaginary/NAME.txt	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-
-See: http://achewood.com/index.php?date=04272005
-
-Imaginary numbers are so named not because they are fictitious, but because
-they are along a different axis from real numbers.
-
-Divmod Imaginary is a simulationists take on the realm of role playing,
-interactive fiction, and multiplayer dungeons.  It incorporates gameplay
-features from each area while attempting to provide a richer environment
-than is generally available from existing systems.

=== removed file 'Imaginary/NEWS.txt'
--- Imaginary/NEWS.txt	2009-11-30 01:08:55 +0000
+++ Imaginary/NEWS.txt	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-0.0.5 (2009-11-25):
-  - Remove the dead imaginary.objects.Thing.locate method
-  - Introduce an interface intended to be provided by administrative actors
-    and require it for the "illuminate" command.
-  - Remove the custom SSH server and instead plug in to the Mantissa SSH
-    application server.
-  - Remove all uses of "axiom.dependency.installOn".
-  - Fix a bug which caused newly created avatars to not be announced when
-    they arrived at the starting location.
-  - When presenting an ambiguity error to an actor, enumerate the possible
-    resolutions.
-  - Fix certain terminal handling issues with east asian characters.
-
-0.0.4 (2008-08-12):
-
-  - A "plain" Thing type has now been added and is available to the
-    "create" command.
-  - "scrutinize" now works when the target is not a container.
-  - a "list thing types" command has been added, to allow viewing
-    types of things that can be created.
-  - "create" now allows users to specify if a thing is considered a
-    common or proper noun.
-  - Improved grammar in action text for various verbs.
-  - Added a "set" action for changing thing attributes.
-  - Changed noun resolution to match substrings and to match
-    case-insensitively.
-
-0.0.3 (2007-01-23):
-  - Work with Axiom dependency api
-
-0.0.2 (2006-09-20):
-  - Some changes
-
-0.0.1 (2006-06-16):
-  - Imported from Pottery repository
-  - Imported from Imagination repository

=== removed file 'Imaginary/README.txt'
--- Imaginary/README.txt	2009-06-26 20:38:23 +0000
+++ Imaginary/README.txt	1970-01-01 00:00:00 +0000
@@ -1,98 +0,0 @@
-
-Imaginary is an experimental simulation-construction toolkit.
-
-Be warned!  We aren't kidding when we say "experimental".  Many features are
-not implemented yet and documentation is incomplete.  We think there are some
-pretty cool ideas here, but if you are intending to use this system, be
-prepared to participate heavily in its development.
-
-This document is mainly concerned with getting an Imaginary server up and
-running, to the point where you can edit the code and see things change.  Some
-familiarity with Python, Twisted, Nevow, Axiom, and Mantissa are all helpful,
-but we will try to make sure they aren't really required just to get started.
-
-While we have tried to make it possible to get a taste of what is possible
-here, if you want to make any serious progress, you will want to join the IRC
-channel "#imagination" on chat.freenode.net and start asking questions.  If you
-are curious about what needs to be done, have a look here:
-
-    http://tinyurl.com/2tuo9o
-
-The first step in configuring a new installation of Imaginary will normally be
-creating a new Mantissa database.
-
-(This is assuming you have already set up Combinator, installed Twisted, and
-all necessary Divmod dependencies. If not, see
-http://divmod.org/trac/wiki/CombinatorTutorial for more information.)
-
-First run the following command:
-
-      axiomatic mantissa
-
-And answer the prompts appropriately. Please take note of the new password you
-enter for the "admin" user, as you will need it in a few steps.
-
-This should create a directory called "mantissa.axiom", containing the server
-for a web interface that will allow you to install "offerings" (plugins for
-Mantissa, in this case, Imaginary), create users, and grant them
-privileges. You can start this webserver with the following command: (the -n
-option will run it in the foreground on the current terminal)
-
-    axiomatic start -n
-
-You should now be able to access this server at http://localhost:8080 in your
-web browser.
-
-Click the "Sign In" link in the upper right hand corner, and log in as "admin"
-with the password you chose previously while configuring Mantissa.
-
-If you logged in successfully, you should now be presented with a list of
-"offerings" that can be installed. Click on "Imaginary" to install it.
-
-Next, mouse over the "Admin" menu at the upper left of the screen and then
-click on the "Products" sub-menu.
-
-In the "Installable Powerups" section, check the box corresponding to
-"Imaginary Game".  Then click the "Installable Powerups" button below.  You
-will hopefully be presented with a green confirmation dialog to confirm your
-success.  This creates a "product" which can be given to users.
-
-Mouse over the "Admin" menu again and click "Local Users".  You should be
-presented with a page including a table of users - probably with only the
-"admin" user in it.  Click the word "Endow" in the "Actions" column of that
-table, then select the product with "ImaginaryApp" in it (again, this is
-probably the only one presented) and click the "Installproducton
-admin@localhost" button.  You should again be presented with a green
-confirmation dialog.  Hooray!
-
-Ideally, you will now be able to ssh into your Imaginary server. In a new
-terminal, ssh to localhost on the Mantissa server's SSH port (by default, this
-is 8022).  For example:
-
-         ssh -p 8022 admin@localhost@localhost
-
-Note the odd username/host specifier - "admin@localhost" is the user, and the
-last "localhost" specifies the host to connect to.
-
-Log in with the same password you used to log in to the web interface.  You
-should be presented with a screen including several options, one of which is
-"imaginary".  Use tab to highlight that option (the highlighted option should
-appear red), then hit enter to select it.
-
-At the Imaginary character prompt, choose to create a new character; enter a
-new username (e.g. not "admin").  You will then join the game as that new
-character.
-
-Once in the game, you should see a row of dashes along the bottom of the
-display.  To confirm your new MUDness, try typing "look" and hit enter; You
-should see some indication of the generic place that you are in, the available
-exits, and other players in the area, though initially you won't see much more
-than "[The Place]".
-
-You can enter "actions" for a list of actions, and use "help" along with one of
-them ("help dig") for specific information on how to use them. You can even log
-in via other telnet windows, create additional accounts, and interact with your
-initial user (for example, beating them to death with "hit").
-
-When you've tired of self-abuse, you can stop your Imaginary server by hitting
-control-c in the terminal where you ran "axiomatic start -n".

=== removed directory 'Imaginary/axiom'
=== removed directory 'Imaginary/axiom/plugins'
=== removed file 'Imaginary/axiom/plugins/imaginaryversion.py'
--- Imaginary/axiom/plugins/imaginaryversion.py	2008-07-16 19:12:33 +0000
+++ Imaginary/axiom/plugins/imaginaryversion.py	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-# Copyright 2008 Divmod, Inc.
-# See LICENSE file for details
-
-"""
-Register an Axiom version plugin for Imaginary.
-"""
-
-from zope.interface import directlyProvides
-from twisted.plugin import IPlugin
-from axiom.iaxiom import IVersion
-from imaginary import version
-directlyProvides(version, IPlugin, IVersion)

=== removed directory 'Imaginary/imaginary'
=== removed file 'Imaginary/imaginary/__init__.py'
--- Imaginary/imaginary/__init__.py	2009-06-29 04:03:17 +0000
+++ Imaginary/imaginary/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,19 +0,0 @@
-# -*- test-case-name: imaginary,examplegame -*-
-
-"""
-Virtual simulation framework.
-"""
-
-from imaginary._version import version
-version                         # exported
-
-# Verbs are only registered when they are imported, and important verbs are
-# found in the following modules:
-from imaginary import action, creation
-action                          # exported
-creation                        # exported
-
-
-# Ideally there would be a nice, passive way to register verbs which would only
-# load them as necessary rather than forcing the entire package to get
-# imported, but this will work okay for now.

=== removed file 'Imaginary/imaginary/_version.py'
--- Imaginary/imaginary/_version.py	2009-11-30 01:08:55 +0000
+++ Imaginary/imaginary/_version.py	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-# This is an auto-generated file. Use Epsilon/bin/release-divmod to update.
-from twisted.python import versions
-version = versions.Version(__name__[:__name__.rfind('.')], 0, 0, 5)

=== removed file 'Imaginary/imaginary/action.py'
--- Imaginary/imaginary/action.py	2013-09-22 10:01:56 +0000
+++ Imaginary/imaginary/action.py	1970-01-01 00:00:00 +0000
@@ -1,1299 +0,0 @@
-# -*- test-case-name: imaginary.test.test_actions -*-
-
-import time, random, operator
-import pprint
-
-from zope.interface import implements
-
-from twisted.python import log, filepath
-from twisted.internet import defer
-
-from axiom import iaxiom
-from axiom.attributes import AND
-
-import imaginary.plugins
-from imaginary import (iimaginary, eimaginary, iterutils, events,
-                       objects, text as T, language, pyparsing)
-from imaginary.world import ImaginaryWorld
-from imaginary.idea import (
-    CanSee, Proximity, ProviderOf, Named, Traversability)
-
-## Hacks because pyparsing doesn't have fantastic unicode support
-_quoteRemovingQuotedString = pyparsing.quotedString.copy()
-_quoteRemovingQuotedString.setParseAction(pyparsing.removeQuotes)
-
-class UnicodeWord(pyparsing.Token):
-    def parseImpl(self, instring, loc, doActions=True):
-        maxLoc = len(instring)
-        while loc < maxLoc and instring[loc].isspace():
-            loc += 1
-        start = loc
-        while loc < maxLoc and not instring[loc].isspace():
-            loc += 1
-        end = loc
-        return end, instring[start:end]
-
-
-
-class _ActionType(type):
-    actions = []
-    def __new__(cls, name, bases, attrs):
-        infrastructure = attrs.pop('infrastructure', False)
-        t = super(_ActionType, cls).__new__(cls, name, bases, attrs)
-        if not infrastructure:
-            cls.actions.append(t)
-        return t
-
-
-    def parse(self, player, line):
-        """
-        Parse an action.
-        """
-        for eachActionType in self.actions:
-            try:
-                match = eachActionType.match(player, line)
-            except pyparsing.ParseException:
-                pass
-            else:
-                if match is not None:
-                    match = dict(match)
-                    for k,v in match.items():
-                        if isinstance(v, pyparsing.ParseResults):
-                            match[k] = v[0]
-
-                    return eachActionType().runEventTransaction(player, line, match)
-        return defer.fail(eimaginary.NoSuchCommand(line))
-
-
-
-class Action(object):
-    """
-    An L{Action} represents an intention of a player to do something.
-    """
-    __metaclass__ = _ActionType
-    infrastructure = True
-
-    actorInterface = iimaginary.IActor
-
-    def runEventTransaction(self, player, line, match):
-        """
-        Take a player, input, and dictionary of parse results, resolve those
-        parse results into implementations of appropriate interfaces in the
-        game world, and execute the actual Action implementation (contained in
-        the 'do' method) in an event transaction.
-
-        This is the top level of action invocation.
-
-        @param player: A L{Thing} representing the actor's body.
-
-        @param line: A unicode string containing the original input
-
-        @param match: A dictionary containing some parse results to pass
-            through to this L{Action}'s C{do} method as keyword arguments.
-
-        @raise eimaginary.AmbiguousArgument: if multiple valid targets are
-            found for an argument.
-        """
-        def thunk():
-            begin = time.time()
-            try:
-                actor = self.actorInterface(player)
-                for (k, v) in match.items():
-                    try:
-                        objs = self.resolve(player, k, v)
-                    except NotImplementedError:
-                        pass
-                    else:
-                        if len(objs) == 1:
-                            match[k] = objs[0]
-                        elif len(objs) == 0:
-                            self.cantFind(player, actor, k, v)
-                        else:
-                            raise eimaginary.AmbiguousArgument(self, k, v, objs)
-                return self.do(actor, line, **match)
-            finally:
-                end = time.time()
-                log.msg(interface=iaxiom.IStatEvent,
-                        stat_actionDuration=end - begin,
-                        stat_actionExecuted=1)
-        events.runEventTransaction(player.store, thunk)
-
-
-    def cantFind(self, player, actor, slot, name):
-        """
-        This hook is invoked when a target cannot be found.
-
-        This will delegate to a method like C{self.cantFind_<slot>(actor,
-        name)} if one exists, to determine the error message to show to the
-        actor.  It will then raise L{eimaginary.ActionFailure} to stop
-        processing of this action.
-
-        @param player: The L{Thing} doing the searching.
-
-        @type player: L{IThing}
-
-        @param actor: The L{IActor} doing the searching.
-
-        @type actor: L{IActor}
-
-        @param slot: The slot in question.
-
-        @type slot: C{str}
-
-        @param name: The name of the object being searched for.
-
-        @type name: C{unicode}
-
-        @raise eimaginary.ActionFailure: always.
-        """
-        func = getattr(self, "cantFind_"+slot, None)
-        if func:
-            msg = func(actor, name)
-        else:
-            msg = "Who's that?"
-        raise eimaginary.ActionFailure(
-            events.ThatDoesntWork(
-                actorMessage=msg,
-                actor=player))
-
-
-    @classmethod
-    def match(cls, player, line):
-        """
-        Parse the given C{line} using this L{Action} type's pyparsing C{expr}
-        attribute.  A C{pyparsing.LineEnd} is appended to C{expr} to avoid
-        accidentally matching a prefix instead of the whole line.
-
-        @return: a list of 2-tuples of all the results of parsing, or None if
-            the expression does not match the given line.
-
-        @param line: a line of user input to be interpreted as an action.
-
-        @see: L{imaginary.pyparsing}
-        """
-        return (cls.expr + pyparsing.LineEnd()).parseString(line)
-
-
-    def do(self, player, line, **slots):
-        """
-        Subclasses override this method to actually perform the action.
-
-        This method is performed in an event transaction, by 'run'.
-
-        NB: The suggested implementation strategy for a 'do' method is to do
-        action-specific setup but then delegate the bulk of the actual logic to
-        a method on a target/tool interface.  The 'do' method's job is to
-        select the appropriate methods to invoke.
-
-        @param player: a provider of this L{Action}'s C{actorInterface}.
-
-        @param line: the input string that created this action.
-
-        @param slots: The results of calling C{self.resolve} on each parsing
-        result (described by a setResultsName in C{self.expr}).
-        """
-        raise NotImplementedError("'do' method not implemented")
-
-
-    def resolve(self, player, name, value):
-        """
-        Resolve a given parsed value to a valid action parameter by calling a
-        'resolve_<name>' method on this L{Action} with the given C{player} and
-        C{value}.
-
-        @param player: the L{Thing} attempting to perform this action.
-
-        @type player: L{Thing}
-
-        @param name: the name of the slot being filled.  For example, 'target'.
-
-        @type name: L{str}
-
-        @param value: a string representing the value that was parsed.  For
-            example, if the user typed 'get fish', this would be 'fish'.
-
-        @return: a value which will be passed as the 'name' parameter to this
-            L{Action}'s C{do} method.
-        """
-        resolver = getattr(self, 'resolve_%s' % (name,), None)
-        if resolver is None:
-            raise NotImplementedError(
-                "Don't know how to resolve %r (%r)" % (name, value))
-        return resolver(player, value)
-
-
-
-def targetString(name):
-    return (
-        _quoteRemovingQuotedString ^
-        UnicodeWord()).setResultsName(name)
-
-
-
-class TargetAction(Action):
-    """
-    Subclass L{TargetAction} to implement an action that acts on a target, like
-    'take foo' or 'eat foo' where 'foo' is the target.
-
-    @cvar targetInterface: the interface which the 'target' parameter to 'do'
-        must provide.
-    """
-
-    infrastructure = True
-
-    targetInterface = iimaginary.IThing
-
-    def targetRadius(self, player):
-        return 2
-
-    def resolve_target(self, player, targetName):
-        return _getIt(player, targetName,
-                      self.targetInterface, self.targetRadius(player))
-
-
-
-class ToolAction(TargetAction):
-    """
-    Subclass L{ToolAction} to implement an action that acts on a target by
-    using a tool, like 'unlock door with key', where 'door' is the target and
-    'key' is the tool.
-
-    @cvar toolInterface: the L{zope.interface.Interface} which the 'tool'
-        parameter to 'do' must provide.
-    """
-    infrastructure = True
-
-    toolInterface = iimaginary.IThing
-
-    def toolRadius(self, player):
-        return 2
-
-    def resolve_tool(self, player, toolName):
-        return _getIt(player, toolName,
-                      self.toolInterface, self.toolRadius(player))
-
-
-
-def _getIt(player, thingName, iface, radius):
-    return list(player.search(radius, iface, thingName))
-
-
-
-class LookAround(Action):
-    actionName = "look"
-    expr = pyparsing.Literal("look") + pyparsing.StringEnd()
-
-    def do(self, player, line):
-        ultimateLocation = player.thing.location
-        while ultimateLocation.location is not None:
-            ultimateLocation = ultimateLocation.location
-        for visible in player.thing.findProviders(iimaginary.IVisible, 1):
-            # XXX what if my location is furniture?  I want to see '( Foo,
-            # sitting in the Bar )', not '( Bar )'.
-            if visible.isViewOf(ultimateLocation):
-                concept = visible.visualize()
-                break
-        else:
-            concept = u"You are floating in an empty, formless void."
-        events.Success(actor=player.thing,
-                       actorMessage=concept).broadcast()
-
-
-
-class LookAt(TargetAction):
-    actionName = "look"
-    expr = (pyparsing.Literal("look") +
-            pyparsing.Optional(pyparsing.White() +
-                               pyparsing.Literal("at")) +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("target"))
-
-    targetInterface = iimaginary.IVisible
-
-    def resolve_target(self, player, targetName):
-        """
-        Resolve the target to look at by looking for a named, visible object in
-        a proximity of 3 meters from the player.
-
-        @param player: The player doing the looking.
-
-        @type player: L{IThing}
-
-        @param targetName: The name of the object we are looking for.
-
-        @type targetName: C{unicode}
-
-        @return: A list of visible objects.
-
-        @rtype: C{list} of L{IVisible}
-
-        @raise eimaginary.ActionFailure: with an appropriate message if the
-            target cannot be resolved for an identifiable reason.  See
-            L{imaginary.objects.Thing.obtainOrReportWhyNot} for a description
-            of how such reasons may be identified.
-        """
-        return player.obtainOrReportWhyNot(
-            Proximity(3.0, Named(targetName,
-                                 CanSee(ProviderOf(iimaginary.IVisible)),
-                                 player)))
-
-
-    def cantFind_target(self, player, name):
-        return "You don't see that."
-
-    def targetRadius(self, player):
-        return 3
-
-    def do(self, player, line, target):
-        if player.thing is not target:
-            evt = events.Success(
-                actor=player.thing,
-                target=target,
-                actorMessage=target.visualize(),
-                targetMessage=(player.thing, " looks at you."))
-        else:
-            evt = events.Success(
-                actor=player.thing,
-                actorMessage=target.visualize())
-        evt.broadcast()
-
-
-
-class Illuminate(Action):
-    """
-    Change the ambient light level at the location of the actor.  Since this is
-    an administrative action that directly manipulates the environment, the
-    actor must be a L{iimaginary.IManipulator}.
-
-    The argument taken by this action is an integer which specifies the light
-    level in U{candelas<http://en.wikipedia.org/wiki/Candela>}.
-    """
-
-    actorInterface = iimaginary.IManipulator
-
-    expr = (pyparsing.Literal("illuminate") +
-            pyparsing.White() +
-            pyparsing.Word("0123456789").setResultsName("candelas"))
-
-
-    def do(self, player, line, candelas):
-        """
-        Attempt to change the illumination of the player's surroundings.
-
-        @param player: a manipulator that can change the illumination of its
-            room.
-        @type player: L{IManipulator}
-
-        @param line: the text being parsed
-        @type line: L{str}
-
-        @param candelas: the number of candelas to change the ambient
-            illumination to.
-        @type candelas: L{str}
-        """
-        candelas = int(candelas)
-        oldCandelas = player.setIllumination(candelas)
-        otherMessage = None
-        if oldCandelas == candelas:
-            actorMessage = u"You do it.  Swell."
-        elif candelas == 0:
-            actorMessage = (
-                u"Your environs fade to black due to Ineffable Spooky Magic.")
-            otherMessage = actorMessage
-        elif oldCandelas == 0:
-            actorMessage = u"Your environs are suddenly alight."
-            otherMessage = actorMessage
-        elif candelas < oldCandelas:
-            actorMessage = u"Your environs seem slightly dimmer."
-            otherMessage = actorMessage
-        elif candelas > oldCandelas:
-            actorMessage = u"Your environs seem slightly brighter."
-            otherMessage = actorMessage
-        events.Success(actor=player.thing,
-                       actorMessage=actorMessage,
-                       otherMessage=otherMessage).broadcast()
-
-
-
-class Describe(TargetAction):
-    expr = (pyparsing.Literal("describe") +
-            pyparsing.White() +
-            targetString("target") +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("description"))
-
-    def targetRadius(self, player):
-        return 3
-
-    def do(self, player, line, target, description):
-        target.description = description
-        evt = events.Success(
-            actor=player.thing,
-            actorMessage=("You change ", target, "'s description."),
-            otherMessage=(player.thing, " changes ", target, "'s description."))
-        evt.broadcast()
-
-
-class Name(TargetAction):
-    expr = (pyparsing.Literal("name") +
-            pyparsing.White() +
-            targetString("target") +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("name"))
-
-    def targetRadius(self, player):
-        return 3
-
-    def do(self, player, line, target, name):
-        evt = events.Success(
-            actor=player.thing,
-            actorMessage=("You change ", target, "'s name."),
-            otherMessage=language.Sentence([player.thing, " changes ", target, "'s name to ", name, "."]))
-        evt.broadcast()
-        target.name = name
-
-
-
-class Open(TargetAction):
-    expr = (pyparsing.Literal("open") +
-            pyparsing.White() +
-            targetString("target"))
-
-    targetInterface = iimaginary.IContainer
-
-    def do(self, player, line, target):
-        dnf = language.Noun(target.thing).definiteNounPhrase()
-        if not target.closed:
-            raise eimaginary.ActionFailure(events.ThatDoesntWork(
-                actor=player.thing,
-                target=target.thing,
-                actorMessage=language.Sentence([dnf, " is already open."])))
-
-        target.closed = False
-        evt = events.Success(
-            actor=player.thing,
-            target=target.thing,
-            actorMessage=("You open ", dnf, "."),
-            targetMessage=language.Sentence([player.thing, " opens you."]),
-            otherMessage=language.Sentence([player.thing, " opens ", target.thing, "."]))
-        evt.broadcast()
-
-
-
-class Close(TargetAction):
-    expr = (pyparsing.Literal("close") +
-            pyparsing.White() +
-            targetString("target"))
-
-    targetInterface = iimaginary.IContainer
-
-    def do(self, player, line, target):
-        dnf = language.Noun(target.thing).definiteNounPhrase()
-        if target.closed:
-            raise eimaginary.ActionFailure(events.ThatDoesntWork(
-                actor=player.thing,
-                target=target.thing,
-                actorMessage=language.Sentence([dnf, " is already closed."])))
-
-        target.closed = True
-        evt = events.Success(
-            actor=player.thing,
-            target=target.thing,
-            actorMessage=("You close ", dnf, "."),
-            targetMessage=language.Sentence([player.thing, " closes you."]),
-            otherMessage=language.Sentence([player.thing, " closes ", target.thing, "."]))
-        evt.broadcast()
-
-
-
-def tooHeavy(player, target):
-    return eimaginary.ActionFailure(events.ThatDoesntWork(
-        actor=player, target=target,
-        actorMessage=(target, " is too heavy to pick up."),
-        otherMessage=(player, " struggles to lift ", target, ", but fails."),
-        targetMessage=(player, " tries to pick you up, but fails.")))
-
-
-
-def targetTaken(player, target, container=None):
-    if container is None:
-        return events.Success(
-            actor=player, target=target,
-            actorMessage=("You take ", target, "."),
-            targetMessage=(player, " takes you."),
-            otherMessage=(player, " takes ", target, "."))
-    idop = language.Noun(container).definiteNounPhrase()
-    return events.Success(
-        actor=player,
-        target=target,
-        tool=container,
-        actorMessage=("You take ", target, " from ", idop, "."),
-        targetMessage=(player, " takes you from ", idop, "."),
-        toolMessage=(player, " takes ", target, " from you."),
-        otherMessage=(player, " takes ", target, " from ", idop, "."))
-
-
-
-class Remove(TargetAction):
-    expr = ((pyparsing.Literal("remove") |
-             pyparsing.Literal("take off")) +
-            pyparsing.White() +
-            targetString("target"))
-
-    targetInterface = iimaginary.IClothing
-    actorInterface = iimaginary.IClothingWearer
-
-    def do(self, player, line, target):
-        from imaginary import garments
-        try:
-            player.takeOff(target)
-        except garments.InaccessibleGarment, e:
-            raise eimaginary.ActionFailure(events.ThatDoesntWork(
-                actor=player.thing,
-                target=target.thing,
-                actorMessage=(u"You cannot take off ",
-                              language.Noun(target.thing).definiteNounPhrase(),
-                              u" because you are wearing ",
-                              e.obscuringGarment.thing, u"."),
-                otherMessage=language.Sentence([
-                    player.thing,
-                    u" gets a dumb look on ",
-                    language.Noun(player.thing).hisHer(),
-                    u" face."])))
-
-        evt = events.Success(
-            actor=player.thing,
-            target=target.thing,
-            actorMessage=(u"You take off ",
-                          language.Noun(target.thing).definiteNounPhrase(),
-                          u"."),
-            otherMessage=language.Sentence([
-                player.thing, u" takes off ", target.thing, u"."]))
-        evt.broadcast()
-
-
-
-class Wear(TargetAction):
-    expr = (pyparsing.Literal("wear") +
-            pyparsing.White() +
-            targetString("target"))
-
-    targetInterface = iimaginary.IClothing
-    actorInterface = iimaginary.IClothingWearer
-
-    def do(self, player, line, target):
-        from imaginary import garments
-        try:
-            player.putOn(target)
-        except garments.TooBulky, e:
-            raise eimaginary.ActionFailure(events.ThatDoesntWork(
-                actor=player.thing,
-                target=target.thing,
-                actorMessage=language.Sentence([
-                    language.Noun(e.wornGarment.thing).definiteNounPhrase(),
-                    u" you are already wearing is too bulky for you to do"
-                    u" that."]),
-                otherMessage=language.Sentence([
-                    player.thing,
-                    u" wrestles with basic personal problems."])))
-
-        evt = events.Success(
-            actor=player.thing,
-            target=target.thing,
-            actorMessage=(u"You put on ",
-                          language.Noun(target.thing).definiteNounPhrase(),
-                          "."),
-            otherMessage=language.Sentence([
-                player.thing, " puts on ", target.thing, "."]))
-        evt.broadcast()
-
-
-
-class Equipment(Action):
-    expr = pyparsing.Literal("equipment")
-
-    actorInterface = iimaginary.IClothingWearer
-
-    def do(self, player, line):
-        from imaginary import garments
-        equipment = list(player.store.query(
-            objects.Thing,
-            AND(
-                garments.Garment.thing == objects.Thing.storeID,
-                garments.Garment.wearer == player),
-            sort=objects.Thing.name.ascending))
-        if equipment:
-            evt = events.Success(
-                actor=player.thing,
-                actorMessage=[
-                    u"You are wearing ",
-                    language.ItemizedList(equipment),
-                    u"."])
-        else:
-            evt = events.Success(
-                actor=player.thing,
-                actorMessage=language.ExpressString(
-                    u"You aren't wearing any equipment."))
-        evt.broadcast()
-
-
-
-class TakeFrom(ToolAction):
-    actionName = "take"
-
-    expr = ((pyparsing.Literal("get") ^ pyparsing.Literal("take")) +
-            pyparsing.White() +
-            targetString("target") +
-            pyparsing.Optional(pyparsing.White() +
-                               pyparsing.Literal("from")) +
-            pyparsing.White() +
-            targetString("tool"))
-
-    def cantFind_target(self, player, targetName):
-        return "Nothing like that around here."
-    cantFind_tool = cantFind_target
-
-    def do(self, player, line, target, tool):
-        # XXX Make sure target is in tool
-        targetTaken(player.thing, target, tool).broadcast()
-        try:
-            target.moveTo(player.thing)
-        except eimaginary.DoesntFit:
-            raise tooHeavy(player.thing, target)
-
-
-
-class PutIn(ToolAction):
-
-    toolInterface = iimaginary.IThing
-    targetInterface = iimaginary.IContainer
-
-    def cantFind_target(self, player, targetName):
-        return "That doesn't work."
-
-    expr = (pyparsing.Literal("put") +
-            pyparsing.White() +
-            targetString("tool") +
-            pyparsing.Optional(pyparsing.White() +
-                               pyparsing.Literal("in")) +
-            pyparsing.White() +
-            targetString("target"))
-
-    def do(self, player, line, tool, target):
-        ctool = iimaginary.IContainer(tool, None)
-        targetObject = target.thing
-        if ctool is not None and (ctool.contains(targetObject) or ctool is target):
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntWork(
-                    actor=player.thing,
-                    target=targetObject,
-                    tool=tool,
-                    actorMessage="A thing cannot contain itself in euclidean space."))
-
-        dnf = language.Noun(targetObject).definiteNounPhrase()
-        evt = events.Success(
-            actor=player.thing,
-            target=targetObject,
-            tool=tool,
-            actorMessage=("You put ",
-                          language.Noun(tool).definiteNounPhrase(),
-                          " in ", dnf, "."),
-            targetMessage=language.Sentence([player.thing, " puts ", " tool in you."]),
-            toolMessage=language.Sentence([player.thing, " puts you in ", targetObject, "."]),
-            otherMessage=language.Sentence([player.thing, " puts ", tool, " in ", targetObject, "."]))
-        evt.broadcast()
-
-        try:
-            tool.moveTo(target)
-        except eimaginary.DoesntFit:
-            # <allexpro> dash: put me in a tent and give it to moshez!
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntWork(
-                    actor=player.thing,
-                    target=targetObject,
-                    tool=tool,
-                    actorMessage=language.Sentence([
-                            language.Noun(tool).definiteNounPhrase(),
-                            u" does not fit in ", dnf, u"."])))
-        except eimaginary.Closed:
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntWork(
-                    actor=player.thing,
-                    target=targetObject,
-                    tool=tool,
-                    actorMessage=language.Sentence([dnf, " is closed."])))
-
-
-
-class Take(TargetAction):
-    expr = ((pyparsing.Literal("get") ^ pyparsing.Literal("take")) +
-            pyparsing.White() +
-            targetString("target"))
-
-    def cantFind_target(self, player, targetName):
-        return u"Nothing like that around here."
-
-    def targetRadius(self, player):
-        return 1
-
-    def do(self, player, line, target):
-        if target in (player.thing, player.thing.location) or target.location is player.thing:
-            raise eimaginary.ActionFailure(events.ThatDoesntMakeSense(
-                actor=player.thing,
-                actorMessage=("You cannot take ", target, ".")))
-
-        targetTaken(player.thing, target).broadcast()
-        try:
-            target.moveTo(player.thing)
-        except eimaginary.DoesntFit:
-            raise tooHeavy(player.thing, target)
-
-
-
-def insufficientSpace(player):
-    return eimaginary.ActionFailure(events.ThatDoesntWork(
-        actor=player,
-        actorMessage="There's not enough space for that."))
-
-
-
-class Drop(TargetAction):
-    expr = (pyparsing.Literal("drop") +
-            pyparsing.White() +
-            targetString("target"))
-
-    def cantFind_target(self, player, targetName):
-        return "Nothing like that around here."
-
-    def targetRadius(self, player):
-        return 1
-
-    def do(self, player, line, target):
-        if target.location is not player.thing:
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntMakeSense(
-                    actor=player.thing,
-                    actorMessage="You can't drop that."))
-
-        try:
-            target.moveTo(
-                player.thing.location,
-                arrivalEventFactory=lambda target: events.ArrivalEvent(
-                    actor=player.thing,
-                    actorMessage=("You drop ",
-                                  language.Noun(target).definiteNounPhrase(),
-                                  "."),
-                    target=target,
-                    targetMessage=(player.thing, " drops you."),
-                    otherMessage=(player.thing, " drops ", target, ".")))
-        except eimaginary.DoesntFit:
-            raise insufficientSpace(player.thing)
-
-
-
-_directionNames = objects.OPPOSITE_DIRECTIONS.keys()
-_directionNames.extend(objects.DIRECTION_ALIASES.keys())
-
-DIRECTION_LITERAL = reduce(
-    operator.xor, [
-        pyparsing.Literal(d)
-        for d in _directionNames]).setResultsName("direction")
-
-
-
-def expandDirection(direction):
-    """
-    Expand direction aliases into the names of the directions they refer to.
-    """
-    return objects.DIRECTION_ALIASES.get(direction, direction)
-
-
-
-class Dig(Action):
-    expr = (pyparsing.Literal("dig") +
-            pyparsing.White() +
-            DIRECTION_LITERAL +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("name"))
-
-    def do(self, player, line, direction, name):
-        direction = expandDirection(direction)
-        if iimaginary.IContainer(player.thing.location).getExitNamed(direction, None) is not None:
-            raise eimaginary.ActionFailure(events.ThatDoesntMakeSense(
-                actor=player.thing,
-                actorMessage="There is already an exit in that direction."))
-
-        room = objects.Thing(store=player.store, name=name)
-        objects.Container.createFor(room, capacity=1000)
-        objects.Exit.link(player.thing.location, room, direction)
-
-        evt = events.Success(
-            actor=player.thing,
-            actorMessage="You create an exit.",
-            otherMessage=language.Sentence([player.thing, " created an exit to the ", direction, "."]))
-        evt.broadcast()
-
-        # XXX Right now there can't possibly be anyone in the
-        # destination room, but someday there could be.  When there
-        # could be, broadcast this to them too.
-
-
-
-class Bury(Action):
-    expr = (pyparsing.Literal("bury") +
-            pyparsing.White() +
-            DIRECTION_LITERAL)
-
-    def do(self, player, line, direction):
-        direction = expandDirection(direction)
-        for exit in iimaginary.IContainer(player.thing.location).getExits():
-            if exit.name == direction:
-                if exit.sibling is not None:
-                    evt = events.Success(
-                        location=exit.toLocation,
-                        otherMessage=language.Sentence([
-                            exit.sibling, " crumbles and disappears."]))
-                    evt.broadcast()
-
-                evt = events.Success(
-                    actor=player.thing,
-                    actorMessage="It's gone.",
-                    otherMessage=language.Sentence([
-                        language.Noun(player.thing).nounPhrase(),
-                        " destroyed ", exit, "."]))
-                evt.broadcast()
-                exit.destroy()
-                return
-
-        raise eimaginary.ActionFailure(events.ThatDoesntMakeSense(
-            actor=player.thing,
-            actorMessage="There isn't an exit in that direction."))
-
-
-
-class Go(Action):
-    expr = (
-        (pyparsing.Literal("go") + pyparsing.White() +
-         targetString("direction")) |
-        (pyparsing.Literal("enter") + pyparsing.White() +
-         targetString("direction")) |
-        (pyparsing.Literal("exit") + pyparsing.White() +
-         targetString("direction")) |
-        DIRECTION_LITERAL)
-
-    actorInterface = iimaginary.IThing
-
-    def resolve_direction(self, player, directionName):
-        """
-        Identify a direction by having the player search for L{IExit}
-        providers that they can see and reach.
-        """
-        directionName = expandDirection(directionName)
-        return player.obtainOrReportWhyNot(
-            Proximity(
-                3.0,
-                Traversability(
-                    Named(directionName,
-                          CanSee(ProviderOf(iimaginary.IExit)), player))))
-
-
-    def cantFind_direction(self, actor, directionName):
-        """
-        Explain to the user that they can't go in a direction that they can't
-        locate.
-        """
-        return u"You can't go that way."
-
-
-    def do(self, player, line, direction):
-        location = player.location
-
-        evt = events.Success(
-            location=location,
-            actor=player,
-            otherMessage=(player, " leaves ", direction.name, "."))
-        evt.broadcast()
-
-        try:
-            direction.traverse(player)
-        except eimaginary.DoesntFit:
-            raise eimaginary.ActionFailure(events.ThatDoesntWork(
-                actor=player,
-                actorMessage=language.ExpressString(
-                        u"There's no room for you there.")))
-
-        # This is subtly incorrect: see http://divmod.org/trac/ticket/2917
-        lookAroundActor = iimaginary.IActor(player)
-        LookAround().do(lookAroundActor, "look")
-
-
-
-class Restore(TargetAction):
-    expr = (pyparsing.Literal("restore") +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("target"))
-
-    targetInterface = iimaginary.IActor
-
-    def cantFind_target(self, player, targetName):
-        for thing in player.thing.search(self.targetRadius(player),
-                                         iimaginary.IThing, targetName):
-            return (language.Noun(thing).nounPhrase().plaintext(player),
-                    " cannot be restored.")
-        return "Who's that?"
-
-    def targetRadius(self, player):
-        return 3
-
-
-    def do(self, player, line, target):
-        target.hitpoints.current = target.hitpoints.max
-        target.stamina.current = target.stamina.max
-
-        if player is target:
-            evt = events.Success(
-                actor=player.thing,
-                actorMessage="You have fully restored yourself.")
-            evt.broadcast()
-        else:
-            evt = events.Success(
-                actor=player.thing,
-                actorMessage=("You have restored ", target.thing, " to full health."),
-                target=target.thing,
-                targetMessage=(player.thing, " has restored you to full health."),
-                otherMessage=(player.thing, " has restored ", target.thing, " to full health."))
-            evt.broadcast()
-
-
-
-class Hit(TargetAction):
-    expr = ((pyparsing.Literal("hit") ^
-             pyparsing.Literal("attack") ^
-             pyparsing.Literal("kill")) +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("target"))
-
-    targetInterface = iimaginary.IActor
-
-    def targetRadius(self, player):
-        return 3
-
-    def do(self, player, line, target):
-        if target is player:
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntMakeSense(u"Hit yourself?  Stupid.",
-                                           actor=player.thing))
-
-        cost = random.randrange(1, 5)
-        if player.stamina < cost:
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntWork(u"You're too tired!",
-                                      actor=player.thing))
-
-        damage = random.randrange(1, 5)
-        player.stamina.decrease(cost)
-        thp = target.hitpoints.decrease(damage)
-        events.Success(
-            actor=player.thing,
-            target=target.thing,
-            targetMessage=language.Sentence([player.thing, " hits you for ", damage, " hitpoints."]),
-            actorMessage=language.Sentence(["You hit ", language.Noun(target.thing).definiteNounPhrase(), " for ", damage, " hitpoints."]),
-            otherMessage=language.Sentence([player.thing, " hits ", target.thing, "."])).broadcast()
-
-        if thp <= 0:
-            xp = target.experience / 2 + 1
-            player.gainExperience(xp) # I LOVE IT
-            targetIsDead = [target.thing, " is dead!", "\n"]
-            events.Success(
-                actor=player.thing, target=target.thing,
-                actorMessage=["\n", targetIsDead, "You gain ", xp, " experience"],
-                targetMessage=["You are dead!"],
-                otherMessage=targetIsDead).broadcast()
-            target.thing.destroy()
-
-
-
-class Say(Action):
-    expr = (((pyparsing.Literal("say") + pyparsing.White()) ^
-             pyparsing.Literal("'")) +
-            pyparsing.restOfLine.setResultsName("text"))
-
-    def do(self, player, line, text):
-        evt = events.SpeechEvent(speaker=player.thing, text=text)
-        evt.broadcast()
-
-
-
-class Emote(Action):
-    expr = (((pyparsing.Literal("emote") + pyparsing.White()) ^
-             pyparsing.Literal(":")) +
-            pyparsing.restOfLine.setResultsName("text"))
-
-    def do(self, player, line, text):
-        evt = events.Success(actor=player.thing,
-                             actorMessage=[player.thing, " ", text],
-                             otherMessage=[player.thing, " ", text])
-        evt.broadcast()
-
-
-
-class Actions(Action):
-    expr = pyparsing.Literal("actions")
-
-    def do(self, player, line):
-        cmds = dict.fromkeys(
-            getattr(cmd, 'actionName', cmd.__name__.lower())
-            for cmd
-            in self.__class__.actions).keys()
-        cmds.sort()
-        player.send((iterutils.interlace(" ", cmds), "\n"))
-
-
-
-class Commands(Action):
-    """
-    The I{commands} action provides a pointer to inexperienced players that
-    they should be thinking in terms of I{actions} instead.
-
-    This has no world side-effects; it just provides some user-interface
-    information to the player.
-    """
-    expr = pyparsing.Literal("commands")
-
-    def do(self, player, line):
-        player.send("Try 'actions' instead.")
-
-
-
-class Search(Action):
-    expr = (pyparsing.Literal("search") +
-            targetString("name"))
-
-    def do(self, player, line, name):
-        srch = player.thing.search(2, iimaginary.IVisible, name)
-        evt = events.Success(
-            actor=player.thing,
-            actorMessage=language.ExpressList(
-                list(iterutils.interlace('\n',
-                                         (o.visualize()
-                                          for o
-                                          in srch)))))
-        evt.broadcast()
-
-
-
-class Score(Action):
-    expr = pyparsing.Literal("score")
-
-    scoreFormat = (
-        '/----------------------------------------------------------------------------\\\n'
-        '| Level: %20d Experience: %10d\n'
-        '| Hitpoints: %16s\n'
-        '| Stamina: %18s\n'
-        '\\----------------------------------------------------------------------------/\n')
-
-    def do(self, player, line):
-        events.Success(
-            actor=player.thing,
-            actorMessage=self.scoreFormat % (player.level, player.experience, player.hitpoints, player.stamina)).broadcast()
-
-
-
-class ExpressWho(language.BaseExpress):
-    header = (u"/============ Currently Playing ===========\\")
-    footer = (u"\\================ Total %(playerCount)03d ===============/")
-
-    def vt102(self, observer):
-        players = self.original.connected
-
-        return [[T.bold, self.header], u'\n',
-                [[language.Noun(p).shortName().vt102(observer), u'\n']
-                 for p in players],
-                [T.bold, self.footer % {'playerCount': len(players)}], u'\n']
-
-
-
-class Who(Action):
-    expr = pyparsing.Literal("who")
-
-    def do(self, player, line):
-        player.send(ExpressWho(player.store.findUnique(ImaginaryWorld)))
-
-
-
-class Scrutinize(TargetAction):
-    """
-    Show detailed information about the model structure of a game object.
-    """
-    expr = (pyparsing.Literal("scrutinize") +
-            pyparsing.White() +
-            targetString("target"))
-
-    def targetRadius(self, player):
-        return 3
-
-    def do(self, player, line, target):
-        v = dict((k, getattr(target, k))
-                  for (k, ign)
-                  in target.getSchema()
-                  if hasattr(target, k))
-
-        targetContainer = iimaginary.IContainer(target, None)
-        if targetContainer is not None:
-            v['contents'] = list(targetContainer.getContents())
-            exits = list(targetContainer.getExits())
-            if exits:
-                v['exits'] = exits
-        s = pprint.pformat((target.__class__.__name__, v))
-        # XXX FIXME Send a real Concept
-        player.send(s, '\n')
-
-
-
-class ExpressInventory(language.BaseExpress):
-    implements(iimaginary.IConcept)
-
-    def __init__(self, original):
-        self.original = original
-
-    def vt102(self, observer):
-        return [[T.fg.yellow, "Inventory:\n"],
-                [T.fg.green,
-                 [(language.Noun(o).shortName().vt102(observer), '\n')
-                  for o
-                  in iimaginary.IContainer(self.original).getContents()]]]
-
-
-
-class Inventory(Action):
-    expr = pyparsing.Literal("inventory")
-
-    def do(self, player, line):
-        events.Success(actor=player.thing,
-                       actorMessage=ExpressInventory(player.thing)).broadcast()
-
-
-
-class Set(TargetAction):
-    """
-    Direct model-level state manipulation command.
-    """
-    expr = (
-        pyparsing.Literal("set") + pyparsing.White() +
-        targetString("attribute") + pyparsing.White() +
-        pyparsing.Literal("of") + pyparsing.White() +
-        targetString("target") + pyparsing.White() +
-        pyparsing.Literal("to") + pyparsing.White() +
-        targetString("value"))
-
-    def do(self, player, line, attribute, target, value):
-        """
-        Dispatch handling to an attribute-specific method.
-
-        @type attribute: C{unicode}
-        @param attribute: The model-level attribute of which to manipulate
-            the value.  Handling of each attribute will be dispatched to a
-            C{set_}-prefixed method for that attribute based on this value.
-
-        @type target: L{Thing}
-        @param target: The model object to manipulate.
-
-        @type value: C{unicode}
-        @param value: The new value for the specified attribute.
-        """
-        try:
-            method = getattr(self, "set_" + attribute.upper())
-        except AttributeError:
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntMakeSense(
-                    actor=player.thing,
-                    actorMessage="You cannot set that."))
-        else:
-            method(player, line, target, value)
-
-
-    def set_GENDER(self, player, line, target, value):
-        """
-        Attempt to change the gender of a thing.
-
-        @param target: The thing to change the gender of.
-        @param value: A string naming a gender on L{language.Gender}.
-        """
-        try:
-            target.gender = getattr(language.Gender, value.upper())
-        except AttributeError:
-            gender = {language.Gender.MALE: "male",
-                      language.Gender.FEMALE: "female",
-                      language.Gender.NEUTER: "neuter"}.get(target.gender)
-            raise eimaginary.ActionFailure(events.ThatDoesntMakeSense(
-                    actor=player.thing,
-                    actorMessage=("Only male, female, and neuter are valid "
-                                  "genders.  You remain ", gender, ".")))
-        else:
-            if player.thing is target:
-                # XXX Why can't I do something with Noun to collapse these
-                # cases?
-                event = events.Success(
-                    actor=player.thing,
-                    actorMessage=(u"You set your gender to ", value, "."))
-            else:
-                event = events.Success(
-                    actor=player.thing,
-                    target=target,
-                    actorMessage=("You set ", language.Noun(target).hisHer(),
-                                  " gender to ", value, "."),
-                    targetMessage=(player.thing, " set your gender to ",
-                                   value, "."))
-            event.broadcast()
-
-
-    def set_PROPER(self, player, line, target, value):
-        """
-        Attempt to change the name of a thing from a proper noun to a common
-        noun or the other way around.
-
-        @param target: The thing to change.
-        @param value: The string C{"true"} or C{"false"}.
-        """
-        if value == "true":
-            target.proper = True
-            phrase = '" a proper noun.'
-        elif value == "false":
-            target.proper = False
-            phrase = '" a common noun.'
-        else:
-            raise eimaginary.ActionFailure(
-                events.ThatDoesntMakeSense(
-                    actor=player.thing,
-                    actorMessage=("Only true and false are valid settings "
-                                  "for proper.")))
-        events.Success(
-            actor=player.thing,
-            actorMessage=('You make the name of "',
-                          language.Noun(target).shortName(),
-                          phrase)).broadcast()
-
-
-
-class Help(Action):
-    """
-    A command for looking up help files.
-
-    @cvar helpContentPath: The path in which to search for files.
-    @type helpContentPath: L{filepath.FilePath}
-    """
-    expr = (pyparsing.Literal("help") +
-            pyparsing.White() +
-            pyparsing.restOfLine.setResultsName("topic"))
-
-    helpContentPath = filepath.FilePath(imaginary.__file__).sibling(
-        "resources").child("help")
-
-    def do(self, player, line, topic):
-        topic = topic.lower().strip()
-        try:
-            helpFile = self.helpContentPath.child(topic).open()
-        except (OSError, IOError, filepath.InsecurePath):
-            player.send("No help available on ", topic, ".", "\n")
-        else:
-            player.send(helpFile.read(), '\n')

=== removed file 'Imaginary/imaginary/copyright.py'
--- Imaginary/imaginary/copyright.py	2006-04-12 02:41:46 +0000
+++ Imaginary/imaginary/copyright.py	1970-01-01 00:00:00 +0000
@@ -1,22 +0,0 @@
-
-# <major> <minor> <patch> <alpha | pre | final | zzz> <iteration>
-version_info = (0, 1, 0, 'alpha', 0)
-
-# Sortable version information.  This will always only
-# increase from an older version to a newer version.
-hexversion = (version_info[0] << 24 |
-              version_info[1] << 16 |
-              version_info[2] << 8 |
-              ['alpha', 'pre', 'final', 'zzz'].index(version_info[3]) << 4 |
-              version_info[4])
-
-# Human-readable format
-if version_info[3] == 'final':
-    version = '%d.%d.%d%s' % version_info[:-1]
-elif version_info[3] != 'zzz':
-    version = '%d.%d.%d%s%d' % version_info
-else:
-    version = "SVN-trunk"
-
-# Longer human-readable format
-longversion= "Imaginary " + version

=== removed file 'Imaginary/imaginary/creation.py'
--- Imaginary/imaginary/creation.py	2009-08-17 02:40:03 +0000
+++ Imaginary/imaginary/creation.py	1970-01-01 00:00:00 +0000
@@ -1,179 +0,0 @@
-# -*- test-case-name: imaginary.test.test_create -*-
-"""
-This module contains code associated with creating objects in game.
-"""
-
-from zope.interface import implements
-
-from twisted import plugin
-
-import imaginary.plugins
-
-from imaginary import objects
-from imaginary import events
-from imaginary import language
-
-from imaginary.iimaginary import IThingType
-from imaginary.eimaginary import ActionFailure, DoesntFit
-
-from imaginary.action import Action, insufficientSpace
-from imaginary.action import targetString
-
-from imaginary.pyparsing import Literal, White, Optional, restOfLine
-
-
-def getPlugins(iface, package):
-    """
-    Get plugins. See L{twisted.plugin.getPlugins}.
-
-    This is in place only so the tests specifically for creation can replace
-    it.  Please use L{twisted.plugin.getPlugins} instead.
-    """
-    # XXX the tests should not need to do that, make it per-instance or
-    # something...
-    return plugin.getPlugins(iface, package)
-
-
-def createCreator(*enhancements):
-    """
-    Create and return a function which can create objects in the game world.
-
-    This is a utility function to make it easy to define factories for certain
-    configurations of power-ups to be used with Imaginary.  It doesn't do
-    anything magical; you can replicate its effects simply by writing a
-    function that calls L{Enhancement.createFor} on the set of L{Enhancement}s.
-    L{createCreator} exists because you will frequently need to do that, and it
-    can be tedious.
-
-    @param enhancements: The arguments to this function are a list of 2-tuples
-        of (L{Enhancement}-subclass, keyword arguments to that class's
-        constructor).
-
-    @return: a function which takes keyword arguments that will be passed on to
-        L{objects.Thing}'s constructor, and will return a L{Thing} with an
-        instance of each class in C{enhancements} installed, via C{createFor},
-        on it.
-
-    @rtype: L{Thing}
-    """
-    def create(**kw):
-        o = objects.Thing(**kw)
-        for enhancementClass, enhancementKeywords in enhancements:
-            enhancementClass.createFor(o, **(enhancementKeywords or {}))
-        return o
-    return create
-
-
-class CreationPluginHelper(object):
-    """
-    A helper for creating plugins for the 'Create' command.
-
-    Create will search for L{IThingType} plugins and allow users to
-    instantiate a new L{objects.Thing} using the one with the name which
-    matches what was supplied to the action.
-    """
-
-    implements(plugin.IPlugin, IThingType)
-
-    def __init__(self, typeName, typeObject):
-        """
-        @type typeName: C{unicode}
-        @param typeName: A short string describing the kind of object this
-        plugin will create.
-
-        @param typeObject: A factory for creating instances of
-        L{objects.Thing}.  This will be invoked with four keyword arguments:
-        store, name, description, and proper.  See attributes of
-        L{objects.Thing} for documentation of these arguments.
-        """
-        self.type = typeName
-        self.typeObject = typeObject
-
-
-    def getType(self):
-        return self.typeObject
-
-
-
-def creationSuccess(player, creation):
-    """
-    Create and return an event describing that an object was successfully
-    created.
-    """
-    phrase = language.Noun(creation).nounPhrase()
-    return events.Success(
-        actor=player,
-        target=creation,
-        actorMessage=language.Sentence(["You create ", phrase, "."]),
-        targetMessage=language.Sentence([player, " creates you."]),
-        otherMessage=language.Sentence([player, " creates ", phrase, "."]))
-
-
-class Create(Action):
-    """
-    An action which can create items by looking at the L{IThingType} plugin
-    registry.
-    """
-    expr = (Literal("create") +
-            Optional(White() +
-                     (Literal("an") | Literal("a") | Literal("the")).setResultsName("article")) +
-            White() +
-            targetString("typeName") +
-            White() +
-            Literal("named") +
-            White() +
-            targetString("name") +
-            Optional(White() +
-                     restOfLine.setResultsName("description")))
-
-    def do(self, player, line, typeName, name, description=None, article=None):
-        """
-        Create an item, and notify everyone present that it now exists.
-        """
-        if not description:
-            description = u'an undescribed object'
-        for plug in getPlugins(IThingType, imaginary.plugins):
-            if plug.type == typeName:
-                proper = (article == "the")
-                o = plug.getType()(store=player.store, name=name,
-                                   description=description, proper=proper)
-                break
-        else:
-            raise ActionFailure(
-                events.ThatDoesntMakeSense(
-                    actor=player.thing,
-                    actorMessage=language.ExpressString(
-                        u"Can't find " + typeName + u".")))
-
-        creationSuccess(player.thing, o).broadcast()
-        try:
-            o.moveTo(player.thing)
-        except DoesntFit:
-            raise insufficientSpace(player.thing)
-
-
-
-
-def listThingTypes():
-    """
-    Return a list of C{unicode} strings each of which gives the name of a type
-    which can be created with the create command.
-    """
-    return sorted([type.type for type in getPlugins(IThingType, imaginary.plugins)])
-
-
-
-class ListThingTypes(Action):
-    """
-    An action which tells the invoker what thing types exist to be created with
-    the L{Create} command.
-    """
-    expr = Literal("list thing types")
-
-    def do(self, player, line):
-        """
-        Tell the player the thing types which exist.
-        """
-        events.Success(
-            actor=player.thing,
-            actorMessage=[(t, "\n") for t in listThingTypes()]).broadcast()

=== removed file 'Imaginary/imaginary/eimaginary.py'
--- Imaginary/imaginary/eimaginary.py	2009-06-29 04:03:17 +0000
+++ Imaginary/imaginary/eimaginary.py	1970-01-01 00:00:00 +0000
@@ -1,90 +0,0 @@
-
-from twisted.cred import error
-
-# Authentication errors
-class BadPassword(error.UnauthorizedLogin):
-    pass
-
-class NoSuchUser(error.UnauthorizedLogin):
-    pass
-
-
-# Base Imaginary error
-class ImaginaryError(Exception):
-    pass
-
-
-# Input handling errors
-class NoSuchCommand(ImaginaryError):
-    """
-    There is no command like the one you tried to execute.
-    """
-
-class AmbiguousArgument(ImaginaryError):
-    """
-    One or more of the inputs specified can not be narrowed down to
-    just one thing.  This can be due to the presence of multiple
-    things with similar names, or due to the absence of anything named
-    similarly to the given input.
-
-    @ivar action: The action which was being processed when an ambiguity was
-    found.
-
-    @type part: C{str}
-    @ivar part: The part of the command which was ambiguous.
-    Typically something like 'target' or 'tool'.
-
-    @type partValue: C{str}
-    @ivar partValue: The string which was supplied by the user for the indicated part.
-
-    @type objects: C{list} of C{IThing}
-    @ivar objects: The objects which were involved in the ambiguity.
-    """
-
-    def __init__(self, action, part, partValue, objects):
-        ImaginaryError.__init__(self, action, part, partValue, objects)
-        self.action = action
-        self.part = part
-        self.partValue = partValue
-        self.objects = objects
-
-
-
-class ActionFailure(ImaginaryError):
-    """
-    Wrapper exception for an Event that caused an action to fail (such that the
-    transaction in which it was running should be reverted).
-    """
-    def __init__(self, event):
-        ImaginaryError.__init__(self)
-        self.event = event
-
-
-    def __repr__(self):
-        return '<Action Failure: %r>' % (self.event,)
-
-
-
-class ThingNotFound(ImaginaryError):
-    """
-    Resolving a Thing by identity failed.
-    """
-
-
-# Game logic errors
-class DoesntFit(ImaginaryError):
-    """
-    An object tried to go into a container, but the container was full.
-    """
-
-
-class Closed(ImaginaryError):
-    """
-    An object tried to go into a container, but the container was closed.
-    """
-
-
-class CannotMove(ImaginaryError):
-    """
-    An object tried to move but it was not portable so it couldn't.
-    """

=== removed file 'Imaginary/imaginary/enhancement.py'
--- Imaginary/imaginary/enhancement.py	2009-06-29 04:03:17 +0000
+++ Imaginary/imaginary/enhancement.py	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-# -*- test-case-name: imaginary.test.test_enhancement -*-
-
-"""
-This module contains objects for application code to use to implement behaviors
-that attach to objects in a simulation.
-"""
-
-class Enhancement(object):
-    """
-    An L{Enhancement} is an object attached to a L{imaginary.objects.Thing}
-    that provides some additional functionality.
-
-    This class is a mixin; it expects to be mixed in to an L{Item} subclass,
-    since it passes itself as an argument to L{Item.powerUp}.
-
-    Note that an L{Enhancement} embodies the behavior, but not the physical
-    attributes, of the object in question.
-
-    For example, let's say you wanted to implement a cell phone in Imaginary.
-    You would make an L{Enhancement} called C{CellPhone} which had various
-    attributes, for example C{phoneNumber}.  Then you would do C{phoneBody =
-    Thing(...)} to create a physical 'phone' object in a world.  Next, you
-    would do C{cellPhone = CellPhone.createFor(phoneBody, ...)}, which would
-    create a C{CellPhone} object that endowed your physical 'phone' with the
-    properties of being an actual phone, like having a phone number, ringing
-    when dialed, etc.
-
-    Note that it is not enough to simply create your C{CellPhone}, as it will
-    not have a physical body, and therefore not exist in the world.
-
-    @ivar thing: a L{imaginary.objects.Thing} powered up with this
-         L{Enhancement}.  All subclasses which mix in L{Item} should declare
-         this as an L{attributes.reference} attribute.  Unless your
-         L{Enhancement} subclass is specifically designed to exist
-         independently of its L{Thing}, or to accept other types for this
-         attribute, it should also be declared as C{(allowNone=False,
-         reftype=Thing, whenDeleted=CASCADE)}.
-    """
-
-    def installed(self):
-        """
-        Override the C{installed()} hook that C{axiom.dependency} provides.
-        When L{Enhancement} was called C{ThingMixin}, the suggested mechanism
-        to install simulation components was to use the dependency system,
-        which was wrong, c.f. U{http://divmod.org/trac/ticket/2558}.
-
-        @raise RuntimeError: to indicate that you shouldn't use this
-            functionality.
-        """
-        raise RuntimeError("Use Enhancement.createFor, not installOn(), "
-                           "to apply an Enhancement to a Thing.")
-
-
-    def applyEnhancement(self):
-        """
-        Apply this L{Enhancement} to its C{thing} attribute, by powering it up.
-        """
-        self.thing.powerUp(self)
-
-
-    def removeEnhancement(self):
-        """
-        Remove this L{Enhancement} from its C{thing} attribute, by powering it
-        down.
-        """
-        self.thing.powerDown(self)
-
-
-    @classmethod
-    def createFor(cls, thing, **kw):
-        """
-        Create an L{Enhancement} of this type for the given
-        L{imaginary.objects.Thing}, in the given L{imaginary.objects.Thing}'s
-        store.
-        """
-        self = cls(store=thing.store, thing=thing, **kw)
-        self.applyEnhancement()
-        return self
-
-
-    @classmethod
-    def destroyFor(cls, thing):
-        """
-        Destroy the L{Enhancement}s of the given subclass associated with the
-        given L{Thing}, if one exists.
-
-        @param thing: A L{Thing} which may be the value of the C{thing}
-            attribute of an instance of the given L{Enhancement} subclass.
-
-        @type thing: L{Thing}
-        """
-        it = thing.store.findUnique(cls, cls.thing == thing, default=None)
-        if it is not None:
-            it.removeEnhancement()
-            it.deleteFromStore()

=== removed file 'Imaginary/imaginary/events.py'
--- Imaginary/imaginary/events.py	2009-08-18 00:20:31 +0000
+++ Imaginary/imaginary/events.py	1970-01-01 00:00:00 +0000
@@ -1,284 +0,0 @@
-# -*- test-case-name: imaginary.test.test_actions.TargetActionTests.test_resolveTargetCaseInsensitively -*-
-
-from zope.interface import implements
-
-from twisted.python import context
-
-from imaginary import iimaginary, language, eimaginary
-from imaginary.idea import Proximity, ProviderOf
-
-
-class Event(language.BaseExpress):
-    implements(iimaginary.IConcept)
-
-    actorMessage = targetMessage = toolMessage = otherMessage = None
-
-    def __init__(self,
-                 location=None, actor=None, target=None, tool=None,
-                 actorMessage=None, targetMessage=None, toolMessage=None,
-                 otherMessage=None):
-
-        if location is None and actor is not None:
-            location = actor.location
-
-        self.location = location
-        self.actor = actor
-        self.target = target
-        self.tool = tool
-        if actorMessage is not None:
-            self.actorMessage = iimaginary.IConcept(actorMessage)
-        if targetMessage is not None:
-            self.targetMessage = iimaginary.IConcept(targetMessage)
-        if toolMessage is not None:
-            self.toolMessage = iimaginary.IConcept(toolMessage)
-        if otherMessage is not None:
-            self.otherMessage = iimaginary.IConcept(otherMessage)
-
-
-    def conceptFor(self, observer):
-        """
-        Retrieve the appropriate L{IConcept} provider for a given observer.  If
-        the observer is this L{Event}'s C{actor}, it will return the
-        C{actorMessage} for this event, and so on for the tool and the target.
-        If it doesn't match a L{Thing} known to this event, it will return
-        C{otherMessage}.
-        """
-        if observer is self.actor:
-            msg = self.actorMessage
-        elif observer is self.target:
-            msg = self.targetMessage
-        elif observer is self.tool:
-            msg = self.toolMessage
-        else:
-            msg = self.otherMessage
-        return msg
-
-
-    def reify(self):
-        """
-        Determine which objects should receive this event and return a callable
-        object which will deliver it to them.
-
-        Note that this occurs during event propagation, and you probably don't
-        need to call it directly.
-
-        @see: L{iimaginary.IEventObserver.prepare} and
-            L{TransactionalEventBroadcaster} for a more thorough description of
-            how this method is used to interact with transactions.
-
-        @return: a 0-arg callable object which, when called, will call the
-            results of all L{IEventObserver}s which were contained within this
-            L{Event}'s location when this method, L{Event.reify}, was called.
-        """
-        L = []
-        for observer in (self.location.idea.obtain(
-                Proximity(0.5, ProviderOf(iimaginary.IEventObserver)))):
-            sender = observer.prepare(self)
-            if not callable(sender):
-                raise TypeError("Senders must be callable", sender)
-            L.append(sender)
-        return lambda: map(apply, L)
-
-
-    def vt102(self, observer):
-        c = self.conceptFor(observer)
-        if c is not None:
-            return [c.vt102(observer), '\n']
-        return u''
-
-
-
-class TransactionalEventBroadcaster(object):
-    """
-    Collect a bunch of output events as a transaction is being executed, then
-    distribute them when it has completed.
-
-    Events can be added normally or as revert events.  Normal events are
-    broadcast after the transaction is successfully committed.  Revert events
-    are broadcast if the transaction failed somehow and was been reverted.
-    """
-    implements(iimaginary.ITransactionalEventBroadcaster)
-
-    def __init__(self):
-        self._events = []
-        self._revertEvents = []
-
-
-    def addEvent(self, event):
-        """
-        Add a normal event.
-
-        @param event: A no-argument callable to be invoked when this
-        transaction has been committed.
-        """
-        if not callable(event):
-            raise ValueError("Events must be callable", event)
-        self._events.append(event)
-
-
-    def addRevertEvent(self, event):
-        """
-        Add a revert event.
-
-        @param event: A no-argument callable to be invoked when this
-        transaction has been reverted.
-        """
-        if not callable(event):
-            raise ValueError("Events must be callable", event)
-        self._revertEvents.append(event)
-
-
-    def broadcastEvents(self):
-        """
-        Send all normal events.
-        """
-        events = self._events
-        self._events = self._revertEvents = None
-        map(apply, events)
-
-
-    def broadcastRevertEvents(self):
-        """
-        Send all revert events.
-        """
-        events = self._revertEvents
-        self._events = self._revertEvents = None
-        map(apply, events)
-
-
-
-def runEventTransaction(store, func, *args, **kwargs):
-    """
-    This takes responsibility for setting up the transactional event
-    broadcasting junk, handling action errors, and broadcasting commit or
-    revert events.
-    """
-    broadcaster = TransactionalEventBroadcaster()
-    def runHelper():
-        # Set up event context for the duration of the action
-        # run.  Additionally, handle raised ActionFailures by
-        # adding their events to the revert event list and
-        # re-raising them so they will revert the transaction.
-        try:
-            return context.call(
-                {iimaginary.ITransactionalEventBroadcaster: broadcaster},
-                func, *args, **kwargs)
-        except eimaginary.ActionFailure, e:
-            broadcaster.addRevertEvent(e.event.reify())
-            raise
-    try:
-        result = store.transact(runHelper)
-    except eimaginary.ActionFailure:
-        broadcaster.broadcastRevertEvents()
-        return None
-    else:
-        broadcaster.broadcastEvents()
-        return result
-
-
-
-class ThatDoesntMakeSense(Event):
-    """
-    An action was attempted which is logically impossible.
-    """
-    def __init__(self, actorMessage="That doesn't make sense.", **kw):
-        super(ThatDoesntMakeSense, self).__init__(actorMessage=actorMessage, **kw)
-
-
-class ThatDoesntWork(Event):
-    """
-    An action was attempted which is phyically impossible.
-    """
-    def __init__(self, actorMessage="That doesn't work.", **kw):
-        super(ThatDoesntWork, self).__init__(actorMessage=actorMessage, **kw)
-
-
-class Success(Event):
-    """
-    You do it.  Swell.
-    """
-
-    def broadcast(self):
-        """
-        Don't really broadcast.  Add this event to the events which will be
-        sent when the action (or whatever) execution transaction is committed
-        successfully.
-        """
-        broadcaster = context.get(iimaginary.ITransactionalEventBroadcaster)
-        if broadcaster is not None:
-            broadcaster.addEvent(self.reify())
-        else:
-            self.reify()()
-
-
-
-class ArrivalEvent(Success):
-    """
-    An event representing the arrival of an object.
-    """
-
-
-
-class MovementArrivalEvent(ArrivalEvent):
-    """
-    An event representing the arrival of an object at a location from an
-    origin.
-    """
-    def __init__(self, thing, origin=None, direction=None):
-        self.thing = thing
-        self.origin = origin
-        self.direction = direction
-        self.location = self.thing.location
-
-
-    def conceptFor(self, observer):
-        if observer is self.thing:
-            return None
-        if self.origin is not None:
-            msg = [" arrives from ", self.origin, "."]
-        elif self.direction is not None:
-            msg = [" arrives from the ", self.direction, "."]
-        else:
-            msg = [" arrives."]
-        msg.insert(0, self.thing)
-        return language.Sentence(msg)
-
-
-
-class DepartureEvent(Success):
-    """
-    An event representing the departure of an object at a location to a
-    destination.
-    """
-    def __init__(self, location, actor, **kw):
-        """
-        @type location: L{iimaginary.IThing} provider.
-        @param location: The location that the actor is leaving.
-        @type actor: L{iimaginary.IThing} provider.
-        @param actor: The actor that is leaving.
-        """
-        super(DepartureEvent, self).__init__(location, actor, **kw)
-
-
-class SpeechEvent(Success):
-    """
-    An event representing something somebody said.
-
-    @ivar speaker: The Thing which spoke.
-    @ivar text: The text which was spoken.
-    """
-    def __init__(self, speaker, text):
-        """
-        @type speaker: L{iimaginary.IThing} provider.
-        @param speaker: The actor emitting this speech.
-        @type text: C{unicode}
-        @param text: The text that the actor said.
-        """
-        self.speaker = speaker
-        self.text = text
-        Success.__init__(
-            self,
-            location=speaker.location,
-            actor=speaker,
-            actorMessage=["You say, '", text, "'"],
-            otherMessage=language.Sentence([speaker, " says, '", text, "'"]))

=== removed file 'Imaginary/imaginary/garments.py'
--- Imaginary/imaginary/garments.py	2011-09-16 18:52:54 +0000
+++ Imaginary/imaginary/garments.py	1970-01-01 00:00:00 +0000
@@ -1,370 +0,0 @@
-# -*- test-case-name: imaginary.test.test_garments -*-
-
-"""
-
-Layered clothing.
-
-"""
-
-from zope.interface import implements
-
-from axiom import item, attributes
-
-from imaginary import iimaginary, language, objects
-from imaginary.eimaginary import ActionFailure
-from imaginary.events import ThatDoesntWork
-from imaginary.idea import Link
-from imaginary.creation import createCreator
-from imaginary.enhancement import Enhancement
-
-
-class Unwearable(Exception):
-    pass
-
-class TooBulky(Unwearable):
-    def __init__(self, wornGarment, newGarment):
-        self.wornGarment = wornGarment
-        self.newGarment = newGarment
-        Unwearable.__init__(self, wornGarment, newGarment)
-
-
-
-class InaccessibleGarment(Exception):
-    """The garment is covered by another, therefore it cannot be removed.
-    """
-    def __init__(self, wearer, garment, obscuringGarment):
-        self.wearer = wearer
-        self.garment = garment
-        self.obscuringGarment = obscuringGarment
-
-
-    def __str__(self):
-        return "%s tried taking off %s which was covered by %s" % (
-            self.wearer, self.garment, self.obscuringGarment)
-
-
-
-GARMENT_SLOTS = [
-    u"crown",
-    u"left eye",
-    u"right eye",
-    u"left ear",
-    u"right ear",
-
-    u"neck",
-    u"chest",
-    u"back",
-
-    u"left arm",
-    u"right arm",
-    u"left wrist",
-    u"right wrist",
-    u"left hand",
-    u"right hand",
-    u"left fingers",
-    u"right fingers",
-
-    u"waist",
-    u"left leg",
-    u"right leg",
-    u"left ankle",
-    u"right ankle",
-    u"left foot",
-    u"right foot"
-    ]
-
-class GarmentSlot:
-    pass
-
-for gslot in GARMENT_SLOTS:
-    gslotname = gslot.upper().replace(" ", "_").encode('ascii')
-    setattr(GarmentSlot, gslotname, gslot)
-
-
-
-class Garment(item.Item, Enhancement):
-    """
-    An enhancement for a L{Thing} representing its utility as an article of
-    clothing.
-    """
-    implements(iimaginary.IClothing,
-               iimaginary.IDescriptionContributor,
-               iimaginary.IMovementRestriction)
-
-    powerupInterfaces = (iimaginary.IClothing,
-                         iimaginary.IDescriptionContributor,
-                         iimaginary.IMovementRestriction)
-
-    thing = attributes.reference()
-
-    # templated / constant stuff
-    garmentSlots = attributes.textlist(allowNone=False)
-    bulk = attributes.integer(allowNone=False,
-                              default=1)
-    garmentDescription = attributes.text(doc="""
-    Description of this as an individual garment.
-    """, allowNone=False)
-
-    # transient / mutable stuff
-    wearer = attributes.reference()
-    wearLevel = attributes.integer(default=0)
-
-
-    def conceptualize(self):
-        return language.ExpressString(u'This can be worn.')
-
-
-    def expressTo(self, observer):
-        """
-        Describe the garment as it looks when it is worn.
-
-        The garment's normal description is C{self.thing.description} or
-        somesuch.
-        """
-        return self.garmentDescription
-
-
-    def nowWornBy(self, wearer):
-        """
-        This garment is now worn by the given wearer.  As this garment is now
-        on top, set its C{wearLevel} to be higher than any other L{Garment}
-        related to the new C{wearer}.
-        """
-        self.wearer = wearer
-        self.wearLevel = wearer.store.query(
-            Garment,
-            Garment.wearer == wearer).getColumn("wearLevel").max(default=0) + 1
-
-
-    def noLongerWorn(self):
-        """
-        This garment is no longer being worn by anyone.
-        """
-        self.wearer = None
-        self.wearLevel = None
-
-
-    def movementImminent(self, movee, destination):
-        """
-        Something is trying to move.  Don't allow it if I'm currently worn.
-        """
-        if self.wearer is not None and movee is self.thing:
-            raise ActionFailure(
-                ThatDoesntWork(
-                    # XXX I don't actually know who is performing the action
-                    # :-(.
-                    actor=self.wearer.thing,
-                    actorMessage=[
-                        "You can't move ",
-                        language.Noun(self.thing).definiteNounPhrase(),
-                        " without removing it first."]))
-
-
-
-def _orderTopClothingByGlobalSlotList(tempClothes):
-    """
-    This function orders a dict as returned by getGarmentDict in the order that
-    they should be shown to the user.
-
-    @param tempClothes: {clothingSlot: list of clothing objects (top last)}
-    @type tempClothes: dict
-    """
-    if not tempClothes:
-        return None
-    yetDescribed = []
-    for universalSlot in GARMENT_SLOTS:
-        slotlist = tempClothes.pop(universalSlot, ())
-        if slotlist:
-            topGarment = slotlist[-1]
-            if topGarment not in yetDescribed:
-                yetDescribed.append(topGarment)
-
-    # if somebody decided to make a wacky slot that is not in the universal
-    # slots list, just describe it last.
-    for k in tempClothes.keys():
-        x = tempClothes.pop(k)
-        if x:
-            topGarment = x[-1]
-            if topGarment not in yetDescribed:
-                yetDescribed.append(topGarment)
-
-    assert tempClothes == {}, (
-        "tempClothes not empty after all clothes eliminated: " +
-        repr(tempClothes))
-
-    return yetDescribed
-
-
-
-class Wearer(item.Item, Enhancement):
-    """
-    The clothing-wearing component of an object that can wear clothing; e.g. a
-    person or mannequin.
-    """
-
-    _interfaces = (iimaginary.IClothingWearer,
-                   iimaginary.IDescriptionContributor,
-                   iimaginary.ILinkContributor,
-                   iimaginary.ILinkAnnotator,
-                   )
-
-    implements(*_interfaces)
-
-    powerupInterfaces = _interfaces
-
-
-    thing = attributes.reference()
-
-
-    def getGarmentDict(self):
-        c = {}
-        for garment in self.store.query(Garment, Garment.wearer == self,
-                                        sort=Garment.wearLevel.ascending):
-            for usedSlot in garment.garmentSlots:
-                c.setdefault(usedSlot, []).append(garment)
-        return c
-
-
-    def putOn(self, newGarment):
-        """
-        Wear a new L{Garment} on this L{Wearer}, first moving it to this
-        L{Wearer}'s C{thing} if it is not already there.
-
-        @param newGarment: the article of clothing to wear.
-
-        @type newGarment: L{Garment}
-
-        @raise TooBulky: if the bulk of any of the slots occupied by
-            C{newGarment} is greater than the bulk of any other clothing
-            already in that slot.  (For example, if you tried to wear a T-shirt
-            over a heavy coat.)
-        """
-        c = self.getGarmentDict()
-        for garmentSlot in newGarment.garmentSlots:
-            if garmentSlot in c:
-                currentTopOfSlot = c[garmentSlot][-1]
-                if currentTopOfSlot.bulk >= newGarment.bulk:
-                    raise TooBulky(currentTopOfSlot, newGarment)
-
-        newGarment.thing.moveTo(self.thing)
-        newGarment.nowWornBy(self)
-
-
-    def takeOff(self, garment):
-        """
-        Remove a garment which this player is wearing.
-
-        (Note: no error checking is currently performed to see if this garment
-        is actually already worn by this L{Wearer}.)
-
-        @param garment: the article of clothing to remove.
-
-        @type garment: L{Garment}
-
-        @raise InaccessibleGarment: if the garment is obscured by any other
-            clothing, and is therefore not in the top slot for any of the slots
-            it occupies.  For example, if you put on an undershirt, then a
-            turtleneck, you can't remove the undershirt without removing the
-            turtleneck first.
-        """
-        gdict = self.getGarmentDict()
-        for slot in garment.garmentSlots:
-            if gdict[slot][-1] is not garment:
-                raise InaccessibleGarment(self, garment, gdict[slot][-1])
-        garment.noLongerWorn()
-
-
-    # IDescriptionContributor
-    def conceptualize(self):
-        """
-        Describe the list of clothing.
-        """
-        return ExpressClothing(self.thing, self.getGarmentDict())
-
-
-    # ILinkContributor
-    def links(self):
-        for garmentThing in self.store.query(objects.Thing,
-                                  attributes.AND(
-                Garment.thing == objects.Thing.storeID,
-                Garment.wearer == self)):
-            yield Link(self.thing.idea, garmentThing.idea)
-
-
-    # ILinkAnnotator
-    def annotationsFor(self, link, idea):
-        """
-        Tell the containment system to disregard containment relationships for
-        which I will generate a link.
-        """
-        if list(link.of(iimaginary.IContainmentRelationship)):
-            if link.source.delegate is self.thing:
-                clothing = iimaginary.IClothing(link.target.delegate, None)
-                if clothing is not None:
-                    if clothing.wearer is self:
-                        yield _DisregardYourWearingIt()
-
-
-
-class _DisregardYourWearingIt(object):
-    """
-    This is an annotation, produced by L{Wearer} for containment relationships
-    between people (who are containers) and the clothing that they're wearing.
-    A hopefully temporary workaround for the fact that clothing is rendered in
-    its own way and therefor shouldn't show up in the list of a person's
-    contents.
-    """
-    implements(iimaginary.IElectromagneticMedium)
-
-    def isOpaque(self):
-        """
-        I am opaque, so that clothing will show up only once (in your "wearing"
-        list, rather than there and in your "contained" list), and obscured
-        clothing won't show up at all.
-        """
-        return True
-
-
-
-class ExpressClothing(language.BaseExpress):
-    def __init__(self, thing, garments):
-        self.thing = thing
-        self.garments = garments
-
-
-    def vt102(self, observer):
-        heshe = language.Noun(self.thing).heShe()
-        L = _orderTopClothingByGlobalSlotList(self.garments)
-        if L is None:
-            return language.Sentence([heshe, u' is naked.']).vt102(observer)
-        return language.Sentence([
-            heshe,
-            u' is wearing ',
-            language.ItemizedList([language.Noun(g.thing).nounPhrase()
-                                   for g in L]),
-            u'.']).vt102(observer)
-
-
-
-createShirt = createCreator(
-    (Garment, dict(garmentDescription=u'an undescribed shirt',
-                   bulk=2,
-                   garmentSlots=[GarmentSlot.CHEST,
-                                 GarmentSlot.BACK,
-                                 GarmentSlot.RIGHT_ARM,
-                                 GarmentSlot.LEFT_ARM])))
-
-
-createUnderwear = createCreator(
-    (Garment, dict(garmentDescription=u'an undescribed pair of underwear',
-                   bulk=1,
-                   garmentSlots=[GarmentSlot.WAIST])))
-
-createPants = createCreator(
-    (Garment, dict(garmentDescription=u'an undescribed pair of pants',
-                   bulk=2,
-                   garmentSlots=[GarmentSlot.RIGHT_LEG,
-                                 GarmentSlot.LEFT_LEG,
-                                 GarmentSlot.WAIST,
-                                 GarmentSlot.LEFT_ANKLE,
-                                 GarmentSlot.RIGHT_ANKLE])))

=== removed file 'Imaginary/imaginary/idea.py'
--- Imaginary/imaginary/idea.py	2010-04-24 18:00:14 +0000
+++ Imaginary/imaginary/idea.py	1970-01-01 00:00:00 +0000
@@ -1,625 +0,0 @@
-# -*- test-case-name: imaginary -*-
-
-"""
-This module implements a highly abstract graph-traversal system for actions and
-events to locate the objects which can respond to them.  The top-level
-entry-point to this system is L{Idea.obtain}.
-
-It also implements several basic retrievers related to visibility and physical
-reachability.
-"""
-
-from zope.interface import implements
-from epsilon.structlike import record
-
-from imaginary.iimaginary import (
-    INameable, ILitLink, IThing, IObstruction, IElectromagneticMedium,
-    IDistance, IRetriever, IExit)
-
-
-
-class Link(record("source target")):
-    """
-    A L{Link} is a connection between two L{Idea}s in a L{Path}.
-
-    @ivar source: the idea that this L{Link} originated from.
-    @type source: L{Idea}
-
-    @ivar target: the idea that this L{Link} refers to.
-    @type target: L{Idea}
-    """
-
-    def __init__(self, *a, **k):
-        super(Link, self).__init__(*a, **k)
-        self.annotations = []
-
-
-    def annotate(self, annotations):
-        """
-        Annotate this link with a list of annotations.
-        """
-        self.annotations.extend(annotations)
-
-
-    def of(self, interface):
-        """
-        Yield all annotations on this link which provide the given interface.
-        """
-        for annotation in self.annotations:
-            provider = interface(annotation, None)
-            if provider is not None:
-                yield provider
-
-
-
-class Path(record('links')):
-    """
-    A list of L{Link}s.
-    """
-
-    def of(self, interface):
-        """
-        @return: an iterator of providers of interfaces, adapted from each link
-            in this path.
-        """
-        for link in self.links:
-            for annotation in link.of(interface):
-                yield annotation
-
-
-    def eachTargetAs(self, interface):
-        """
-        @return: an iterable of all non-None results of each L{Link.targetAs}
-            method in this L{Path}'s C{links} attribute.
-        """
-        for link in self.links:
-            provider = interface(link.target.delegate, None)
-            if provider is not None:
-                yield provider
-
-
-    def targetAs(self, interface):
-        """
-        Retrieve the target of the last link of this path, its final
-        destination, as a given interface.
-
-        @param interface: the interface to retrieve.
-        @type interface: L{zope.interface.interfaces.IInterface}
-
-        @return: the last link's target, adapted to the given interface, or
-            C{None} if no appropriate adapter or component exists.
-        @rtype: C{interface} or C{NoneType}
-        """
-        return interface(self.links[-1].target.delegate, None)
-
-
-    def isCyclic(self):
-        """
-        Determine if this path is cyclic, to avoid descending down infinite
-        loops.
-
-        @return: a boolean indicating whether this L{Path} is cyclic or not,
-            i.e. whether the L{Idea} its last link points at is the source of
-            any of its links.
-        """
-        if len(self.links) < 2:
-            return False
-        return (self.links[-1].target in (x.source for x in self.links))
-
-
-    def to(self, link):
-        """
-        Create a new path, extending this one by one new link.
-        """
-        return Path(self.links + [link])
-
-
-    def __repr__(self):
-        """
-        @return: an expanded pretty-printed representation of this Path,
-        suitable for debugging.
-        """
-        s = 'Path('
-        for link in self.links:
-            dlgt = link.target.delegate
-            src = link.source.delegate
-            s += "\n\t"
-            s += repr(getattr(src, 'name', src))
-            s += " => "
-            s += repr(getattr(dlgt, 'name', dlgt))
-            s += " "
-            s += repr(link.annotations)
-        s += ')'
-        return s
-
-
-
-class Idea(record("delegate linkers annotators")):
-    """
-    Consider a person's activities with the world around them as having two
-    layers.  One is a physical layer, out in the world, composed of matter and
-    energy. The other is a cognitive layer, internal to the person, composed
-    of ideas about that matter and energy.
-
-    For example, when a person wants to sit in a wooden chair, they must first
-    visually locate the arrangement of wood in question, make the determination
-    of that it is a "chair" based on its properties, and then perform the
-    appropriate actions to sit upon it.
-
-    However, a person may also interact with symbolic abstractions rather than
-    physical objects.  They may read a word, or point at a window on a computer
-    screen.  An L{Idea} is a representation of the common unit that can be
-    referred to in this way.
-
-    Both physical and cognitive layers are present in Imaginary.  The cognitive
-    layer is modeled by L{imaginary.idea}.  The physical layer is modeled by a
-    rudimentary point-of-interest simulation in L{imaginary.objects}.  An
-    L{imaginary.thing.Thing} is a physical object; an L{Idea} is a node in a
-    non-physical graph, related by links that are annotated to describe the
-    nature of the relationship between it and other L{Idea}s.
-
-    L{Idea} is the most abstract unit of simulation.  It does not have any
-    behavior or simulation semantics of its own; it merely ties together
-    different related systems.
-
-    An L{Idea} is composed of a C{delegate}, which is an object that implements
-    simulation-defined interfaces; a list of L{ILinkContributor}s, which
-    produce L{Link}s to other L{Idea}s, an a set of C{ILinkAnnotator}s, which
-    apply annotations (which themselves implement simulation-defined
-    link-annotation interfaces) to those links.
-
-    Each L{imaginary.thing.Thing} has a corresponding L{Idea} to represent it
-    in the simulation.  The physical simulation defines only a few types of
-    links: objects have links to their containers, containers have links to
-    their contents, rooms have links to their exits, exits have links to their
-    destinations.  Any L{imaginary.thing.Thing} can have a powerup applied to
-    it which adds to the list of linkers or annotators for its L{Idea},
-    however, which allows users to create arbitrary objects.
-
-    For example, the target of the "look" action must implement
-    L{imaginary.iimaginary.IVisible}, but need not be a
-    L{iimaginary.objects.Thing}.  A simulation might want to provide a piece of
-    graffiti that you could look at, but would not be a physical object, in the
-    sense that you couldn't pick it up, weigh it, push it, etc.  Such an object
-    could be implemented as a powerup for both
-    L{imaginary.iimaginary.IDescriptionContributor}, which would impart some
-    short flavor text to the room, and L{imaginary.iimaginary.IVisible}, which
-    would be an acceptable target of 'look'.  The
-    L{imaginary.iimaginary.IVisible} implementation could even be an in-memory
-    object, not stored in the database at all; and there could be different
-    implementations for different observers, depending on their level of
-    knowledge about the in-world graffiti.
-
-    @ivar delegate: this object is the object which may be adaptable to a set
-        of interfaces.  This L{Idea} delegates all adaptation to its delegate.
-        In many cases (when referring to a physical object), this will be an
-        L{imaginary.thing.Thing}, but not necessarily.
-
-    @ivar linkers: a L{list} of L{ILinkContributor}s which are used to gather
-        L{Link}s from this L{Idea} during L{Idea.obtain} traversal.
-
-    @ivar annotators: a L{list} of L{ILinkAnnotator}s which are used to annotate
-        L{Link}s gathered from this L{Idea} via the C{linkers} list.
-    """
-
-    def __init__(self, delegate):
-        super(Idea, self).__init__(delegate, [], [])
-
-
-    def _allLinks(self):
-        """
-        Return an iterator of all L{Links} away from this idea.
-        """
-        for linker in self.linkers:
-            for link in linker.links():
-                yield link
-
-
-    def _applyAnnotators(self, linkiter):
-        """
-        Apply my list of annotators to each link in the given iterable.
-        """
-        for link in linkiter:
-            self._annotateOneLink(link)
-            yield link
-
-
-    def _annotateOneLink(self, link):
-        """
-        Apply all L{ILinkAnnotator}s in this L{Idea}'s C{annotators} list.
-        """
-        allAnnotations = []
-        for annotator in self.annotators:
-            # XXX important to test: annotators shouldn't mutate the links.
-            # The annotators show up in a non-deterministic order, so in order
-            # to facilitate a consistent view of the link in annotationsFor(),
-            # all annotations are applied at the end.
-            allAnnotations.extend(annotator.annotationsFor(link, self))
-        link.annotate(allAnnotations)
-
-
-    def obtain(self, retriever):
-        """
-        Traverse the graph of L{Idea}s, starting with C{self}, looking for
-        objects which the given L{IRetriever} can retrieve.
-
-        The graph will be traversed by looking at all the links generated by
-        this L{Idea}'s C{linkers}, only continuing down those links for which
-        the given L{IRetriever}'s C{shouldKeepGoing} returns L{True}.
-
-        @param retriever: an object which will be passed each L{Path} in turn,
-            discovered during traversal of the L{Idea} graph.  If any
-            invocation of L{IRetriever.retrieve} on this parameter should
-            succeed, that will be yielded as a result from this method.
-        @type retriever: L{IRetriever}
-
-        @return: a generator which yields the results of C{retriever.retrieve}
-            which are not L{None}.
-        """
-        return ObtainResult(self, retriever)
-
-
-    def _doObtain(self, retriever, path, reasonsWhyNot):
-        """
-        A generator that implements the logic for obtain()
-        """
-        if path is None:
-            # Special case: we only get a self->self link if we are the
-            # beginning _and_ the end.
-            path = Path([])
-            selfLink = Link(self, self)
-            self._annotateOneLink(selfLink)
-            finalPath = path.to(selfLink)
-        else:
-            finalPath = Path(path.links[:])
-            self._annotateOneLink(finalPath.links[-1])
-
-        result = retriever.retrieve(finalPath)
-        objections = set(retriever.objectionsTo(finalPath, result))
-        reasonsWhyNot |= objections
-        if result is not None:
-            if not objections:
-                yield result
-
-        for link in self._applyAnnotators(self._allLinks()):
-            subpath = path.to(link)
-            if subpath.isCyclic():
-                continue
-            if retriever.shouldKeepGoing(subpath):
-                for obtained in link.target._doObtain(retriever, subpath, reasonsWhyNot):
-                    yield obtained
-
-
-
-class ObtainResult(record("idea retriever")):
-    """
-    The result of L{Idea.obtain}, this provides an iterable of results.
-
-    @ivar reasonsWhyNot: If this iterator has already been exhausted, this will
-        be a C{set} of L{IWhyNot} objects explaining possible reasons why there
-        were no results.  For example, if the room where the player attempted
-        to obtain targets is dark, this may contain an L{IWhyNot} provider.
-        However, until this iterator has been exhausted, it will be C{None}.
-    @type reasonsWhyNot: C{set} of L{IWhyNot}, or C{NoneType}
-
-    @ivar idea: the L{Idea} that L{Idea.obtain} was invoked on.
-    @type idea: L{Idea}
-
-    @ivar retriever: The L{IRetriever} that L{Idea.obtain} was invoked with.
-    @type retriever: L{IRetriever}
-    """
-
-    reasonsWhyNot = None
-
-    def __iter__(self):
-        """
-        A generator which yields each result of the query, then sets
-        C{reasonsWhyNot}.
-        """
-        reasonsWhyNot = set()
-        for result in self.idea._doObtain(self.retriever, None, reasonsWhyNot):
-            yield result
-        self.reasonsWhyNot = reasonsWhyNot
-
-
-
-class DelegatingRetriever(object):
-    """
-    A delegating retriever, so that retrievers can be easily composed.
-
-    See the various methods marked for overriding.
-
-    @ivar retriever: A retriever to delegate most operations to.
-    @type retriever: L{IRetriever}
-    """
-
-    implements(IRetriever)
-
-    def __init__(self, retriever):
-        """
-        Create a delegator with a retriever to delegate to.
-        """
-        self.retriever = retriever
-
-
-    def moreObjectionsTo(self, path, result):
-        """
-        Override in subclasses to yield objections to add to this
-        L{DelegatingRetriever}'s C{retriever}'s C{objectionsTo}.
-
-        By default, offer no additional objections.
-        """
-        return []
-
-
-    def objectionsTo(self, path, result):
-        """
-        Concatenate C{self.moreObjectionsTo} with C{self.moreObjectionsTo}.
-        """
-        for objection in self.retriever.objectionsTo(path, result):
-            yield objection
-        for objection in self.moreObjectionsTo(path, result):
-            yield objection
-
-
-    def shouldStillKeepGoing(self, path):
-        """
-        Override in subclasses to halt traversal via a C{False} return value for
-        C{shouldKeepGoing} if this L{DelegatingRetriever}'s C{retriever}'s
-        C{shouldKeepGoing} returns C{True}.
-