define object <Cookbook>
properties <readable; read = 1>
end define

define object <Picture Book>
properties <readable; read = 2>
end define

have an array such as

set string <read[1]; lots of tasty recepies>
set string <read[2]; aww, a sweet little book for 3 yr olds>

in the game define block have a command

command <read #obj#> if property <#obj#;readable> then msg <#read[$objectproperty(#obj#;read)$]#> else msg <You cannot read #obj#>

set string <read[1];You read the book.|nIt says "one day in the distant future one man will come forth to rule the land and all who walks on it. This person will be...."|nWhat a load of bull!|n You flick through some of the pages and notice that there is something stuck inside! give <feather> |n you recieved the feather!>
It would start to get a bit stroppy about the "give <>" in there!
That's what I mean, certain things may happen if the different object's are read, the may change into other objects (also happens with "inspect/examine!". NOT with look!) I may want to change a variable or two, move the character somewhere for the storyline to continue, ect...
I was just wondering if there was a way that I could have a script somewhere in the define object block?

I'm going to scour the ASL-284 documents now!!

This would be a welcome part to the object definition in my opinion!

quote:

---

Alex.... couldn't you add this "read" feature just like the "look" and "examine" part of the define object?

This would be a welcome part to the object definition in my opinion!

---

Adding stuff like a read feature is easy to do yourself. There's a cut, paste and run demo of how I'd do it in this posting!

I'll modify this code and add it to my Quest 3 Extension library if anyone needs it.

This code gives the author a 'readable' type to use, defaults for those items that are NOT defined as type <readable> a default message for readable items, (which can be overridden on an object by object basis) and will even allow 'reading' an item to optionally run other ASL code if needed.

It makes use of Quest's 'type' and 'action' structures and I cranked it out in under 20 minutes so it may have a bug or two... but it should demonstrate my point O.K.

Here's the code - it might wrap so you'll need to use common sense:

quote:

---

' Quest 3 Template

' All sections must exist in the game, though the text sections may be empty
' if desired.

'!include <std.qlb>

define game <Test Bed>
asl-version <284>
game version <0.0a>
game author <Al Bampton>
game copyright <� 2001>
game info <This is a test bed intended to show how to add a read command.>
start <startroom>
command <read #object#> {
if property <#object#;readable> then {
doaction <#object#;read>
if not <$objectproperty(#objname#;readaction)$;nil> then {
doaction <#object#;readaction>
}
}
else {
msg <There's nothing to read!>
}
}
end define

define room <startroom>
look <This looks like a room ideal for starting an adventure from.>

define object <book>
look <it's a programming manual - how thrilling!>
prefix <a>
type <readable>
end define

define object <brick>
look <it's a brick - ho hum.>
prefix <a>
end define

define object <newspaper>
look <The Sun - Not great editorial but good pictures!>
prefix <a>
type <readable>
properties <readmessage=why read it, just look at the pictures!>
action <readaction> {
msg <|nYou can run any code you like (specific to reading the newspaper) here.>
}
end define

end define

define type <readable>
readable
readmessage = You start to read but it's so incredibly dull you decide not to bother.
readaction = nil
action <read> {
set string <objname;$thisobject$>
msg <$objectproperty(#objname#;readmessage)$>
}
end define

define text <intro>
Test
end define

define text <win>
Enter win text here...
end define

define text <lose>
Enter lose text here...
end define

---

Thats it - anyone feel this 'readable objects' code should be 'library-ised' and put into my forthcoming Quest Extension library please let me know. Any other suggestions will be listened to as well :-)

Al

All you really need is something like one if, check if it's got the property readable. Then doaction >#object#; read>!
Else <The #object# is not readable!>

Why all that extra complicated stuff?

quote:

---

I understand alot of it, but what is it with all this "nil" stuff?
All you really need is something like one if, check if it's got the property readable. Then doaction >#object#; read>!
Else <The #object# is not readable!>

Why all that extra complicated stuff?

---

It's there because the code doesn't just provide a message in response to 'read object.' The readaction=nil is a flag so that by default when an object is read only the 'readmessage' property is printed out.

If you provide an individual object with an action called 'readaction' then that will override the default 'readaction' (which does nothing) in the type definition.

If readaction is overridden then the code here will print out the readmessage appropriate to the object and then run the 'readaction' action provided by the author maybe that will open a door - causing dust to fly up - whatever.

Essentially this is providing both a simple 'read' message and optionally an action that is triggered by the reading. The 'readaction = nil' is thus the flag for this optional functionality.

I think that was what the original poster was after. :-)

Look at the newspaper section of the code and you'll see that it has a 'readaction' property - When you read the newspaper you'll find Quest prints out the readmessage and then the informational message

quote:

---

You can run any code you like (specific to reading the newspaper) here.

---

THAT is where you'd put whatever code you wanted to run when the newspaper is read.

Splitting it like this means one can control the two events of reading and action triggered by reading independently - useful in a general purpose piece of code.

