def sanitizeInstance(o):
"""If possible, sanitize the given instance so it is source-persistent.
"""
if reflect.isinst(o,thing.Thing):
return SourceThing(o)
if reflect.isinst(o,observable.Hash):
return SourceHash(o)
else: return o # flag a warning here; you're screwed
def sanitizeInstance(o):
"""If possible, sanitize the given instance so it is source-persistent.
"""
if reflect.isinst(o, thing.Thing):
return SourceThing(o)
if reflect.isinst(o, observable.Hash):
return SourceHash(o)
else:
return o # flag a warning here; you're screwed
def sanitizeMethod(o):
"""If this is a method of a Thing, sanitize it.
Otherwise, write out the method.
"""
if reflect.isinst(o.im_self, thing.Thing):
return SourceMethod(o)
else:
return o # screwed here too...
def sanitizeMethod(o):
"""If this is a method of a Thing, sanitize it.
Otherwise, write out the method.
"""
if reflect.isinst(o.im_self,thing.Thing):
return SourceMethod(o)
else:
return o # screwed here too...
def remove_dots(value):
if value is None:
return None
if not isinst(value, str):
value = unicode(value)
value = re.sub(r'\.', '', value)
return value
def remove_dots(value):
if value is None:
return None
if not isinst(value, str):
value = unicode(value)
value = re.sub(r'\.', '', value)
return value
def ambient_go(self, sentence):
addtl = ""
if self.exits:
exit = random.choice(self.exits)
room = self.findExit(exit)
if not reflect.isinst(room, DarkRoom):
addtl = " and head into the light!"
sentence.subject.location = room
sentence.subject.hears("You stumble around blindly...", addtl)
else:
sentence.subject.hears("You bash into a wall.")
def ambient_go(self, sentence):
addtl = ""
if self.exits:
exit = random.choice(self.exits)
room = self.findExit(exit)
if not reflect.isinst(room, DarkRoom):
addtl = " and head into the light!"
sentence.subject.location = room
sentence.subject.hears("You stumble around blindly...", addtl)
else:
sentence.subject.hears("You bash into a wall.")
def checkKeyMatch(self, key):
""" Check to see if the given key matches this object's lock.
Raise a error.Failure if it does not. Override this method to
implement different key-matching mechanisms; by default, I will check
that one of the key's lockTypes is in my list of lockTypes.
"""
if not reflect.isinst(key, Key):
error.Failure("That's not a key.")
for type in key.lockTypes:
if type in self.lockTypes:
return
error.Failure(key, " doesn't seem to fit.")
def checkKeyMatch(self, key):
""" Check to see if the given key matches this object's lock.
Raise a error.Failure if it does not. Override this method to
implement different key-matching mechanisms; by default, I will check
that one of the key's lockTypes is in my list of lockTypes.
"""
if not reflect.isinst(key, Key):
error.Failure("That's not a key.")
for type in key.lockTypes:
if type in self.lockTypes:
return
error.Failure(key, " doesn't seem to fit.")
def ability_mutate(self, sentence):
"""mutate object to new_type
This will mutate an object into a different type of object. """
mutator = sentence.directObject()
try:
newtype = sentence.indirectString("to")
newtype = self.code_space[newtype]
except:
error.Failure("You don't know of any such type.")
newtype = reflect.getcurrent(newtype)
x = issubclass(newtype, reflect.getcurrent(thing.Thing))
assert x, "You shouldn't mutate Things to types which are not Things."
if not reflect.isinst(mutator, newtype):
mutator.__class__ = newtype
def reportResults(self, testClass, method, resultType, results=None):
jresults = results
if type(jresults) == types.TupleType:
typ, val, tb = jresults
jresults = failure.Failure(val, typ, tb)
# make sure Failures don't reference objects that can't be created
# by the recipient
if reflect.isinst(jresults, failure.Failure):
jresults.type = str(jresults.type)
jresults.value = str(jresults.value)
testClassName, methodName = self.cleanResults(testClass, method)
self.jellyMethodCall("reportResults",
testClassName, methodName,
resultType,
jresults)
reporter.Reporter.reportResults(self, testClass, method, resultType,
results)
def ability_rebuild(self, sentence):
"""rebuild (name|.python.name)
This will rebuild either a Thing (reloading its toplevel module (the one that
its class is in) and changing its class as appropriate.), an object in your
namespace, or a qualified python module name (prefixed with a dot). """
ds = sentence.directString()
if ds[0] == ".":
module = string.replace(ds[1:], " ", "")
rebuild.rebuild(reflect.namedModule(module))
else:
try:
object = self.code_space[ds]
except:
object = sentence.directObject()
if reflect.isinst(object, thing.Thing):
rebuild.rebuild(reflect.namedModule(object.__class__.__module__))
else:
rebuild.rebuild(object)
# the preposition that the object being searched was found after in
# the sentence.
#
# (3) the player will be searched for methods of the form
# ability_verbname.
# (1) locations
locations = list(player.locations)
locations.reverse()
for loc in locations:
self._ambientResolve(loc)
# (2) explicitly specified objects
obVals = self.objects.items()
obVals.sort() # sort by preposition name
for prep, ob in obVals:
if reflect.isinst(ob, thing.Thing):
self._resolve(ob, prep)
# (3) attempt to get an ability from the player
self._abilityResolve(player)
if self.candidates:
return
# If there are no candidates after scanning all of the usual suspects
# for applicable verbs, perform an exhaustive search for other objects
# which contain an auto-verb listed for this verb. This means a
# hashtable of the form
#
# {verb: preposition,
# ...}
#
# Where verb is the name of the verb which should be automatically used
# the preposition that the object being searched was found after in
# the sentence.
#
# (3) the player will be searched for methods of the form
# ability_verbname.
# (1) locations
locations = list(player.locations)
locations.reverse()
for loc in locations:
self._ambientResolve(loc)
# (2) explicitly specified objects
obVals = self.objects.items()
obVals.sort() # sort by preposition name
for prep, ob in obVals:
if reflect.isinst(ob, thing.Thing):
self._resolve(ob, prep)
# (3) attempt to get an ability from the player
self._abilityResolve(player)
if self.candidates:
return
# If there are no candidates after scanning all of the usual suspects
# for applicable verbs, perform an exhaustive search for other objects
# which contain an auto-verb listed for this verb. This means a
# hashtable of the form
#
# {verb: preposition,
# ...}
#
# Where verb is the name of the verb which should be automatically used
