/*
* There's a couple bugs in this sample game. I'm posting it
* anyway because it's not supposed to be a 'plug-n-play'
* module, but rather just here to demonstrate a technique.
* I rather doubt that anyone will use it in its present form.
* (It works quite well enough to see what's going on here.)
* If you fix it gooder, please repost it on ifarchive. thanks.
* Anyway:
*
* I'm trying to achieve several things with this example game.
*
* First and most important, there's a technique here by which
* the parser can deal intelligently with standard English
* dependent clauses during disambiguation. (It recognizes and
* correctly understands "the water that is in the bucket" for
* example.)
*
* Second, this is a liquid handler with special capabilities.
*
* The liquid handler explores a bit how this parser stuff can
* be applied practically, but I bet you can think of even
* cooler uses for the parser tricks in this example game.
*
* I don't have a lot of time on my hands (contrary to
* appearances...), but if you want to you can bug me with
* questions about this thing. I hope it's well enough
* commented, though.
*
* I don't know how useful this is for T3. (If you decide to
* adapt it, I'd be happy to hear from you.) I wrote this before
* T3 was released. It's probably totally obsolete as it is now,
* but hopefully it will be useful as an illustration of a
* technique.
*
* Anyhow,
* Do whatever you like with this. (hack, steal, sell, ridicule, adapt,
* and/or take complete credit for.)
* Drop me a line if you do something clever with it that you think I
* might want to see.
* - breslin
*
[email protected]
*
*/
#include <adv.t>
#include <std.t>
addliquidlocationadjective: function;
delliquidlocationadjective: function;
replace commonInit: function
{
setdaemon(delliquidlocationadjective, nil);
}
/****************************************
* this is a complex section. our execution has to do
* specifically with the reservoir class (see below) and related
* object handling.
*
* however, the general potential of this code is impressive, in our
* opinion. this is recommended reading for anyone interested in parser
* systems and techniques.
*
* we're making clauses such as 'the water thats in the bottle'
* parseable. that's the goal. here's the plan:
* first, we make the final word of the phrase a noun for the target
* object.
* the target object in this case is the water (the water that's in the
* bottle in particular). so to the corresponding object, we add the noun
* 'bottle'. we then make its other noun ('water') into an adjective.
* to recap: at this point,
* we have an object _water_, and to this object has been added the noun
* 'bottle' (the same name which its location has)
* and we have also added to this object the adjective 'water' (its
* primary noun before we started the name adding). we can't refer to it
* as 'the water thats in the bottle' yet, but
* we can already refer to it as 'water bottle'. (this doesnt help much
* yet, of course.)
*
* now all we have to do is contort each of the words in the 'thats in the'
* part of the clause into simple adjectives which we assign to the target
* object. so, now we have the target object _water_ which has adjectives
* 'water' 'thats' 'in' and 'the', and for one of its nouns, 'bottle'.
* viola.
*
* Beware:
* this contortion is a problem if not handled carefully. for one example,
* "in" and "from" are used in other senses. if we don't treat "in"
* carefully, for example, it can be misinterpreted by the parser as an
* adjective elsewhere:
*
* > put the water in the bottle
*
* What do you want to put it in?
*
* by 'it', the parser is referring to the water that's inside the bottle.
* the parser thinks this construction was attempting: "put the water
* (thats currently) in the bottle (into someplace as yet unspecified)".
* for this reason, if not for several others, the changes we make to the
* object for the purposes of parsing clauses like 'the water thats in the
* bottle' or 'the lotion thats in the basket' must be temporary changes.
* in other words, if we don't revert to basic parsing, we introduce more
* problems than we solve.
*
* in the present game, we're only using this technique during
* disambiguation of specific classes of objects.
*
* our implementation of this plan works fine in this game, but we submit
* a few questions/ideas to anyone interested in developing this further:
*
* once we spoil the player with definite clauses (clauses that begin
* with "that" -- or alternatively "which"), they'll want to use them
* elsewhere. developing this clause-parsing system might involve hooking
* into the parser near the point where the parser would normally complain,
* "there's words after your command I can't use". (?)
* it seems as though we then could add our contorted adjectives to the
* words in question, assign them the noun from the end of the phrase, and
* run the command through again. (?)
*
* it's possible that doing this would merely complicate, and not improve
* the parser. (?)
*
* it might be desireable to move all this stuff from parseDisambig to
* disambigDobj/Iobj... although for the moment we can't see any particular
* benefit. (?)
*
**********************************************************************/
parseDisambig: function(str, lst)
{
local i, cnt, liquidinlist;
liquidinlist := nil;
for (i := 1, cnt := length(lst) ; i <= cnt ; ++i)
{
if ((isclass(lst[i], liquid)) or (isclass(lst[i], liquidreservoir)))
liquidinlist := true;
}
if (liquidinlist)
{
local i, cnt, testdog;
"Do %you% mean the ";
for (i := 1, cnt := length(lst) ; i <= cnt ; ++i)
{
if (isclass(lst[i], liquid))
{
lst[i].thedesc;
" thats in <<lst[i].location.thedesc>>";
addliquidlocationadjective (lst[i]);
}
else if (isclass(lst[i], liquidreservoir))
{
if (isclass(lst[i].location, liquidcontainer))
{
lst[i].thedesc;
" thats in <<lst[i].location.thedesc>>";
}
else
{
if (lst[i].preferredDisambName <> 'undefined')
"<<lst[i].preferredDisambName>>";
else
"<<str>> from <<lst[i].thedesc>>";
}
addliquidlocationadjective (lst[i]);
}
else
{
say(car(getwords(lst[i], &adjective)));
" ";
lst[i].sdesc;
}
if (i < cnt) ", ";
if (i + 1 = cnt) "or ";
}
"?";
}
else
{
local i, tot, cnt;
"Which << str >> do %you% mean, ";
for (i := 1, cnt := length(lst) ; i <= cnt ; ++i)
{
lst[i].thedesc;
if (i < cnt) ", ";
if (i + 1 = cnt) "or ";
}
"?";
}
}
addliquidlocationadjective: function(item)
{
local loc, newnoun, newadj;
if (isclass(item.location, liquidcontainer) = nil)
return; // unnecessary unless container
// is involved (!)
if (item.locationadjective = true) // should always be redundant
return;
loc := item.location;
newnoun := car(getwords(loc, &noun)); // container's name.
// reservoirs inside (fixed)
// liquidcontainers _should_
// naturally inherit the
// container name. if the
/* // reservoir did not, we're
* need to save the noun, because // going to add it here, and
* the location potentially changes. // we're not going to take it
*/ // away with the del-function
// liquids inside
// liquidcontainers (!) are
// assigned the container
// name as a temporary
// noun (!)
if (isclass(item, liquid))
item.tempnoun := newnoun;
newadj := car(getwords(item, &noun)); // actually many new adjectives
// (see below). the only
// _item_specific_ one is
// the name of the item.
// (!) the name of the
// item is re-assigned to the
// item as an adjective (!)
addword(item, &noun, newnoun); // these two are the only
addword(item, &adjective, newadj); // _item_specific_ changes.
addword(item, &adjective, 'in'); // the remaining changes
addword(item, &adjective, 'from'); // are generic
addword(item, &adjective, 'inside');
item.locationadjective := true; // changes have been made (!)
global.liquidlocationadjectivelist := global.liquidlocationadjectivelist + item;
}
delliquidlocationadjective: function(parm) // reverses (!) the effect of
{ // addliquidlocationadjective.
if (global.liquidlocationadjectivelist <> []) // we apologise for the
{local llal, i; // obsessive doublechecking
llal := global.liquidlocationadjectivelist; // you're about to witness.
for (i := 1; i <= length(llal); i++) // we're leaving this in, in
// case you're debugging
// and need the help.
{
local loc, newnoun, newadj, liqlist;
if (llal[i] = nil) return;
liqlist := global.liquidlist;
loc := llal[i].location;
if (
(length(liqlist) > length(liqlist - llal[i])) // if item isn't on the
and // global.liquidlist,
(isclass(loc, liquidcontainer) = true) // we leave it alone.
and // this shouldn't happen.
(llal[i].locationadjective <> nil) // should always be a redundant check
)
{
newnoun := llal[i].tempnoun; // the noun that was newly
// assigned during
// addliquidlocationadjective.
// primary noun of the item's
// container. we're stripping
// that from the item if the
// item isn't a reservoir.
if (isclass(llal[i], liquid)) // only liquids, not reservoirs, need
delword(llal[i], &noun, newnoun); // to be adjusted here. reservoirs
// are supposed to inherit their
// container name, if they have a
// container. so we don't want to
// delete that.
newadj := car(getwords(llal[i], &noun)); // primary noun of the item, which
// had been made into an adjective
// (reservoir or not).
delword(llal[i], &adjective, newadj); // we remove the item's primary
// noun from the item's adjective
// list. This may or may not be
// really necessary.... (?)
delword(llal[i], &adjective, 'in'); // now we remove the other generic
delword(llal[i], &adjective, 'from'); // adjectives.
delword(llal[i], &adjective, 'inside');
llal[i].locationadjective := nil; // changes reversed, remove flag
}
}
global.liquidlocationadjectivelist := [];
}
}
modify thing
adjective = 'thats' 'that\'s' 'the' // see parsedisamb for explanation
doPutIn(actor, io) = // this deals with foreign objects
{ // (solid objects) going into
// reservoirs.
if ((isclass(io, liquidreservoir)) and (isclass(io.location, room)))
// if the reservoir doesn't have a container, objects placed in it
// are destroyed. (like throwing an object in a lake or so. change this
// whenever necessary.)
{
"%You% throw%s% <<self.thedesc>> into <<io.thedesc>>. Hope you didn't
need that!";
self.moveInto(nil);
}
else if (isclass(io, liquidreservoir))
{
"%You% put%s% <<self.thedesc>> in <<io.location.thedesc>>.";
self.moveInto(io.location);
}
else // not a reservoir. regular putIn.
{
self.moveInto(io);
"Done. ";
}
}
verIoPourIn(actor) = { }
verDoPourIn(actor, iobj) = { }
verIoPourInto(actor) = { }
verDoPourInto(actor, iobj) = { }
verDoFillWith(actor, iobj) = { }
verIoFillWith(actor) = { }
ioFillWith(actor, dobj) =
{
execCommand(actor, putVerb, self, inPrep, dobj);
}
ioPourInto(actor, dobj) =
{
execCommand(actor, putVerb, dobj, inPrep, self);
}
ioPourIn(actor, dobj) =
{
execCommand(actor, putVerb, dobj, inPrep, self);
}
verDoEmpty(actor) = { "\^<<self.thedesc>> isn't the sort of thing that
can be filled and emptied."; }
ioEmptyOn(actor, dobj) = { dobj.doEmptyOn(actor, self); }
ioEmptyIn(actor, dobj) = { dobj.doEmptyInto(actor, self); }
ioEmptyInto(actor, dobj) = { dobj.doEmptyInto(actor, self); }
;
modify global
liquidlocationadjectivelist = []
lamplist = [] // list of all known light providers in the game
liquidlist = [] // list of all liquids and liquidreservoirs
;
startroom: room
sdesc = "The Demonstration Room"
ldesc = {
"There's a toilet here, a river, and a gruesome stream of ";
"blood. You might be carrying some liquid containers.";
}
north = startroom
;
toilet: liquidcontainer, fixeditem
location = startroom
sdesc = "toilet"
noun = 'toilet'
adjective = 'white'
canReachContents = true
ldesc = {
"It's a standard public toilet:
white porcelain, and a flusher for flushing.\n";
"There's water in the bowl. ";
}
verDoFlush( actor ) = {}
doFlush( actor ) = {
"The toilet gurgles loudly as water rushes through the bowl.\n";
}
;
bottle: liquidcontainer
location = startroom
sdesc = "bottle"
noun = 'bottle'
ldesc = {
"It's made of glass, and somewhat ribbed around the sides,
much like an old style cocacola bottle. It has no lid. ";
pass ldesc;
}
adjective = 'glass'
ioPutIn(actor, dobj) = {
if (
(isclass(dobj, liquid) = nil)
and
(isclass(dobj, liquidreservoir) = nil)
)
"The rim of the bottle is too narrow. You can't force it in.";
else
dobj.doPutIn(actor, self);
}
;
/****************
* the whole purpose of liquidreservoir is, you don't empty
* the liquidreservoir when you get the liquid from it.
*
* the implementation adopted for liquids is as follows:
*
* there's a liquid class, and then there's the
* liquidreservoir class.
* the player actually only takes an object of class 'liquid',
* which is dynamically created and moved into the player's
* container when s/he gets/pours/etc the liquidfountain object
* with/into/etc an appropriate container. for each liquidreservoir
* type object, there should be a corresponding liquid
* but not necessarily vice-versa. liquidreservoir
* items should be lakes, swamps, streams, fountains,
* etc. liquids are 'water/riverwater' 'slime' etc.
* the player never touches the actual reservoir
* while pouring. the corresponding liquid is substituted
* for it. liquidreservoir items can be inside other items,
* as in the water inside a fountain. see below for info about
* liquidcontainers (items designed to contain liquids, as opposed
* to items designed to contain liquidcontainers).
*
* now here's some slightly more complicated technical stuff that you
* only need to read if you want to improve our system:
* the command involved in moving and creating liquids
* center around the verb PutIn. the other verbs (such
* as FillWith, PourIn, PourInto) execute PutIn.
* one important thing to remember: normally, the
* io<Verb>[Prep] actually carries out the action of the
* verb after it passes its verIo<Verb>[Prep] and
* verDo<Verb>[Prep], but with the verb "PutIn", this action
* is transferred from IoPutIn to DoPutIn. (this is its
* natural library definition, and wasn't our idea -- wether
* it makes more sense or not... probably does or mike would have
* made it more consistant.) anyway,
* in other words, the object being "contained" actually
* performs the action of the verb, not the container.
* There's nothing wrong with changing this if you want
* to, but we've adopted this for liquids, to keep things
* (?) simpler (?), and standard, and hopefully more
* intuitive for people who know TADS well enough to be
* making improvements on our system.
*
* as a side note, dynamically created liquids are, so to
* speak, only one volume, as are liquidcontainers (i.e.,
* liquidcontainers are either filled, or empty.) this means
* that you can fill a barrel with a teacup, and vice versa.
* if you feel like you need to fix this for your game, check
* out safe.t in if-archive\programming\tads\examples. that
* might get you started.
* also, you might consider testing containability
* based on wether or not one container will fit inside another.
* you could use container bulk for this, or some other measure,
* for example dan shovitz' (unpublished ?) 1 thru 6 size gague,
* a la LFPhoenix.
************************************************/
modify theFloor
ioPutOn(actor, dobj) =
{
if (isclass(dobj,liquid))
{ dobj.doPutOn(actor, self); }
else
dobj.doDrop(actor);
}
;
modify class container
verDoEmpty(actor) = { }
verDoEmptyOn(actor, io) = { }
verIoEmptyIn(actor) = { self.verIoEmptyInto(actor); }
verDoEmptyIn(actor, io) = { self.verDoEmptyInto(actor, io); }
verIoEmptyInto(actor) = { }
verDoEmptyInto(actor, io) = {
if (io.isIn(self))
{
"%You%'ll have to take <<io.thedesc>> out of
<<self.thedesc>> before %you% can do that.";
}
}
doEmptyIn(actor, io) = { self.doEmptyInto(actor,io); }
doEmpty(actor) = {
"(onto the ground)\n";
self.doEmptyOn(actor, theFloor);
}
doEmptyOn(actor, io) = {
if ((self.contents) = [])
{
"%You% might want to try putting something inside <<self.thedesc>> ";
"before %you% decide%s% to empty it.";
return;
}
if ((self.isIn(parserGetMe()) = nil) and (isclass(self, fixeditem)))
{
"%You%'d have to pick up <<self.thedesc>> to empty it, and %you%
can't pick it up. Maybe %you% should try just taking its
contents.";
return;
}
else
{
local i, c;
if (self.location <> parserGetMe())
{
"%You% grab%s% <<self.thedesc>> and empt%ies% its contents onto
<<io.thedesc>>.\n";
self.moveInto(parserGetMe());
}
c := self.contents;
for (i := 1; i <= length(c); i++)
{
if (c[i].isOnSurface = nil)
{
"\n\^";
c[i].sdesc;
": ";
execCommand(actor, putVerb, c[i], onPrep, io);
}
}
}
}
doEmptyInto(actor, io) = {
if ((self.contents) = [])
{
"%You% might want to try putting something inside <<self.thedesc>>
before %you% decide%s% to empty it.";
return;
}
if ((self.isIn(parserGetMe()) = nil) and (isclass(self, fixeditem)))
{
"%You%'d have to pick up <<self.thedesc>> to empty it, and %you%
can't pick it up. Perhaps %you% should try just taking its
contents.";
return;
}
else
{
local i, c;
if (self.location <> parserGetMe())
{
"%You% grab%s% <<self.thedesc>> and empt%ies% its contents into
<<io.thedesc>>.\n";
self.moveInto(parserGetMe());
}
c := self.contents;
for (i := 1; i <= length(c); i++)
{
if (c[i].isOnSurface = nil)
{
"\n\^";
c[i].sdesc;
": ";
execCommand(actor, putVerb, c[i], inPrep, io);
}
}
}
}
;
class liquidreservoir: fixeditem
preferredDisambName = 'undefined' // useful for reservoirs
// without containers (lakes, etc.)
verIoPutIn(actor) = { }
ioPutIn(actor, dobj) = { dobj.doPutIn(actor, self); }
ispoison = nil
liquidContentsClassPointer = nil // must put the contents class here
verDoTake(actor) = {
"\^<<self.liquidContentsClassPointer.thedesc>> would just
slip through %your% fingers.";
}
doPutIn(actor, io) =
{
local contentsClassPointer := new liquidContentsClassPointer;
if (io.isIn(actor)=nil)
{
"(takeing <<io.thedesc>>)\n";
io.moveInto(actor);
}
global.liquidlist := global.liquidlist + contentsClassPointer;
contentsClassPointer.moveInto(io);
(io.isfilled := true);
/******************************
* we're assuming that carriable reservoirs haven't been implemented.
* if you have a reservoir that's carried, you might
* want to add a custom message about that in the
* following lines. if you want to change its behavior, you might need
* to do something with verIoPutIn/verDoPutIn
*********************************************/
if ((self.location) and (firstsc(self.location) <> room))
{
"%You% dip%s% <<io.thedesc>> into <<self.location.thedesc>> and
fill%s% it with <<liquidContentsClassPointer.sdesc>>.";
}
else
{
"%You% dip%s% <<io.thedesc>> into <<self.thedesc>> and
fill%s% it with <<liquidContentsClassPointer.sdesc>>. ";
}
}
verDoPutIn(actor, io) =
{
if (io = nil)
return;
else if (
((isclass(io, liquidcontainer)) = nil)
and
((isclass(io, liquidreservoir)) = nil)
)
{
"\^<<io.thedesc>> isn't a suitable container
for <<self.liquidContentsClassPointer.sdesc>>. ";
}
else if ((io = self) or (io = self.location))
{
"%You% can't pour "; self.thedesc; " in <<self.itselfdesc>>, pal. ";
}
else if (io.isIn(self))
self.circularMessage(io);
else if (isclass(io, fixeditem))
{
"How do%es% %you% expect to do that? %You% can move
neither ";
if (firstsc(io.location) = room)
io.thedesc;
else
io.location.thedesc;
" nor ";
if (firstsc(self.location) = room)
self.thedesc;
else
self.location.thedesc;
".";
}
else if (length(io.contents) > 0)
{
local i, c;
c := io.contents;
for (i := 1; i <= length(c); i++)
{
if (isclass(c[i], liquidContentsClassPointer))
{
local liquidInsideIo := c[i];
"%You're% too late. It's already filled
with <<io.thedesc>>.\n";
}
else if (isclass(c[i], liquid))
{
local liquidInsideIo := c[i];
"\^<<io.thedesc>> is already filled
with <<liquidInsideIo.sdesc>>. %You%'ll have to empty it
first.";
}
}
/* optional: else "There's already something inside <<io.thedesc>>."; */
}
else
self.verifyRemove(actor);
}
verDoPourOn(actor, io) =
{
"If %you% could figure out a way to pick up <<self.thedesc>>, %you%
might have a chance.";
}
verIoDouseWith(actor, io) = {self.verDoPourOn(actor, io);}
verDoPutOn(actor, io) = {self.verDoPourOn(actor, io);}
doPutOn(actor, io) = {self.verDoPourOn(actor, io);}
verDoDrink(actor) = { }
doDrink(actor) = {
if (self.ispoison)
{
if (actor = parserGetMe())
{
"Hmm, that tasted strange...\nYou sputter and gag for a moment,
then roll up into a ball and die a quick but painful death.\n";
die();
}
else
{
"<<actor.sdesc>> refuses.\n"; // if this ever happens, you'll want to
} // change the message here anyway
}
else
{
"%You% gulp%s% down <<self.thedesc>>. Aah, refreshing!";
}
}
verDoGiveTo(actor, io) =
{
"%You% can't grab <<self.liquidContentsClasspointer.thedesc>> without spilling it.
Perhaps %you% should find something to carry it in.";
}
verDoSmell( actor ) = {}
doSmell( actor ) =
{
"It smells like <<self.sdesc>>";
}
;
class liquidcontainer: container
isfilled = nil
;
class liquid: item
verDoEmptyOn(actor, io) = { }
doEmptyOn(actor, io) = { io.ioPourOn(actor, self); }
verDoEmptyIn(actor, io) = { }
doEmptyIn(actor, io) = { self.doPutIn(actor, io); }
verDoEmpty(actor) = { }
doEmpty(actor) = {
"(onto the ground)\n";
self.doPutOn(actor, theFloor);
}
doDrop(actor) = {
self.doPutOn(actor, theFloor);
}
tempnoun = ''
isEquivalent = nil
ispoison = nil
verDoTake(actor) = {
"\^<<self.thedesc>> would just slip through %your% fingers.";
}
/**************************************************************
* the way we've implemented it here, you can dump as much
* foreign liquids into a liquidreservoir as you want, and
* they'll just dissolve into the reservoir. doing that does not
* change the reservoir at all. even if you dump tons of poison
* into the reservoir, it dissolves safely, no problem. depending on
* the imagined size of a specific reservoir, this might need to be
* over-ridden (on a case by case basis.) keep in mind that you'll
* need to change the behavior of liquids, not the behavior of the
* reservoir. (one of the magics of ioPutIn = dobj.doPutIn)
**************************************************************/
doPutIn(actor, io) =
{
self.location.isfilled := nil;
if (isclass(io, liquidreservoir))
{
if (isclass(self, io.liquidContentsClassPointer))
{
"%You% pour%s% <<self.thedesc>> back into <<io.thedesc>>.";
}
else
{
"%You% pour%s% <<self.thedesc>> from <<self.location.thedesc>> into ";
if (firstsc(io.location) = room)
{
io.thedesc;
". It mixes in ";
}
else
{
io.location.thedesc;
". It mixes with
<<io.liquidContentsClassPointer.thedesc>> ";
}
"and slowly dissolves.";
}
global.liquidlist -= self;
delete self;
}
else if (
(io.location)
and
(isclass(io.location, fixeditem) = nil)
)
{
if (io.isIn(actor)=nil)
{
"(takeing <<io.thedesc>>)\n";
io.moveInto(actor);
}
"%You% pour%s% <<self.thedesc>> from <<self.location.thedesc>> into
<<io.thedesc>>. ";
self.moveInto(io);
}
else if (io.location)
{
"%You% pour%s% <<self.thedesc>> from <<self.location.thedesc>> into
<<io.thedesc>>. ";
self.moveInto(io);
}
else
pass doPutIn; // this won't happen unless your game is wierd
}
verDoPutIn(actor, io) =
{
local i;
if (io = nil)
return;
else if (self.isIn(actor) = nil)
{
if (isclass(self.location, liquidcontainer))
"%You're% not carrying <<self.location.thedesc>>.";
else
"%You're% not carrying <<self.thedesc>>.";
}
else if (self.location = io)
{
"\^<<self.thedesc>> is already inside <<io.thedesc>>, ace. ";
}
else if (io = self)
{
"%You% can't pour "; self.thedesc; " in <<self.itselfdesc>>, pal. ";
}
else if (
((isclass(io, liquidcontainer)) = nil) // it can go into
and // containers.
((isclass(io, liquidreservoir)) = nil) // allow liquids to
) // mix into reservoirs
{
"\^<<io.thedesc>> isn't a suitable container for <<self.sdesc>>. ";
}
else if (io.isIn(self))
self.circularMessage(io);
else if (io.isfilled)
{
for (i := 1; i <= length(io.contents); i++)
{
if (firstsc(io.contents[i]) = firstsc(self))
{
"%You're% a bit late, pal. There's already <<self.thedesc>> in
<<io.thedesc>>.";
return;
}
}
"\^<<io.thedesc>> already has another liquid in it. Maybe %you%
should empty it first.";
}
else
self.verifyRemove(actor);
}
verDoDrink(actor) = { }
doDrink(actor) =
{
if (self.ispoison)
{
if (actor = parserGetMe())
{
(self.location.isfilled := nil);
"Hmm, that tasted strange...\nYou sputter and gag for a moment,
then roll up into a ball and die a quick but painful death.\n";
die();
}
else
{
"<<actor.sdesc>> adamantly refuses."; // you'll change this if it
} // ever becomes relevant
}
(self.location.isfilled := nil);
"%You% gulp%s% down <<self.thedesc>>. Aah, refreshing!";
(global.liquidlist := global.liquidlist - self);
delete self;
}
verDoGiveTo(actor, io) =
{
if (isclass(self.location, liquidcontainer))
{
"%You% can't grab <<self.thedesc>> without spilling it. ";
if (isclass(self.location, fixeditem) = nil)
{
"Perhaps %you% should give <<io.thedesc>> ";
self.location.thedesc;
".";
}
else
{
"Perhaps %you% should find something to carry <<self.thedesc>> in.";
}
}
else if (not self.location = parserGetMe())
{
"%You%'ll have to figure out some way to pick it up first.";
}
}
;
toiletbowlwater: liquidreservoir
location = toilet
ispoison = true
noun = 'water'
sdesc = "water"
adjective = 'toilet'
ldesc = "You carefully study the inside of the toilet bowl. It's rather
dirty... stinky... hmm, filthy... disgusting...."
liquidContentsClassPointer = toiletwater
;
class toiletwater: liquid
ispoison = true
ldesc = "You study the yellowish-brownish toilet water closely.
Evidently, you find it quite interesting."
location = nil
noun = 'water'
adjective = 'brownish' 'yellowish' 'yellowish-brownish' 'dirty' 'brown' 'yellow' 'toilet'
sdesc = "yellowish-brownish toilet water"
adesc = "some yellowish-brownish toilet water"
;
/*****************
* The next few items are examples of liquids
* and liquidreservoirs.
* You will find that assigning names, nouns, and
* adjectives to the liquids and reservoirs is
* slightly trickier that you might expect.
* This is an unavoidable (?) result of the disambiguation
* tricks we're using. If you can read the code well
* enough to figure out the way that disambiguation
* works in this game, you should have no problem
* picking unproblematic names and unambiguous
* adjectives. If we haven't commented the code
* well enough for you to understand it, we apologise,
* and offer these examples in compensation.
*
* The best advice is, keep it as simple as possible.
* Dynamic objects are difficult enough to disambiguate
* already, and making them come from quasi-identical
* sources (sources that a player will imagine are just
* bigger versions of the dynamically created object
* which they come away with) makes disambiguation
* really tough.
* So keep the names and adjectives as simple and clear
* as possible.
*
* we'll load Me with a couple containers, and put the examples
* in the startroom
*/
jug: liquidcontainer // must be liquidcontainer. normal
location = Me // containers don't work for liquids.
sdesc = "jug"
noun = 'jug'
;
cup: liquidcontainer
location = Me
sdesc = "cup"
noun = 'cup'
;
river: liquidreservoir // name and class, same as usual
// these kinds of things you'll normally
// want to leave unlisted, so you can
// talk about them in room descriptions.
noun = 'river' 'water' // name of reservoir, AND name of liquid
// which comes out of reservoir. (MUST
// have the latter. You might want to
// eliminate the former, but only if the
// reservoir has a container. check out
// the toiletbowlwater for further ideas.
// if it does have a container, it must
// be a fixed container, or wierd stuff
// happens.)
adjective = 'river' // MUST have name of reservoir as adjective.
// if the reservoir is in a fixedcontainer,
// this is optional.
sdesc = "river" // keep it as simple as possible. adding
// words here might confuse the player.
ldesc = "It is running uphill. How odd."
location = startroom
ispoison = nil
preferredDisambName = 'river water' // useful ONLY if the reservoir is
// _not_ in another object. Lakes,
// streams, rivers, etc. get a
// preferred disambiguation name.
// reservoirs that are inside
// containers, like the
// toiletbowlwater in this game,
// don't use this name, but instead
// are disambiguated based on their
// location. (e.g., the water that's
// in the toilet). You can assign
// this name anyway, but it will never
// be used by the game. If you fail
// to assign a preferred disamb name,
// our disambiguator will figure out
// something, but it might not be
// quite as elegant. (then again, it
// might be more elegant. hehe.)
// (!) IMPORTANT: (!)
// one other thing about this
// preferredDisambName: the last
// word in the string MUST be the
// NOUN of the reservoir.
// also, ALL of the other words in
// the string MUST be adjectives of
// the reservoir. If the noun you
// choose is the noun which the
// reservoir shares with the liquid,
// the adjectives are crucial, and
// should be obviously different from
// the adjectives for the liquid. (as
// in this particular example).
liquidContentsClassPointer = riverwater // _MUST_ put the contents
// class here. (the liquid
// you want it to serve.)
// this is what makes the
// fountain work.
;
class riverwater: liquid // this object works
// basically as a template for
// all of the dynamically generated
// objects (liquids) which come
// out of the corresponding reservoir.
// therefore, it is a CLASS, NOT an
// object. and it doesn't have a
// location.
noun = 'water' // keep it simple. shares this noun
// with its reservoir source (!)
adjective = 'clear' 'clean' // intuitive, simple.
adesc = "water"
sdesc = "some water"
thedesc = "the water"
ldesc = "It's clean, cool, refreshing. Just the thing after a
long adventure! Or a long codeing session!!"
;
stream: liquidreservoir // another example, basically the same as river
location = startroom
ispoison = true // careful!
noun = 'stream' 'blood' // must share noun (here, 'blood')
sdesc = "terrible stream"
adjective = 'stream'
preferredDisambName = 'the stream' // last word is primary noun
// not shared noun. so we're not
// worried about making clear
// adjectives in this string.
ldesc = "It's a terrible stream of seeping blood."
liquidContentsClassPointer = blood // must put the contents class here
;
class blood: liquid
ispoison = true
adesc = "some blood"
noun = 'blood' // must share noun
sdesc = "blood"
adjective = 'succulent'
ldesc = "Eww. Oozy and yucky. You can almost feel it pulsing!"
;
/*
* the most interesting example is the toilet, toiletwater, and
* toiletbowlwater, above. that's somewhat more complex, because the
* toiletbowlwater (reservoir) is inside a container (namely, the toilet).
* such containers, as noted above, can't be moveable. (because we didn't
* implement that).
* you will notice there that a liquidreservoir CAN have only
* one noun, as long as it's the same noun as its corresponding
* liquid. (depends on the specifics of the situation. with the toilet,
* one noun works best. with a fountain or a well, it probably needs
* to be named after its container, in addition to sharing a name with
* its liquid. you'll figure it out when you tinker with it.)
* perhaps obvious (?): if your liquidreservoir is in a container, you
* should probably make the container a liquidcontainer. (that way,
* liquids can
* be poured into it.)
*********************************************************************/
fillVerb: deepverb
sdesc = "fill"
verb = 'fill'
ioAction( withPrep ) = 'FillWith'
action( actor ) = 'Fill'
prepDefault = withPrep
;
emptyVerb : deepverb
sdesc = "empty"
verb = 'empty'
ioAction( onPrep ) = 'EmptyOn'
ioAction( inPrep ) = 'EmptyIn'
ioAction( inPrep ) = 'EmptyInto'
doAction = 'Empty'
;