I'd have just used:
command <read #object#> {
if here (#object#) or got (#object#) then {
if property (#object#; readable) then {
doaction (#object#; read) }
else msg <You can't read the #object#> }
else msg <You do not have/do not see the #object# anywhere!> }

But that's me I guess!

quote:

---

AAAAhhhhh!!!!
I see (barely!).
I guess I was confused with all the glittery new code !
I'd have just used:
command <read #object#> {
if here (#object#) or got (#object#) then {
if property (#object#; readable) then {
doaction (#object#; read) }
else msg <You can't read the #object#> }
else msg <You do not have/do not see the #object# anywhere!> }

But that's me I guess!

---

Not really all that different at all actually - my code is just re-worked to give the extra functionality of optionally allowing a piece of script to be run as well as printing the read message and providing a (useful?) default message or two that can be conveniently amended by the author just be setting a property in each object if he wishes to.

It's coded in this (slightly obscure) way because of my 'library minded' attitude to code of a general purpose nature. Were that code parcelled into my forthcoming library an author would simply need to include the library and to get a 'readable' object use:-

quote:

---

define object <tablet>
prefix <a stone>
type <scenery>
type <readable>
end define

---

(That type <scenery> is for something provided by my new q3ext library - ignore it for the moment.)

The 'tablet' object would automatically get the default 'boring to read' message and all other objects would get 'there's nothing to read' - with no further effort from the author. All other readable objects defined this way would benefit similarly.

Now if the author has several other 'boring to read' objects - but wanted this specific tablet to present a different message when read - he could add something like:-

quote:

---

properties <readmessage=It's in some form of sandscript - completely incomprehensible.>

---

To the code as shown above. That will override the message just for this object - others will still get the default as before.

Later in the game he might find a spell book, he could code that like so:-

quote:

---

define object <spellbook>
look <a dusty old volume>
type <readable>
properties <readmessage=You start to read the strange verses aloud...>
action <readaction> {
msg <|nThere is a huge flash of light - and you find yourself standing at the end of a mystical bridge.>
goto <bridge>
}
end define

---

This allows actions to be triggered by reading the object - and these can be controlled locally in the object definition so that the 'readable objects' code (which is written in a library) need never be changed. Again this extra functionality doesn't affect any other 'readable' objects defined - they still get default behaviour.

I mention in my Q2 tutorial how writing code for libraries tends to cause complications for the library author in order to provide ease of use for the library user, this is a good example of what I meant.

OTOH the author doesn't actually need to know how code actually works to use it and tailor it's behaviour, that is always one of the main aims of my libraries.

Discussing this 'readability' function has made me decide to rework it and build a 'readable' type into Q3EXT my Quest 3 Extension library - which is in beta at present.

!Include <Q3EXT.QLB> will therefore effectively add a READ command to Quest's armoury - amongst other goodies ;-)

I'll be waiting to get a look at that code :)

Your librarie's are always very vast in size!!! I'll have to pay more attention.

WAY back in this thread i mentioned I'd cooked up the code example for readable objects in twenty minutes and it might have bugs - perhaps I ought to have given it half an hour :-(

The code as given in this thread has an absolutely HUGE bug caused by sloppy coding on my part - the fact it 'seems to work' at all is purely good fortune.

Never mind - a debugged version that works properly is now in my extension library "q3ext.qlb", which I hope to make available very soon.

Al

I'll get VB6.0 installed soon...... that's a bit easier for me to understand!!! But right now, I've got to deal with my second HDD that is down to just 500-odd megs!

quote:

---

Well, it all seems WAY too complicated IMO!
.
.
.
My head hurts slightly as well, since I just got Visual C++ (6.0) and have been fooling around with it..... EEEERRRRRGGGGGHHHHHH!!!!

---

If you think my little bit of ASL is 'way to complicated' - you are going to HATE MS c++ 6 with a vengeance - nothing is easy to do in C++ anyway and the MS version of C++ seems (IMHO) to set out to make C++ - (which is horrible to learn anyway) as hard as possible to grasp.

I can write code using MS Visual C++, indeed I have to as part of my job, but using it is about as pleasant as having teeth extracted without anaesthetic. Personally unless I am actually forced to use it, I'd choose to use almost anything else in preference. Don't get me wrong, C++ is very very powerful, but unless you want to use it's low level power it is overkill.

If your garden is overrun with weeds a little gardeners flame gun does a good job, learning to fly a jet strike aircraft so you can carry out a precision napalm bomb strike on the garden is effective for sure - but probably a little over the top. I almost always find I can do 95% of coding jobs as effectively and much more quickly with something other than the 'big gun' of C++.

Off topic I know, sorry Alex!

Al

Yes, having a look at their "Hello World" programme..... YEEEESSHHH!!!
I won't be using MS C++ properly for some time!
But I got it so that I'd:
A. Be ready for college/Uni.
b. Get to fool around with something I like to do...... CREATE MINI-PROGRAMS!!!

Right now I've been trying to find out how do operate the button's, ect...

I'll just go and put my tail between my legs now :)