def do(self, player, line, 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."))
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 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()
def do(self, player, line, target):
from imaginary import garments
try:
player.putOn(target)
except garments.TooBulky as 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."
])))
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,
"."])).broadcast()
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)
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, "."]))
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 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()
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 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
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)
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, "."]))
# F**k the reactor, F**k 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 __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, "'"]))
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()
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."])))
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()
def testSentence(self):
self.assertEquals(
self.format(
language.Sentence([self.noun.nounPhrase(), u" is awesome."])),
u"A fake thing is awesome.")
