What is a meta-command?
Magnus Olsson
In the current debate about the "look" command, the term
"meta-command" is used liberally; people say that they think "look"
should be a meta-command, and so on.
As far as I can see, what most of the posters mean by this is that
"look" should be a "free action", i.e. the turn counter shouldn't be
incremented and daemons and timers shouldn't run after it.
But does this really make it a meta-command? To me, a meta-command is
one which is outside of the game world. To me, the action of looking,
whether it consumes a turn or not, is very much a part of the game,
unlike commands such as "save" or "verbose" which are commands to the
game-as-a-program.
I think we should distinguish meta-command from free actions, in the
following way:
A free action is an ordinary game command, having to do with the
player's interaction with the game world, that just doesn't happen to
take any time. The candidates I can think of right now are "look",
"inventory" and "what is a grue", though it can be argued that these
*should* take up time (see below). Free actions are affected by the
game state just as any other command, trapped by react_before (in
Inform) and so on.
Meta-commands are commands that are caught by the game's parser
*before* they affect (or are affected by) the game state. For example,
they are not trapped by react_before; the player can still save even
when in total darkness, and so on.
A role-playing analogy may help: a free action is something a player
does inside his role, that doesn't advance the clock. The role-playing
equivalent of a meta-command would be something like a player asking
the game master to clarify a rule.
Finally, I think it's a difficult question whether commands such as
'look' or 'inventory' should be free actions or not. Depending on the
context, the command 'look' may mean that the player examines his
surroundings in detail - which of course should take some time - or
just that he keeps looking around while doing other things.
In one case I can actually consider 'look' to be a meta-command in the
sense I've used the word above: viz. if the player is merely asking
the game to re-display the room description that just scrolled off the
screen, or which would have been displayed automatically if the player
hadn't typed 'brief' 10 turns ago.
--
Magnus Olsson (m...@df.lth.se, zeb...@pobox.com)
--- Not affiliated to Lund University or LTH ---
Daryl McCullough
Magnus Olsson wrote:
> To me, a meta-command is
> one which is outside of the game world. To me, the action of looking,
> whether it consumes a turn or not, is very much a part of the game,
> unlike commands such as "save" or "verbose" which are commands to the
> game-as-a-program.
I think it depends on what you think "look" means. If it means that
you want the character in the game to look, then I agree that it isn't
a metacommand. Alternatively, it can be thought of as a request to
be told what the character is seeing. In the latter case, the character
doesn't do anything special, but the command causes something to be
written on the computer screen, which makes it a metacommand.
"Inventory" can similarly be given two interpretations: do you mean
for the character to rummage through her sack and see what treasures
she has collected, or do you only mean for the computer screen to tell
you, the player, what is in your character's possession?
Daryl McCullough
CoGenTex, Inc.
Ithaca, NY
Andrew Plotkin
Magnus Olsson (m...@bartlet.df.lth.se) wrote:
> In the current debate about the "look" command, the term
> "meta-command" is used liberally; people say that they think "look"
> should be a meta-command, and so on.
> As far as I can see, what most of the posters mean by this is that
> "look" should be a "free action", i.e. the turn counter shouldn't be
> incremented and daemons and timers shouldn't run after it.
There's a reason for this assumption: In Inform, you turn off daemons and
timers (and each_turns) by putting the keyword "meta" in the grammar
line. Or setting the "meta" variable.
"meta" in Inform also prevents before/after actions from being run (which
is reasonable for "save" and "restore", and maybe less so for "look" as a
free action.)
I know you're just nitpicking the terminology, but I don't think it's a
huge deal. :)
> Finally, I think it's a difficult question whether commands such as
> 'look' or 'inventory' should be free actions or not. Depending on the
> context, the command 'look' may mean that the player examines his
> surroundings in detail - which of course should take some time - or
> just that he keeps looking around while doing other things.
> In one case I can actually consider 'look' to be a meta-command in the
> sense I've used the word above: viz. if the player is merely asking
> the game to re-display the room description that just scrolled off the
> screen, or which would have been displayed automatically if the player
> hadn't typed 'brief' 10 turns ago.
Contrariwise, I've seen (and written) scenes where "look" *was* supposed
to take a turn. This most often happens when something changes in the
room *without* a warning message, or with a warning message which just
says "Something seems different." (This can be very eerie when done
correctly. The player has to type "look" and read the text carefully --
because the protagonist is looking carefully around himself for whatever
it was that moved in his peripheral vision.) You can easily think of
scenes where stuff continues to happen as he looks.
--Z
--
"And Aholibamah bare Jeush, and Jaalam, and Korah: these were the
borogoves..."
Kathleen Fischer
Andrew Plotkin wrote:
> "meta" in Inform also prevents before/after actions from being run
Well that explains a bug a had a while ago :(
I couldn't figure out WHAT was going on, finally had to recode the whole
thing a different way -- which turned out to be a much better solution
anyway - but it was a very frustrating bug.
Kathleen (a little knowledge is a dangerous thing)
--
*******************************************************************
* Kathleen M. Fischer
* kfischer@x_greenhouse.llnl.gov (Remove the 'x_' before replying)
** "Don't stop to stomp ants while the elephants are stampeding" **
Magnus Olsson
In article <erkyrathE...@netcom.com>,
Andrew Plotkin <erky...@netcom.com> wrote:
>Magnus Olsson (m...@bartlet.df.lth.se) wrote:
>
>> In the current debate about the "look" command, the term
>> "meta-command" is used liberally; people say that they think "look"
>> should be a meta-command, and so on.
>
>> As far as I can see, what most of the posters mean by this is that
>> "look" should be a "free action", i.e. the turn counter shouldn't be
>> incremented and daemons and timers shouldn't run after it.
>
>There's a reason for this assumption: In Inform, you turn off daemons and
>timers (and each_turns) by putting the keyword "meta" in the grammar
>line. Or setting the "meta" variable.
>
>"meta" in Inform also prevents before/after actions from being run (which
>is reasonable for "save" and "restore", and maybe less so for "look" as a
>free action.)
Yes, and that's exactly why I think the distinction is important.
>I know you're just nitpicking the terminology, but I don't think it's a
>huge deal. :)
Actually, it's more than nitpicking. I think this scenario illustrates
my point:
| Medusa's Cave
| This cave is full of very life-like statues of adventurers in various
| poses. Medusa isn't here in person, though.
|
| > z
| Medusa enters the room behind your back.
|
| > look
| As your gaze falls upon Medusa's face, you turn to stone.
|
| *** You have died ***
In this example, "look" can be a free action, but it can't be a
meta-command, since in that case it wouldn't be caught by Medusa's
react_before.
To clarify my position, I'd like to propose that we have three types
of commands:
1) Ordinary commands.
2) Free action commands. Just like ordinary commands (so other objects
can react to it), except that the time counter doesn't advance, and
daemons and timers don't run after it.
3) Meta-commands. These are commands directed at the game-as-a-program
and affect only the way the player interacts with the program, not the
way the player _character_ interacts with the game world. In
particular, a meta-command (with the exception of "undo", "restore"
and "restart") does not change anything in the game world. You should
be able to insert a meta-command (except "undo", "restore" or
"restart") in the user-program-interaction without changing the
resulting game state.
>> Finally, I think it's a difficult question whether commands such as
>> 'look' or 'inventory' should be free actions or not. Depending on the
>> context, the command 'look' may mean that the player examines his
>> surroundings in detail - which of course should take some time - or
>> just that he keeps looking around while doing other things.
>Contrariwise, I've seen (and written) scenes where "look" *was* supposed
>to take a turn. This most often happens when something changes in the
>room *without* a warning message, or with a warning message which just
>says "Something seems different."
Thanks for providing an example - I was going to write this, but changed
my mind, thinking that it would seem to contrived and that nobody
would want to write such scenes anyway.
Joe and Bonnie Aultman
In article <5g76fv$4...@bartlet.df.lth.se>,
Magnus Olsson <m...@bartlet.df.lth.se> wrote:
>2) Free action commands. Just like ordinary commands (so other objects
>can react to it), except that the time counter doesn't advance, and
>daemons and timers don't run after it.
I've read this thread with interest and taken the opportunity to revisit
this issue in my head. I still retain, however, the possibly unpopular
opinion that there should be no free action commands.
I understand the reasons that people want them, but I think it's the
wrong approach. If the player does not remember the map well in her
head, and she has to type "LOOK" a lot, then she is playing an unobservant
character. It's an element that she herself has brought to the game.
If she wants to play an observant character, she should map the game
thoroughly.
A similar argument applies to the forgetful character and "INVENTORY."
Of course, the existence of "UNDO" and "RESTORE" muddies up the whole
situation, but I consider it the burden of the player to simulate an
observant character, if necessary, by applying them in the appropriate
circumstances.
That is all,
Joe
Julian Arnold
In article <5g6fqg$5...@bartlet.df.lth.se>, Magnus Olsson
<URL:mailto:m...@bartlet.df.lth.se> wrote:
>
>
> In the current debate about the "look" command, the term
> "meta-command" is used liberally; people say that they think "look"
> should be a meta-command, and so on.
>
> As far as I can see, what most of the posters mean by this is that
> "look" should be a "free action", i.e. the turn counter shouldn't be
> incremented and daemons and timers shouldn't run after it.
>
> one which is outside of the game world. To me, the action of looking,
> whether it consumes a turn or not, is very much a part of the game,
> unlike commands such as "save" or "verbose" which are commands to the
> game-as-a-program.
Yes, fair enough. My initial use of the phrase "meta command" was
because Inform uses meta to differentiate normal actions (GET, etc.)
from what I call "system" commands (SAVE, etc.). Perhaps foolishly I
thought that using Inform terminology would prevent this debate. :)
The thing is that Hugo/Inform have but two classes of command-- action
commands and meta commands in Inform, and verbs and xverbs in Hugo-- and
I was trying to stay within the boundaries of the two systems.
That said, I'm not convinced there is a need to differentiate between
"free actions" and "system commands." In fact, I have argued that LOOK
and INV should be "system commands," as they are to do with the player
and not the character (but I see your point that this is a matter of
context).
Excuse me for being hazy on Inform, but in Hugo at least xverbs (meta
commands) can be trapped by before/after rules, so if LOOK and INV were
xverbs they would have the same functionality as your free actions.
> Finally, I think it's a difficult question whether commands such as
> 'look' or 'inventory' should be free actions or not. Depending on the
> context, the command 'look' may mean that the player examines his
> surroundings in detail - which of course should take some time - or
> just that he keeps looking around while doing other things.
>
> In one case I can actually consider 'look' to be a meta-command in the
> sense I've used the word above: viz. if the player is merely asking
> the game to re-display the room description that just scrolled off the
> screen, or which would have been displayed automatically if the player
> hadn't typed 'brief' 10 turns ago.
OK, different contexts call for different interpretations. It's just
that ATM the default interpretation is that LOOK/INV are verbs, I think
the default should be that they are xverbs. And someone is bound to
soon say that this is nitpicking, and does it *really* matter. :)
I've had a similar problem in a game I work on sometimes, which
implements REMEBER/THINK ABOUT <object>. Do I say that this command
means "tell the player what the character knows about <object>" (in
which case it is an xverb) or that it means "the character pauses to
ponder/reminisce about <object>" (in which case it is a verb). Most
realistically, sometimes it should be the one, sometimes the other,
depending on context, but this is undesirable from the point of view of
the player (what do you mean I get run over while thinking about the
oncominmg traffic? THINK was an xverb just now!). As you might have
guessed, I eventually went the xverb route.
Jools
--
"For small erections may be finished by their first architects; grand
ones, true ones, ever leave the copestone to posterity. God keep me
from ever completing anything." -- Herman Melville, "Moby Dick"
Julian Arnold
>
> Contrariwise, I've seen (and written) scenes where "look" *was* supposed
> to take a turn. This most often happens when something changes in the
> room *without* a warning message, or with a warning message which just
> correctly. The player has to type "look" and read the text carefully --
> because the protagonist is looking carefully around himself for whatever
> it was that moved in his peripheral vision.) You can easily think of
> scenes where stuff continues to happen as he looks.
Yes, but if LOOK was meta then in the above situation the difference
would not be noticed with a casual look, rather an explicit EXAMINE
SURROUNDINGS/ROOM/ENVIRONMENT would be necessary.
Nulldogma
NKG wrote:
> Saying people like this are "unobservant" is either missing the point
or
> being somewhat snobbish. Therefore I feel it's to the game author's
> advantage to provide a handful of useful tools (eg: exits commands) that
> make life for the player easier.
I added an "exits" command (even though I would never use one myself, and
think it's awkward and intrusive) in version something-or-other of Lost
New York specifically because I knew my SO would never play it otherwise
-- she has no sense of compass directions, and kept getting lost and
frustrated in the opening scenes. I figured if she was frustrated, other
novices probably would be as well, so it was worth adding as an option.
(This is a "which way can I go?" exits command, BTW, not a "which way can
I go and where does it lead?" one.)
Neil
---------------------------------------------------------
Neil deMause ne...@echonyc.com
http://www.echonyc.com/~wham/neild.html
---------------------------------------------------------
Julian Arnold
In article <5g76fv$4...@bartlet.df.lth.se>, Magnus Olsson
> >Magnus Olsson (m...@bartlet.df.lth.se) wrote:
> >
> >"meta" in Inform also prevents before/after actions from being run (which
> >is reasonable for "save" and "restore", and maybe less so for "look" as a
> >free action.)
>
> Yes, and that's exactly why I think the distinction is important.
I've already replied to Magnus' first comment, so I'll keep this short.
The distinction may be important from an Inform-centric point of view.
However, Inform ~= IF. Hugo meta commands (xverbs) can be trapped by
before/after rules.
Jools, who isn't Inform-bashing, no really.
Andrew Plotkin
Julian Arnold (jo...@arnod.demon.co.uk) wrote:
> In article <5g76fv$4...@bartlet.df.lth.se>, Magnus Olsson
> <URL:mailto:m...@bartlet.df.lth.se> wrote:
> >
> > In article <erkyrathE...@netcom.com>,
> > Andrew Plotkin <erky...@netcom.com> wrote:
> > >Magnus Olsson (m...@bartlet.df.lth.se) wrote:
> > >
> > >"meta" in Inform also prevents before/after actions from being run (which
> > >is reasonable for "save" and "restore", and maybe less so for "look" as a
> > >free action.)
> >
> > Yes, and that's exactly why I think the distinction is important.
> I've already replied to Magnus' first comment, so I'll keep this short.
> The distinction may be important from an Inform-centric point of view.
> However, Inform ~= IF. Hugo meta commands (xverbs) can be trapped by
> before/after rules.
> Jools, who isn't Inform-bashing, no really.
Of course you're not, since you know quite well that this behavior is
part of the Inform libraries, and can easily be changed. :)
Florian Beck
m...@bartlet.df.lth.se (Magnus Olsson) writes:
> Actually, it's more than nitpicking. I think this scenario illustrates
> my point:
>
> | Medusa's Cave
> | This cave is full of very life-like statues of adventurers in various
> | poses. Medusa isn't here in person, though.
> |
> | > z
> | Medusa enters the room behind your back.
> |
> | > look
> | As your gaze falls upon Medusa's face, you turn to stone.
> |
> | *** You have died ***
>
> In this example, "look" can be a free action, but it can't be a
> meta-command, since in that case it wouldn't be caught by Medusa's
> react_before.
Hm, my point of view is quite different :-) I think *no* game-world command
can ever be a free action. But look *can* be a meta command.
In most games, every action takes one turn, no matter whether the
player looks or reads a book. Thats not realistic of course, but the
author has to decide if its worth the effort to distinguish short
actions from long ones. Looking around may take a few seconds. Even
glancing through a book will take half an hour. Only, in many games
that does not matter.
Strictly speaking, there is no free action in the game world.
What "look" really is, is an ambiguous command. It can *either* be a
(little) time consuming action of the *character* *or* it can be
command the *player* types to get, perhaps repeatedly, information on
the state of the game.
[In graphical games, BTW, this is not a problem. Perhaps, I-text-F
could simulate this by displaying the room description continuously,
e.g. in the status "line"?]
It's not clear if the room descriptions are objective (as in theatre)
or subjective and thus depending on character (as in a first person
novel). It can be either, though hardly both ways. I'd say, the
author decides.
>
> To clarify my position, I'd like to propose that we have three types
> of commands:
>
> 1) Ordinary commands.
>
> 2) Free action commands. Just like ordinary commands (so other objects
> can react to it), except that the time counter doesn't advance, and
> daemons and timers don't run after it.
This could work, in practice, if you just want to distinguish between
action that take very little time from those who take substantial
time. But where's the border? Look? Inventory? (will take some time,
think of containers) What's with e.g. look at <enemy>? Smell <enemy>?
A glance at your watch? How much time does it take to try to go into a
direction without door?
--
Flo
Esa A E Peuha
Julian Arnold (jo...@arnod.demon.co.uk) wrote:
: OK, different contexts call for different interpretations. It's just
: that ATM the default interpretation is that LOOK/INV are verbs, I think
: the default should be that they are xverbs. And someone is bound to
: soon say that this is nitpicking, and does it *really* matter. :)
: I've had a similar problem in a game I work on sometimes, which
: implements REMEBER/THINK ABOUT <object>. Do I say that this command
: means "tell the player what the character knows about <object>" (in
: which case it is an xverb) or that it means "the character pauses to
: ponder/reminisce about <object>" (in which case it is a verb). Most
: realistically, sometimes it should be the one, sometimes the other,
: depending on context, but this is undesirable from the point of view of
: the player (what do you mean I get run over while thinking about the
: oncominmg traffic? THINK was an xverb just now!). As you might have
: guessed, I eventually went the xverb route.
Why not make these truly different commands? For example, typing LOOK
would make the character actually carefully examine everything inside the
room, while typing XLOOK would just print the normal description of the
room (of course, XLOOK may not be the best name for this command).
Similarly, there would be THINK/XTHINK etc. (but what would be the
difference between INV and XINV? :-)
--
Esa Peuha
student of mathematics at the University of Helsinki
http://www.helsinki.fi/~peuha/
Magnus Olsson
In article <ant13123...@arnod.demon.co.uk>,
Julian Arnold <jo...@arnod.demon.co.uk> wrote:
>In article <5g76fv$4...@bartlet.df.lth.se>, Magnus Olsson
><URL:mailto:m...@bartlet.df.lth.se> wrote:
>>
>> In article <erkyrathE...@netcom.com>,
>> Andrew Plotkin <erky...@netcom.com> wrote:
>> >Magnus Olsson (m...@bartlet.df.lth.se) wrote:
>> >
>> >"meta" in Inform also prevents before/after actions from being run (which
>> >is reasonable for "save" and "restore", and maybe less so for "look" as a
>> >free action.)
>>
>> Yes, and that's exactly why I think the distinction is important.
>
>I've already replied to Magnus' first comment, so I'll keep this short.
>
>The distinction may be important from an Inform-centric point of view.
This is certainly the first time anybody's called me "Inform-centric" :-).
>However, Inform ~= IF.
Of course. I think my distinction ordinary actions / free actions / metaactions
holds for all IF, and should be kept separate from implementation issues.
In fact, the reason I brought this issue up at all was that I sensed a risk for
confusion between terminologies: there's in itself nothing wrong in calling
a "free action" a "metacommand"; but when people start assuming that they
should use Inform's "meta-verb" construct to implement them there's risk
for confusion.
>Hugo meta commands (xverbs) can be trapped by
>before/after rules.
IIRC, TADS has a "meta-verb" construct taht is used for "real" meta-verbs
such as "save" and "undo", but which should not be used for free actions
- such verbs should simply call abort or something like that to prevent
daemons and fuses from running (since the turn counter in TADS is a daemon,
that will also mean that the command doesn't take any game time).
Julian Arnold
>
> Julian Arnold (jo...@arnod.demon.co.uk) wrote:
> > In article <5g76fv$4...@bartlet.df.lth.se>, Magnus Olsson
> > <URL:mailto:m...@bartlet.df.lth.se> wrote:
> > >
> > > In article <erkyrathE...@netcom.com>,
> > > Andrew Plotkin <erky...@netcom.com> wrote:
> > > >Magnus Olsson (m...@bartlet.df.lth.se) wrote:
> > > >
> > > >"meta" in Inform also prevents before/after actions from being run (which
> > > >is reasonable for "save" and "restore", and maybe less so for "look" as a
> > > >free action.)
> > >
> > > Yes, and that's exactly why I think the distinction is important.
>
> > I've already replied to Magnus' first comment, so I'll keep this short.
>
> > The distinction may be important from an Inform-centric point of view.
> > before/after rules.
>
>
> Of course you're not, since you know quite well that this behavior is
> part of the Inform libraries, and can easily be changed. :)
Hm, I feel a bit like I've been set up. :)
Anyway, no, I didn't know, but I'm not surprised. I don't know about
"easily" changed though. A search through parserm for "meta" turns up
the following in the before_action property of the InformLibrary object:
#IFTRUE Grammar__Version == 1;
if ((meta || BeforeRoutines()==false) && action<256)
{ indirect(#actions_table-->action); r = false;
}
else r = true;
#IFNOT;
if ((meta || BeforeRoutines()==false) && action<4096)
{ indirect(#actions_table-->action); r = false;
}
else r = true;
#ENDIF;
I assume this is the culprit, and you would remove the meta references
from the if statements?
Jools
Julian Arnold
In article <5gbhm7$c...@bartlet.df.lth.se>, Magnus Olsson
<URL:mailto:m...@bartlet.df.lth.se> wrote:
>
> This is certainly the first time anybody's called me "Inform-centric" :-).
>
> >However, Inform ~= IF.
>
> Of course. I think my distinction ordinary actions / free actions / metaactions
> holds for all IF, and should be kept separate from implementation issues.
>
> In fact, the reason I brought this issue up at all was that I sensed a risk for
> confusion between terminologies: there's in itself nothing wrong in calling
> a "free action" a "metacommand"; but when people start assuming that they
> should use Inform's "meta-verb" construct to implement them there's risk
> for confusion.
Yes, fair points. I wasn't meaning to imply that you were
Inform-centric (which would be an odd thing to accuse you of when your
last two games were both TADS, and you haven't, to my knowledge,
released a single Inform game).
> >Hugo meta commands (xverbs) can be trapped by
> >before/after rules.
>
> IIRC, TADS has a "meta-verb" construct taht is used for "real" meta-verbs
> such as "save" and "undo", but which should not be used for free actions
> - such verbs should simply call abort or something like that to prevent
> daemons and fuses from running (since the turn counter in TADS is a daemon,
> that will also mean that the command doesn't take any game time).
And as Andrew Plotkin points out, apparently Inform can be coerced into
behaving so that meta commands are essentially free actions.
Andrew Plotkin
Julian Arnold (jo...@arnod.demon.co.uk) wrote:
> > Of course you're not, since you know quite well that this behavior is
> > part of the Inform libraries, and can easily be changed. :)
> Hm, I feel a bit like I've been set up. :)
> Anyway, no, I didn't know, but I'm not surprised. I don't know about
> "easily" changed though. A search through parserm for "meta" turns up
> the following in the before_action property of the InformLibrary object:
> #IFTRUE Grammar__Version == 1;
> if ((meta || BeforeRoutines()==false) && action<256)
> { indirect(#actions_table-->action); r = false;
> }
> else r = true;
> #IFNOT;
> if ((meta || BeforeRoutines()==false) && action<4096)
> { indirect(#actions_table-->action); r = false;
> }
> else r = true;
> #ENDIF;
> I assume this is the culprit, and you would remove the meta references
> from the if statements?
Yes, that looks right.
The implementation of meta-verbs is entirely in the Inform library, along
with the rest of the Inform parser. The Inform *language* thinks "meta" is
just a bit which can be set in a word's dictionary entry.
If you want to have *three* classes of verbs (meta, free-action,
normal-action) things get a little more complicated. You'd have to add
another global variable, "freeaction", and set it by some test early in
the parsing process. Then go through the library and for each usage of
"meta", decide whether it should be "meta", "freeaction", or "meta ||
freeaction." I haven't done the work, here, but it wouldn't be a big
deal.
Note that the Inform library also makes another distinction for
"meta"-verbs: you can't order another character to do them. (No fair
typing "Floyd, save" or "Wizard, undo.") This restriction shouldn't apply
to free-action verbs.
Cardinal Teulbachs
pe...@cc.helsinki.fi (Esa A E Peuha) made so bold as to state:
>Why not make these truly different commands? For example, typing LOOK
>would make the character actually carefully examine everything inside the
>room, while typing XLOOK would just print the normal description of the
>room (of course, XLOOK may not be the best name for this command).
>Similarly, there would be THINK/XTHINK etc. (but what would be the
>difference between INV and XINV? :-)
You have no right to ruin a perfectly good argument with your silly
appeals to common sense, Esa. Please stop it.
--Cardinal T
I mean, what the hell kind of villain thwarts the hero's
progress with soup cans in the kitchen pantry?
--Russ Bryan
Are there any text games prominently featuring dinosaurs?
If not, does anyone besides me think it would be cool?
--Matthew Amster-Burton
"The axe bounces off Geoffrey's neck. Doh!"
--Graham Manson
"Bathroom? Yeah. Go through that door, on the end
of the hall, on your left." "Pardon?" "South twice,
than east." "Ah."
--Clyde "Fred" Sloniker
Cardinal Teulbachs
Julian Arnold <jo...@arnod.demon.co.uk> made so bold as to state:
>OK, different contexts call for different interpretations. It's just
>that ATM the default interpretation is that LOOK/INV are verbs, I think
>the default should be that they are xverbs. And someone is bound to
>soon say that this is nitpicking, and does it *really* matter. :)
This is nitpicking. Does it *really* matter?
But for what it's worth, I think LOOKing and INVing should always cost
the player. The player should, ideally and as a rule, be expected to
absorb the game text to the point of having it form a fairly clear and
precise imaginary picture in his mind. Granting that the literary
skills of authors can often make this difficult, still it seems to me
to be the IF *ideal* that both author and player should strive for in
their respective capacities. Free LOOKs and INVs just make for lazy
players, who begin to act a bit like speed-readers in that they start
to "scan" instead of really reading, and only seek out the little
tidbit of information they think they need at any given time, while
effectively ignoring the rest. It can be argued, of course, that the
penalty of using up a game-turn isn't generally all that punitive, but
the alternative--making such actions freebies--absolutely tells the
player that superficial attention to the game is not only permissible
but actively encouraged. That's the wrong message to send, in my view.
Iain Merrick
On Wed, 12 Mar 1997, Daryl McCullough wrote:
[snip]
> "Inventory" can similarly be given two interpretations: do you mean
> for the character to rummage through her sack and see what treasures
> she has collected, or do you only mean for the computer screen to tell
> you, the player, what is in your character's possession?
>
> Daryl McCullough
> CoGenTex, Inc.
> Ithaca, NY
This issue was brought forcibly to my attention in the endgame to
Jigsaw... (not, not _that_ endgame, the other one :)
Basically, there's a bunch of apes who like to mimic your actions: if
you push them, they push you back, and so on. I was quite amused to find
that when I did an inventory, the apes did a comical impression of
someone searching through their possessions; and, of course, when you
"look", the apes scan the horizon keenly.
Up until then I'd never thought of these commands as actual actions: I
guess I implicitly thought of them as "meta-commands". Still do, in
fact, but that's beside the point...
Iain Merrick
i...@dcs.st-and.ac.uk
David Glasser
In article <erkyrathE...@netcom.com>, erky...@netcom.com (Andrew
Plotkin) wrote:
> Magnus Olsson (m...@bartlet.df.lth.se) wrote:
>
> > In the current debate about the "look" command, the term
> > "meta-command" is used liberally; people say that they think "look"
> > should be a meta-command, and so on.
>
> > As far as I can see, what most of the posters mean by this is that
> > "look" should be a "free action", i.e. the turn counter shouldn't be
> > incremented and daemons and timers shouldn't run after it.
>
> There's a reason for this assumption: In Inform, you turn off daemons and
> timers (and each_turns) by putting the keyword "meta" in the grammar
> line. Or setting the "meta" variable.
>
> "meta" in Inform also prevents before/after actions from being run (which
> is reasonable for "save" and "restore", and maybe less so for "look" as a
> free action.)
>
> I know you're just nitpicking the terminology, but I don't think it's a
> huge deal. :)
>
>
> > Finally, I think it's a difficult question whether commands such as
> > 'look' or 'inventory' should be free actions or not. Depending on the
> > context, the command 'look' may mean that the player examines his
> > surroundings in detail - which of course should take some time - or
> > just that he keeps looking around while doing other things.
>
> > In one case I can actually consider 'look' to be a meta-command in the
> > sense I've used the word above: viz. if the player is merely asking
> > the game to re-display the room description that just scrolled off the
> > screen, or which would have been displayed automatically if the player
> > hadn't typed 'brief' 10 turns ago.
>
> Contrariwise, I've seen (and written) scenes where "look" *was* supposed
> to take a turn. This most often happens when something changes in the
> room *without* a warning message, or with a warning message which just
> says "Something seems different." (This can be very eerie when done
> correctly. The player has to type "look" and read the text carefully --
> because the protagonist is looking carefully around himself for whatever
> it was that moved in his peripheral vision.) You can easily think of
> scenes where stuff continues to happen as he looks.
>
Yes, and in fact, it can sometimes help the player if things change when
he LOOKS. For instance, in The Legend Lives!, in the supply room at TV,
the description of the room tells you if the guard is right outside.
Usually, I would type LOOK until it doesn't tell me about the guard.
However, if LOOK didn't take a turn, I'd have to go WAIT.LOOK WAIT.LOOK to
do the same thing.
> --Z
>
>
>
> --
>
> "And Aholibamah bare Jeush, and Jaalam, and Korah: these were the
> borogoves..."
David Glasser
dsgl...@hotmail.com
http://www.geocities.com/SoHo/6028/
Erik Hetzner
> If you want to have *three* classes of verbs (meta, free-action,
> normal-action) things get a little more complicated. You'd have to add
> another global variable, "freeaction", and set it by some test early in
> the parsing process. Then go through the library and for each usage of
> "meta", decide whether it should be "meta", "freeaction", or "meta ||
> freeaction." I haven't done the work, here, but it wouldn't be a big
> deal.
I don't think three classes of verbs are exactly what we want. What we're
dealing with here is a number of things (IMHO):
1. Time of action.
2. The player's v. the character's memory.
Text is harder to remember than sights. So the character would have an
easier time spotting slight changes in the landscape than the player has
noticing slight changes in the prose. So a game /ought/ to inform the
player for things along the lines of: `You notice something has changed.'
This is only fair. Which brings me to:
Perhaps the player's first `look' out to take a turn. Subsequent looks
within, say, 30 turns or three different rooms would be free. After that,
a look would take a turn again.
Of course, a player generally gets a `free' look when she enters a room.
Perhaps this ought to take time according to the same rules as above. If
the player has brief on, of course, they don't have to `pay' for looks
when the enter a room.
Even better would be to have a system where different commands took
different times -- so the first look might take 10-30 sec., depending on
the size of the room. Looks after might take less, or no time at all (as
it is just as if the player is recalling what the character had seen).
On the other hand, this is all rather complicated and bureaucratic.
> Note that the Inform library also makes another distinction for
> "meta"-verbs: you can't order another character to do them. (No fair
> typing "Floyd, save" or "Wizard, undo.") This restriction shouldn't apply
> to free-action verbs.
Of course, a command to another character should really take /two/ turns
-- one to tell the character what to do, and another for the character to
do it. But then the player should be free for that second turn to do what
they'd like, except to command the other character again, who would have
to be `busy'.
> --Z
--
Erik Hetzner | `I'm celebrating my love for you;
e...@uclink4.berkeley.edu | with a pint of beer and a new tattoo.'
Andrew Plotkin
Erik Hetzner (e...@uclink4.berkeley.edu) wrote:
> I don't think three classes of verbs are exactly what we want. What we're
> dealing with here is a number of things (IMHO):
> 1. Time of action.
> 2. The player's v. the character's memory.
> Text is harder to remember than sights. So the character would have an
> easier time spotting slight changes in the landscape than the player has
> noticing slight changes in the prose. So a game /ought/ to inform the
> player for things along the lines of: `You notice something has changed.'
This, I agree with.
> This is only fair. Which brings me to:
> Perhaps the player's first `look' out to take a turn. Subsequent looks
> within, say, 30 turns or three different rooms would be free. After that,
> a look would take a turn again.
At this point, the player probably can't *figure out* what's going on,
and decides that "look" either takes a turn or doesn't, at random.
:)
Julian Arnold
In article <5gavqn$2...@oravannahka.Helsinki.FI>, Esa A E Peuha> : OK, different contexts call for different interpretations. It's just
> : that ATM the default interpretation is that LOOK/INV are verbs, I think
> : the default should be that they are xverbs. And someone is bound to
> : soon say that this is nitpicking, and does it *really* matter. :)
>
> : implements REMEBER/THINK ABOUT <object>. Do I say that this command
> : means "tell the player what the character knows about <object>" (in
> : which case it is an xverb) or that it means "the character pauses to
> : ponder/reminisce about <object>" (in which case it is a verb). Most
> : realistically, sometimes it should be the one, sometimes the other,
> : depending on context, but this is undesirable from the point of view of
> : the player (what do you mean I get run over while thinking about the
> : oncominmg traffic? THINK was an xverb just now!). As you might have
> : guessed, I eventually went the xverb route.
>
> would make the character actually carefully examine everything inside the
> room, while typing XLOOK would just print the normal description of the
> room (of course, XLOOK may not be the best name for this command).
> Similarly, there would be THINK/XTHINK etc. (but what would be the
> difference between INV and XINV? :-)
Well, a similar system to LOOK/XLOOK has been used before. In Infocom's
"Suspect" for example (I think), you could LOOK (took 1 minute), SEARCH
(took, say, 5 minutes), or SEARCH CAREFULLY (took, say, 15 minutes).
I probably wouldn't use LOOK/XLOOK, as this system is already
effectively built into the standard grammar: player LOOKs to get a
normal room description, or EXAMINEs specific objects (forcing him to
specify objects is much better than having a single-word command which
does it all for him), or (optionally) SEARCHes (with specific objects a
further option).
As for THINK/XTHINK, hm... On the whole I think it's better to have
just one verb, even if sometimes this will inappropriately be meta when
it should be non-meta, or vice versa.
Julian Arnold
In article <5gdcsd$3...@chile.earthlink.net>, Cardinal Teulbachs
<URL:mailto:card...@earthlink.net> wrote:
>
> Julian Arnold <jo...@arnod.demon.co.uk> made so bold as to state:
>
> >that ATM the default interpretation is that LOOK/INV are verbs, I think
> >the default should be that they are xverbs. And someone is bound to
> >soon say that this is nitpicking, and does it *really* matter. :)
>
>
> But for what it's worth, I think LOOKing and INVing should always cost
> the player. The player should, ideally and as a rule, be expected to
> absorb the game text to the point of having it form a fairly clear and
> precise imaginary picture in his mind. Granting that the literary
> skills of authors can often make this difficult, still it seems to me
> to be the IF *ideal* that both author and player should strive for in
> their respective capacities. Free LOOKs and INVs just make for lazy
> players, who begin to act a bit like speed-readers in that they start
> to "scan" instead of really reading, and only seek out the little
> tidbit of information they think they need at any given time, while
> effectively ignoring the rest. It can be argued, of course, that the
> penalty of using up a game-turn isn't generally all that punitive, but
> the alternative--making such actions freebies--absolutely tells the
> player that superficial attention to the game is not only permissible
> but actively encouraged. That's the wrong message to send, in my view.
I dunno. People play IF because they want to read the text, surely.
However, as well as marvelling at that text they want to play a game.
The author is not compromising himself by providing facilities to ease
this part of the endeavour, such as free LOOKs and INVs, and an EXITS
command. Authors may have to suffer for their art, but I don't see why
players should.
Mark J Musante
Julian Arnold (jo...@arnod.demon.co.uk) wrote:
> Well, a similar system to LOOK/XLOOK has been used before. In Infocom's
> "Suspect" for example (I think), you could LOOK (took 1 minute), SEARCH
> (took, say, 5 minutes), or SEARCH CAREFULLY (took, say, 15 minutes).
Is this the only instance of an adverb in an IF game? I believe most games
just use nouns, verbs, adjectives and prepositions. Would adding adverbs
to the player's syntax help or hurt the gameplay?
>PUT VASE CAREFULLY ON THE CUSHION
>OPEN DOOR SLOWLY
>GO QUICKLY NORTH
>TURN DIAL GENTLY
- Mark
Mary K. Kuhner
>Perhaps the player's first `look' out to take a turn. Subsequent looks
>within, say, 30 turns or three different rooms would be free. After that,
>a look would take a turn again.
The player needs to know whether look will take a turn or not, because
in timed sequences this can be important. Two ugly cases are "I thought
look was free, but the monster ate me" and "I thought look took a turn,
and was using it to watch something change, but it never changed".
If look takes a turn or not according to a subtle, invisible algorithm,
the main effect will probably be annoying the player. You don't want
to draw attention to the mechanics this way.
I think either always free, or always taking a turn, is fine; but not
both in the same game. It's like playing with pronouns according to a
complex rule; if the player doesn't understand what the game is doing,
it's just a booby-trap.
Mary Kuhner mkku...@genetics.washington.edu
Nulldogma
Mark J Musante wrote:
> Is this the only instance of an adverb in an IF game? I believe most
games
> just use nouns, verbs, adjectives and prepositions. Would adding
adverbs
> to the player's syntax help or hurt the gameplay?
Ugh. Sounds to me like a recipe for nightmare "guess-the-adverb"
scenarios.
> >PUT VASE CAREFULLY ON THE CUSHION
> PUT VASE ON CUSHION
Oops! You clumsily throw the vase at the cushion, and it falls off and
breaks.
> SET VASE ON CUSHION
I don't know how to set the vase.
> PUT VASE GENTLY ON CUSHION
I don't know how to put anything gently.
> PUT VASE ON CUSHION WITH CARE
You don't see any care here.
> THROW VASE AT AUTHOR
Julian Arnold
In article <E76xC...@world.std.com>, Mark J Musante
<URL:mailto:olo...@world.std.com> wrote:
>
> Julian Arnold (jo...@arnod.demon.co.uk) wrote:
> > Well, a similar system to LOOK/XLOOK has been used before. In Infocom's
> > "Suspect" for example (I think), you could LOOK (took 1 minute), SEARCH
> > (took, say, 5 minutes), or SEARCH CAREFULLY (took, say, 15 minutes).
>
> just use nouns, verbs, adjectives and prepositions. Would adding adverbs
> to the player's syntax help or hurt the gameplay?
>
> >GO QUICKLY NORTH
> >TURN DIAL GENTLY
I've seen them in other (non-Infocom) games. ISTR "The Hobbit" used
them? Maybe.
In general though, I think they'd be unuseful at best, a downright
hindrance at worst. Imagine all those horrible "guess the adverb"
puzzles: "But I went east cautiously!" "No, you go east surreptitiously,
then north cautiously, and finally take a sneaky inventory and slyly
throw the gooblet at Kenneth."
Erik Hetzner
> > Perhaps the player's first `look' out to take a turn. Subsequent looks
> > within, say, 30 turns or three different rooms would be free. After that,
> > a look would take a turn again.
>
> At this point, the player probably can't *figure out* what's going on,
> and decides that "look" either takes a turn or doesn't, at random.
>
> :)
Yes, but what sort of person actually /cares/ how many turns they finish
the game in? Or even checks to see how many they've taken? :) The only
time I ever look at the time or turns is when something bad happens
because I took too long.
Cardinal Teulbachs
Julian Arnold <jo...@arnod.demon.co.uk> made so bold as to state:
>I dunno. People play IF because they want to read the text, surely.
>However, as well as marvelling at that text they want to play a game.
>The author is not compromising himself by providing facilities to ease
>this part of the endeavour, such as free LOOKs and INVs, and an EXITS
>command. Authors may have to suffer for their art, but I don't see why
>players should.
In my case, I think the art has to suffer the artist :)
Anyway, I'll have to agree with you after all. The player's attention
shouldn't have to be demanded. It's the author's responsibility to
catch it and hold it. I'll bet a study would show that the best games
have recorded proportionately fewer LOOKs and INVs than the lesser
ones due to greater interest and involvement on the part of the
player. But that should be scored as the author's accomplishment, not
the game system's.
Andrew Plotkin
Erik Hetzner (e...@uclink4.berkeley.edu) wrote:
> In article <erkyrathE...@netcom.com>, erky...@netcom.com (Andrew
> Plotkin) wrote:
> > > Perhaps the player's first `look' out to take a turn. Subsequent looks
> > > within, say, 30 turns or three different rooms would be free. After that,
> > > a look would take a turn again.
> >
> > At this point, the player probably can't *figure out* what's going on,
> > and decides that "look" either takes a turn or doesn't, at random.
> >
> > :)
> Yes, but what sort of person actually /cares/ how many turns they finish
> the game in? Or even checks to see how many they've taken? :)
A person who has only three "turns" to unlock the door before the monster
eats him.
> The only
> time I ever look at the time or turns is when something bad happens
> because I took too long.
Exactly. If there's no time limit, it doesn't matter if "look" takes a
turn. If there is, then the player *will* care; and then, if he can't
figure out whether it will or not, he'll come after you with a rusty vase.
Joe Mason
"Re: What is a meta-comman", declared Mark J from the Vogon ship:
MJ>Is this the only instance of an adverb in an IF game? I believe most
MJ>games just use nouns, verbs, adjectives and prepositions. Would
MJ>adding adverbs to the player's syntax help or hurt the gameplay?
MJ>>PUT VASE CAREFULLY ON THE CUSHION
MJ>>OPEN DOOR SLOWLY
MJ>>GO QUICKLY NORTH
MJ>>TURN DIAL GENTLY
Hurt. Definitely hurt - it would be HELL to code! You'd have to either
think up every adjective appropriate to the situation (and I believe in
English there are many more adjective synonyms then for other types of
verbs) or have adjectives only matter in a few situations, when its
important to the puzzle. This would be unfair to the player, who
probably wouldn't realize you can USE an adjective, since it didn't seem
to make a difference anywhere else...
However, adding one particular adjective which is used often (ie. SEARCH
CAREFULLY) would probably be okay if it was documented - players would
soon stop thinking about it, much like INVENTORY (which really makes no
sense at all). It would still be better to think of a verb that could
do it on its own (ie. LOOK, INSPECT, SEARCH instead of LOOK, SEARCH,
SEARCH CAREFULLY).
Speaking of which, here's a suggested solution to the "free look"
problem: a "glance" verb, which does a LOOK without taking any time. Or
(at the author's option) gives an abbreviated description, just enough
to list exits and anything else that jumps out at the player. Forms
could include:
GLANCE AROUND
GLANCE
GL
GLANCE AT/IN/ON <object>
They'd parallel the "look" forms of each verb. The author need not give
an abbreviated description of anything he doesn't want to, but possible
"GLANCE AT" would take a full turn if no abbreviated desc is given (we
can't give too many things away free!)
Joe
Joe
ş CMPQwk 1.42 9550 şI am Porky Pig of Borg. Prepare to be assimi..asisim..to be a robot!