What can you do if you encounter a strange and interesting object, and you want to find out more about it? What if you want to find out who owns a particular object, or what commands work on a particular object?

This tutorial covers some of the most useful commands for finding out who's who and what's what here at Hippo.

The most basic way of getting information about an object is through the @examine command:

Syntax: @examine <object-name>

@examine <object-number>

This command gives you the following information:

* its full name, aliases, and object number

* its owner's name and object number

* its description

* its contents and their object numbers

* a list of the 'obvious' verbs defined on it

* its key expression (telling whether the object is locked and

if so, who can and cannot access it)

If you want to specify an object by name, it has to be either in the same room as you, or carried by you. Otherwise, you have to specify it by its object number.

To get the object number of a player, try the @who command.

For more about locks and keys, type `help locking'.

Try `@examine me' to see what sort of information can be gotten about you.

To find out what a mysterious object really is, you need to know what its parent is. The @parents command not only tells you the parent of an object, but gives a list of all the ancestors of the object.

Syntax: @parents <object-name>

@parents <object-number>

If you want to specify an object by name, it has to be either in the same room as you, or carried by you --- or here at Hippo, the name of a player. Otherwise, you have to specify it by its object number.

Try `@parents me' to find out your parentage.

Let's assume that you've developed a fertile object, and want to know how many instances have been created using this object as a parent. The command to list these objects is `@kids':

Syntax: @kids <object-name>

@kids <object-number>

As an example, the generic guest (#31) has as its children all the guest characters of Hippo Campus. To get a list of these characters, type

@kids #31

Warning: some objects have many, many children! Don't use this command unless you're sure of what you're doing.

You can display the contents of an object (for example, a room, a player, or a container) using the @contents command.

Syntax: @contents <object-name>

@contents <object-number>

To find out where an object is located, you can use the @location command.

Syntax: @location <object-name>

@location <object-number>

Strangely enough, in the current version of Hippo, @location allows you to specify players by name regardless of where they might be, but @contents does not.

Although of course programmers need to know how to found out what properties and verbs an object has, even non-programmers can sometimes benefit from this information. Knowing the verbs and properties can help you get a better understanding of what can be done with the object.

Two of the commands commonly available on MOOs are `@display' and `@show'.

The display command lists the verbs and properties of an object, in such a way that you can ask for any combination of properties and/or verbs, directly defined upon the object and/or inherited.

Syntax: @display <object>

@display <object>.[property]

,[inherited_property]

:[verb]

;[inherited_verb]

Examples: @display me

@display me.

@display vending machine.,

@display #0.:

If the object is readable by you, the @display command shows such information as the names and aliases of properties and verbs, their permissions, and their owners.

If a property is readable by you, @display also shows you its type and its value (unless it is a long string or list).

If a verb is readable by you, then @display shows you the types of direct object, preposition, and indirect object it expects.

A command which is similar to @display, but gives somewhat different information, is @show.

Syntax: @show <object>

@show <object>.<property-name>

@show <object>:<verb-name>

The `@show <object>' form of the command lists all the properties and verbs of the object.

Since @show gives the full value of all the properties, even long lists, the information displayed can run to many, many pages.

Use this command carefully!

Programmers, and other people brave enough to want to see the actual code listing of the verbs that make an object work, can use the @list command.

Syntax: @list <object>:<verb>

@list <object>:<verb> [with|without parentheses|numbers] [all]

@list <object>:<verb> <dobj> <prep> <iobj>

@list <object>:<verb> <start>..<end>

Although there are many options which you can use to get the listing of a verb, most non-programmers need only use the first form listed.

The best way to see how this works is on an example. Try the following:

@list me:look

Notice that even though the verb `look' was not defined directly on you, the @list command examined your ancestors to find the verb you inherit.

For a full description of the @list command and its various forms, type `help @list'.

Conscientious programmers have sometimes been known to provide `help' instructions for the verbs they write. These instructions are mainly to help other programmers figure out what is needed to use the verb, but sometimes they can be of use to non-programmers as well.

To see if a particular verb has any help associated with it, type

help <object>:<verb>

Although the commands discussed in this tutorial are some of the most useful commands used by programmers when developing their applications, there are many other useful commands available. You can get a listing of these commands by typing

help prog-index

This site is best viewed in 800 x 600, or 1024 x 768. If you find any faults in our page on certain browsers, please report them so we may fix the problem.

Copyright © NJO 2001.
For problems or questions regarding our site, contact our [WebMaster].
Last updated: August 25, 2001.