n00b Writer
hop-o'-my-thumb
his own text adventure?
Max
news:Xns956C8B664F900ho...@129.250.170.85...
> What's the best piece of ( free ) software for a n00b looking to write
> his own text adventure?
Sorry about the length of this reply; I want to give you good advice.
Let me get in early, and make my recommendations, before the others put
silly thoughts in your head ;-).
Go for TADS or Inform. It means you have to learn to program, but it isn't
actually very difficult. If you go for ADRIFT (a graphical, supposedly easy,
design system) it'll be easier in the very beginning, but after a few weeks
(days?) in Inform or Tads, they'll be about the same, and eventually ADRIFT
will frustrate you (it is very limited when you try to do unusual things).
Don't go for ALAN or HUGO because their advantage over Inform is small, but
their disadvantage (mainly lack of a population to back them) is big.
Between Inform and TADS, it's more difficult. I like TADS, and the new Tads3
system is very powerful, without added complexity (unless you want to do
really advanced stuff). Inform's big plusses are twofold: it is the most
used language; and Graham Nelson's Inform Designer's Manual is a masterpiece
(I consult it at least once a month, even though I don't use Inform).
I went for TADS because the first IF (text adventure) I played was Ian
Finley's _Babel_, which was written in TADS. I really like it, and like I
said, Tads3 has some great features.
I would say you should go for Tads, too, but I wouldn't discourage Inform.
For more information:
inform: www.inform-fiction.org
tads: www.tads.org
--Max
Arfarfarf
I'm a noobie, just as you are; so, I'm coming into the Text Adventure way of
things from the beginning too.
But, I also program with C++ and Visual Basic.
TADS uses and follows the same (or similar to it) conventions that are used for
C / C++, which basically is Object Oriented Programming - in a squashed down
and bastardised meaning this translates to creating, designing, copying and
manipulating objects and details of the real world. (I'm certain that someone
would expand on this, but I don't want to go on about it too much - it'd seem a
bit wrong with me being a noobie to TADS myself.)
OOP is the bit that makes TADS a really great tool for designing Adventuring
systems, and after all my waffle about C/C++ and such, I would like to add my
ten penneth here, and advise you to learn a bit about objects (aswell as TADS
programming - very similar). Perhaps go and have a search on Google for Object
Oriented Programming, C++ Objects, or I'm sure someone on here could post you a
link to some useful information about it...
:-)
Or, perhaps someone would disagree with me entirely, in which case just ignore
me.
:)
M.D. Dollahite
>his own text adventure?
As has already been said, go for either TADS 3 or Inform. Don't let the fact
that TADS 3 is in beta scare you, it's pretty stable already, and the
"incompatible changes" warned about on the website usually require nothing more
than a find&replace.
The reason I recommend TADS 3 over Inform is twofold. First of all, TADS 3 has
a more powerful standard devkit, with modern features like sensory data
simulation and joined rooms, and a fully customizable parser. The second
reason is that based on the snippets of Inform code I've seen on this newsgroup
(I'll admit that I haven't actually read the manual, so I could be way off base
here), I'd say TADS has much simpler syntax. It looks like Inform is designed
like BASIC or Pascal, with hordes of different keywords and specialized syntax
patterns. There seem to be at least three different keywords just for
declaring a property of an object. TADS is closer to C/C++ or Java, having
only a minimal set of keywords and only a few reusable syntax patterns.
Defining object properties requires no keywords at all in TADS. Fewer keywords
and syntaxes means less to learn and remember.
Of course, if you're one of those people who's terrified of learning to program
(I swear it's not as hard you imagine it to be), then you might want to use
ADRIFT. Just don't expect to make anything sophisticated or original with it,
it's basically paint-by-numbers.
Kevin Lighton
> What's the best piece of ( free ) software for a n00b looking to write
> his own text adventure?
Try looking at Roger Firth's Cloak of Darkness page
(http://www.firthworks.com/roger/cloak/index.html) to look at the same
adventure written in several different IF languages (including the ones
that have been recommended in this thread) to see if one of them looks
more suited to you.
Ja, mata
--
Kevin Lighton lig...@bestweb.net or shin...@operamail.com
"I thought he was too arrogant to have an escape pod!" Vyse, _Skies of
Arcadia_
samwyse
>>What's the best piece of ( free ) software for a n00b looking to write
>>his own text adventure?
>
> a more powerful standard devkit, with modern features like sensory data
> simulation and joined rooms, and a fully customizable parser.
I like Inform over TADS, in part because it *isn't* as tightly
integrated a package. Inform actually has two components, the compiler
and the library. The compiler is somewhere between C and C++ in power,
and it compiles (by default) to the most widely ported virtual machine
in the world. The library isn't quite up to TADS (yet!) but you do have
a choice of other libraries if you so desire. The Platypus library is
two years old, but I think that it's closer to TADS in several respects.
Dave Bernazzani, OTOH, just announced a mini-library that's more
primitive, but is only about one-third the size of the standard library.
If you really want to stick with the standard library, then there are
also a lot of add-on packages for it.
> The second
> reason is that based on the snippets of Inform code I've seen on this newsgroup
> (I'll admit that I haven't actually read the manual, so I could be way off base
> here), I'd say TADS has much simpler syntax. It looks like Inform is designed
> like BASIC or Pascal, with hordes of different keywords and specialized syntax
> patterns. There seem to be at least three different keywords just for
> declaring a property of an object.
Gee, I only count two. ;-) They are 'has' for attributes (Boolean
flags) and 'with' for properties (scalar and array values). Personally,
I like the "hordes of different keywords". TADS programs are often
concise to the point that I'm unsure what's going on in the code that
I've read. IMHO, a few well-chosen keywords can make things a lot
clearer than struggling with line-noice like '@' and '+'.
> TADS is closer to C/C++ or Java, having
> only a minimal set of keywords and only a few reusable syntax patterns.
> Defining object properties requires no keywords at all in TADS. Fewer keywords
> and syntaxes means less to learn and remember.
Let's see, in TADS an object definition looks like this (copied from a
recent post):
closet: OutOfReach, Fixture, Booth 'closet' 'closet'
"It's just a little closet. "
canReachFromInside(obj, dest) {
return (!obj.isIn(self) || tryRemovingFromNested());
}
canObjReachContents(obj) {
return (gAction.ofKind(BoardAction)
|| obj.location == self
|| tryMovingIntoNested());
}
;
If I understand what the above is doing, then to do roughly the same
thing in Inform would look something like this:
Object closet "It's just a little closet. "
has
static container enterable,
with
name 'closet',
before [
Take:
if (IndirectlyContains(self,actor) &&
~~IndirectlyContains(self,noun))
"You can't reach it from in here.";
if (IndirectlyContains(self,noun) &&
~~IndirectlyContains(self,actor))
"You can't reach it from out there.";
rfalse;
];
The only keywords in the above are 'Object', 'has' and 'with', and maybe
'if' and 'rfalse', but both the TADS and Inform code make use of a large
number of subroutines, properties and attributes defined somewhere else.
LoneCleric
wrote:
> Don't go for ALAN or HUGO because their advantage over Inform is small,
> but
> their disadvantage (mainly lack of a population to back them) is big.
Lies, damn lies, and statistics. ;-) Seriously, I'd be very surprised if
there was even one single case of somebody deciding to use Hugo, but then
having to give up because his questions over here went unanswered. I'll
grant you that the documentation for Inform is awesome, though. I bought a
copy of the IDM just for the "general overview" sections.
> I went for TADS because the first IF (text adventure) I played was Ian
> Finley's _Babel_, which was written in TADS. I really like it, and like I
> said, Tads3 has some great features.
I went for Hugo because it looked like the underdog, and never regretted
it once. I also chose Hugo because Kent Tessman seemed like the most
reachable and dedicated engine maintainer, an opinion I'm still upholding
today. (Sorry Mr. Roberts!)
LC
David Whyld
"M.D. Dollahite" <ryu...@aol.comNOSPAM> wrote in message
news:20040922221037...@mb-m02.aol.com...
> >What's the best piece of ( free ) software for a n00b looking to write
>>his own text adventure?
>
> Of course, if you're one of those people who's terrified of learning to
> program
> (I swear it's not as hard you imagine it to be), then you might want to
> use
> ADRIFT. Just don't expect to make anything sophisticated or original with
> it,
> it's basically paint-by-numbers.
I'd disagree with that. Sophisticated and original games *can* be produced
with Adrift. Whether they are or not is down to the individual writing them.
I take it you're basing your experience on the actual writing of an Adrift
game as opposed to just reporting what other people have told you?
RootShell
> (http://www.firthworks.com/roger/cloak/index.html) to look at the same
> adventure written in several different IF languages (including the ones
> that have been recommended in this thread) to see if one of them looks
> more suited to you.
Kevin Lighton gave you the answer i would give you, im not a writer yet, but
having read the "Inform Designer Manual" and the "Inform for beginners" pdf
files, i will eventually stick with inform although TADS is growing in
features (particulary with TADS3).
But at Roger Firth's "Cloak of Darkness" website, you will get all the
information (about the most used authoring systems) and his personnal
opinion about each one.
Hope this helps,
RootShell
-=| Can you guess the name of ZXSpectrum games, just by seeing an ingame
screenshot? Find out at ZXSpectrum "Name The Game" - http://ntg.docaj.net
|=-
samwyse
>
> like BASIC or Pascal, with hordes of different keywords and specialized syntax
> patterns. There seem to be at least three different keywords just for
> declaring a property of an object.
I know I already replied to this once, but as I was looking for
something else I found this little gem in the Inform technical manual.
In it, Graham Nelson explains exactly how keywords are handled in
Inform, and why authors hardly ever have to worry about tripping over them.
=====
A "keyword" is an identifier which has a meaning understood by the
Inform compiler: for example the lexeme
while
is understood (in some contexts) to refer to the "while" statement,
rather than being a name coined by the programmer for some variable or
object.
In most small languages such a lexeme would always be a keyword and
never a name. (This is the concept of "reserved word": a word reserved
for the use of the compiler, forbidden as a name.) For example, the
fairly-large language C++ has 48 such keywords.
Inform is unable to reserve keywords (that is, forbid their use as
names) for two reasons: firstly, because there are 281 of the damn
things (and 116 of them are only significant in lines of assembly
language: why forbid the use of these to non-assembly-language
programmers?), and secondly because it is important to the language that
some keywords definitely should be the same as some object names.
"Class" is both a keyword meaning "the class-making directive" and a
name meaning "the object representing the class of all classes".
So the decision "is this identifier intended to be a keyword or intended
to be the name of something?" relies on the context. What the lexer
does is to divide the 281 keywords into twelve groups. The syntax
analyser switches these groups on or off as it finds its way through the
program. For example, the group "opcode_names" is only enabled (i.e.,
switched on) after an @ character has been read at the beginning of a
statement.
Roberto Grassi
>> Of course, if you're one of those people who's terrified of learning to
>> program (I swear it's not as hard you imagine it to be), then you might
>> want to use ADRIFT. Just don't expect to make anything sophisticated
>> or original with it, it's basically paint-by-numbers.
> I'd disagree with that. Sophisticated and original games *can* be produced
> with Adrift. Whether they are or not is down to the individual writing them.
> I take it you're basing your experience on the actual writing of an Adrift
> game as opposed to just reporting what other people have told you?
David, i agree with, you because i know what can be done with Adrift.
BUT, sadly, what people is asking here is an EVIDENCE that this can be
done.
Until an Adrift game will be 'sophisticated, original and complex' the
'average' IF player won't trust it by faith.
Rob
--
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG
Walter Sandsquish
<4151c...@news1.mweb.co.za>...
<< Don't go for ALAN or HUGO because their advantage over
Inform is small, but their disadvantage (mainly lack of a
population to back them) is big. >>
I don't you'll have any problems getting questions about
ALAN answered ...
Steve Breslin
> [I]n TADS an object definition looks like this (copied from a
> recent post):
[snip]
> If I understand what the above is doing, then to do roughly the same
> thing in Inform would look something like this:
[snip]
I wish I knew inform enough to comment intelligently on your
translation. But if this is an adequate translation, I say, "Wow, nice
job Inform!"
Instead, I'll comment part of the Tads-3 code you quoted, and you can
tell me:
closet: OutOfReach, Fixture, Booth 'closet' 'closet'
"It's just a little closet. "
canReachFromInside(obj, dest) {
/* if the object is not in the closet, return true:
* it can be reached.
* if the object is in self, execute an implicit
* command, which will try to exit the player from
* the nested room location.
* this implicit command will return true if the
* implicit move is a success, which we take to mean
* that the object can now be reached.
*/
return (!obj.isIn(self) || tryRemovingFromNested());
}
canObjReachContents(obj) {
return (gAction.ofKind(BoardAction)
|| obj.location == self
|| tryMovingIntoNested());
}
;
The implicit command will enact an intermediary action reported
parenthetically, thus:
>get widget
(first exiting the closet)
Taken.
>
P.S.: As you may have gathered, I've cleaned up the Tads-3 code for
this substantially in the meanwhile.
Steve Breslin
apologize and rectify:
closet: OutOfReach, Fixture, Booth 'closet' 'closet'
"It's just a little closet. "
/* This method checks the touch-path for an object
* (commonly, an Actor) touching another object,
* the dest (destination-object).
*/
canReachFromInside(obj, dest) {
/* The first check, !obj.isIn(self) is entirely
* unnecessary -- a dumb oversight of the author.
*
* if the object is in self, execute an implicit
* command, which will force the object to try
* exiting from the closet.
*
* this implicit command will return true if the
* implicit move is a success, which we take to mean
* that the destination-object can now be reached.
*/
return (!obj.isIn(self) || tryRemovingFromNested());
// better: return tryRemovingFromNested();
}
canObjReachContents(obj) {
return (gAction.ofKind(BoardAction)
|| obj.location == self
|| tryMovingIntoNested());
}
;
Again, I apologize; the avoidable ugliness in this code has since been
combed out.
M.D. Dollahite
>and the library.
Same as TADS.
>Gee, I only count two. ;-) They are 'has' for attributes (Boolean
>flags) and 'with' for properties (scalar and array values).
Alright, well that's still 2 keywords more than are needed.
>Personally,
>I like the "hordes of different keywords". TADS programs are often
>concise to the point that I'm unsure what's going on in the code that
>I've read.
That's because you're accustomed to everything having its own unique syntax,
thus you need the keywords to let you know which syntax rules are in effect.
When everything uses the same syntax rules, you don't need a zillion keywords
to follow the program.
But whereas the TADS code used only two syntax patterns (object defininition
and property definition), the Inform code uses about four different patterns
(object definition, "has" property definitions, "with" property definitions,
method definitions). And that's not even counting the procedural code inside
the methods.
You talk about having trouble following the code, even that little chunk of
Inform code has my head spinning trying to figure out what's going on.
In any case I'm not going argue the point. It's all subjective opinions
anyway.
samwyse
> Sorry, I simply butchered my initial comment of this code. Let me
> apologize and rectify:
No problem. I'm going to re-present my Inform version and describe what
it's doing. BTW, the TADS code I copied had the word 'closet' appearing
twice. I don't know if that was a typo, or something more subtle. Also,
after thinking about things a bit more, I'm not sure if the closet will
require a 'before' method, or a 'react_before' method. I'll use a
little trick to use the same code to handle both situations.
! This declares a closet to be an object.
! It is static (can't be taken by the player),
! a container, and enterable (by the player).
! It can be refered to by the word 'closet'.
Object closet "It's just a little closet. "
has
static container enterable,
with
name 'closet',
! This method potentially overrides the default
! behavior of an action.
before [ ;
! I am slightly changing the code from my post
! to handle a lot more actions.
Examine,Listen,Smell:
! These can be done at all times.
! (I'm assuming the closet is always open.)
rfalse;
default:
! In all other cases, if the actor is inside
! the closet and the noun isn't, complain.
if (IndirectlyContains(self,actor) &&
~~IndirectlyContains(self,noun))
"You can't reach it from in here.";
! if the actor isn't inside the closet
! and the noun is, complain as well.
if (IndirectlyContains(self,noun) &&
~~IndirectlyContains(self,actor))
"You can't reach it from out there.";
! Proceed to the default behavior.
rfalse;
],
react_before [ ;
! First time in, modify ourself to use
! the same code as the 'before' method.
self.react_before = self.before;
! And then invoke that code.
return self.before();
];