Jump to content

Online creation

Add links
From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by 68.162.148.34 (talk) at 01:36, 13 February 2006 (→‎CoolMUD). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

Online Creation (OLC), or Online Building is a feature of MUDs that allows users to edit world data while simultaneously playing the game. Referred to by the acronym "OLC" or "OC", this was a significant improvement for Dikumud variants, because older MUD-like games require a restart to implement any changes to the map or objects database. TinyMUD, LPMUD and MUSH, MUCK and MUX software are all similar in that they provide extensibility and customization live without rebooting the game server, but typically use other words to refer to their editors (though, some do call theirs OLC). Many refer to the power to create online as "wizard", "builder" and "immortal" features, or "online building".

Monster

The first publicly available mud that featured online creation of the game world was Monster and was released in November 1988[1] by Richard Skrenta.

"Monster allows players to do something that very few, if any, other games allow: the players themselves create the fantasy world as part of the game. Players can create objects, make locations, and set up puzzles for other players to solve. Game mechanisms allow players to:

  • Create and describe new objects and locations
  • Specify how game objects function
  • Provide text descriptions for events that may happen[2]

Monster was completely disk-based and modifications to the game were immediate. There were three types of game objects (rooms, exits and objects) which could be created and modified with the following command set: 

  Accept/Refuse #  Allow others to Link an exit here at direction # | Undo Accept
  Customize [#]    Customize this room | Customize exit # | Customize object #
  Describe [#]     Describe this room | Describe a feature (#) in detail
  Destroy #        Destroy an instance of object # (you must be holding it)
  Duplicate #      Make a duplicate of an already-created object.
  Form/Zap #       Form a new room with name # | Destroy room name (#)
  Link/Unlink #    Link/Unlink this room to/from another via exit at direction #
  Make #           Make a new object named #
  Relink           Move an exit
  Rooms            Show information about rooms you have made
  Show #           Show option # (type SHOW ? for a list)
  Unmake #         Remove the form definition of object #

Further modifications could done via the menu-based Customize command.

For rooms, the name, primary and secondary descriptions could be changed. A mystery message could be added to a room that would be displayed when a magic object was brought into a room by a player. Trapdoors could be created to bounce players to a named exit (triggered by a random chance) or for bouncing dropped objects to another room.

For exits, one could set multiple aliases (i.e. n|north|road) as well as extended descriptions. Player traversal of exits could be blocked or allowed if a magic object was defined on the exit. Success and failure messages for attempted traversal could be defined as well as the messages other players saw when a player entered or came out of an exit. Exits could be marked concealed and/or flagged as doors to require the player to attempt to open a door or search the room for concealed exits.

For objects, one could edit the description, the article to be used with it (i.e. 'a', 'an', 'some'), and an extended description shown upon closer examination. A magic object or magic room could be defined that would allow or prevent an object from being picked up or used unless inside a specific place. Like exits, success and failure messages could be defined for 'getting' or 'using' an object. An object's type could be set which allowed pre-programmed behavior.

TinyMUD

TinyMUD written by Jim Aspnes and released in December 1989 inspired a family of muds based entirely on the premise of allowing users to build online. TinyMUD was inspired by Monster[3]. Later with TinyMuck (Stephen White), TinyMush or MUSH (Larry Foard) and SMUG (Jim Aspnes and others) user free programming was added to the feature set.

The following is abridged from the public domain document, "Three's Unabridged Dictionary of Commands" by Chrysalis (May 31, 1990). 

@chown <object>=<player>. Changes the ownership of <object> to <player>.
@create <name> [=<cost>]. Creates a thing with the specified name.

@describe <object> [=<description>]. 
<object> can be a thing, player, exit, or room, specified as <name> or #<number> or 'me' or 'here'. 

@dig <name>. Creates a new room with the specified name and displays its number. 

@fail <object> [=<message>]. 
<object> can be a thing, player, exit, or room, specified as <name> or #<number> or 'me' or 'here'. 
Sets the fail message for <object>. The message is displayed when a player fails to use <object>.

@find [name]. Displays the name and number of every room, thing, or player that you control whose name matches <name>.
@link <object>=<number>; @link <object>=here; @link <dir>|<room>=home. Links <object> to room specified by <number>. 
For things and players, sets the home room. For rooms, sets the drop-to room. For exits, sets the target room.

@lock <object>=<key>. 
Locks <object> to a specific key(s). <object> can be specified as <name> or #<number>, or as 'me' or 'here'. 
Boolean expressions are allowed, using '&' (and), '|' (or), '!' (not), and parentheses ('(' and ')') for grouping. 

@name <object>=<new name> [<password>]. Changes the name of <object>. 
<object> can be a thing, player, exit, or room, specified as <name> or #<number> or 'me' or 'here'. 

@ofail <object> [=<message>]. 
The @ofail message, prefixed by the player's name, is shown to others when the player fails to use <object>. 

@open <dir>[;<other dir>]* [=<number>]. Creates an exit in the specified direction(s). 
If <number> is specified, it is linked to that room. Otherwise, it is created unlinked. 
You or anyone else may use the '@link' command to specify where the unlinked exit leads.

@osuccess <object> [=<message>]. 
The @osuccess message, prefixed by the player's name, is shown to others when the player successfully uses <object>.

@set <object>=<flag>; @set <object>=!<flag>. Sets (or, with '!', unsets) <flag> on <object>. 

@success <object> [=<message>]. 
Sets the success message for <object>. The message is displayed when a player successfully uses <object>. 

@unlink <dir>; @unlink here. Removes the link on the exit in the specified direction, or removes the drop-to on the room. 
Unlinked exits may be picked up and dropped elsewhere. 

@unlock <object>. Removes the lock on <object>.

These were the core building commands available on TinyMUD and remain quite similar to those used on later derivatives of TinyMUD.

LPMud

LPMud (sometimes shortened to simply "LP") is a MUD variant developed in 1989 by Lars Pensjö that separates the mud game functionality between a virtual machine (known as the driver) and world-building components in the LPC programming language (known as the mudlib). This distinction is similar to the distinction between the video game engine and the content the engine delivers (or drives).

Lars had been an avid player of TinyMUD and AberMUD. He wanted to create a world with the flexibility of TinyMUD and the power of AberMUD, Furthermore, he did not want to have sole responsibility for creating and maintaining the game world.

TinyMUSH

File:Mushlogin.JPG
The login screen from M*U*S*H, the centre of development for PennMUSH.

A MUSH (sometimes said to be an abbreviation for Multi-User Shared Hack, Habitat, Holodeck, or Hallucination, though these are backronyms) is a text-based online social medium to which multiple users are connected at the same time. MUSH are often used for online social intercourse and role-playing games, although the first forms of MUSH do not appear to be coded specifically to implement gaming activity. Today's two major MUSH variants are descended from TinyMUD, which was fundamentally a social game.

A primary feature of MUSH codebases that tends to distinguish it from other multi-user environments is the ability, by default, of any player to extend the world by creating new rooms or objects and specifying their behavior in the MUSH's internal scripting language.

One well known and successful MUSH was DuneMUSH based on MUSH variant PennMUSH.

TinyMUCK

TinyMUCK 1.0 written by Stephen White was written and released sometime before Feb 1990[4] and was derived from TinyMud 1.5.2[5]. The project was handed to Lachesis with TinyMUCK 1.2[6] and the ability to do online programming in a language dubbed MUF, or MultiUser Forth[7] was added.

TinyMUCK added the following features to the TinyMUD online building interface:

  • The ability to write and modify MUF programs online (@prog, @edit, @list)
  • The abilty to attach these programs to things, rooms and players (@action, @attach)
  • The ability to delete objects online (@recycle)

LambdaMOO

The first public release of LambdaMOO was in February 1991 by Pavel Curtis. LambdaMOO was based on MOO authored by Stephen White and started around May 1990. The LambdaMOO online building interface was written in MOO_programming_language and released as part of the LambdaCore database.

Interface information extracted from a LambdaCore help file (dated June 92)

The primary means for players to extend the MOO is for them to create new objects with interesting behavior. There are convenient commands for creating and recycling objects and for keeping track of the objects you've created. 

@dig -- conveniently building new rooms and exits
@create -- making other kinds of objects
@recycle -- destroying objects you no longer want
@quota -- determining how many more objects you can build
@count -- determining how many objects you already own
@audit -- listing all of your objects
@classes -- listing all of the public classes available for your use
@realm -- listing the parenting tree for objects owned by one or more players
@move -- moving your objects from place to place
@dig -- creating new rooms and exits
@add-exit -- adding other players' exits from your rooms
@add-entrance -- adding other player's entrances to your rooms
@exits -- listing all of the conventional exits from your rooms
@entrances -- listing all of the conventional entrances to your rooms
@resident -- listing or changing the residents of your rooms
@rename -- setting the name and aliases of your objects
@describe -- setting what others see when they look at your objects
@messages -- listing and setting the other descriptive texts on an object
@lock -- setting a lock on an object
@unlock -- clearing the lock on an object

CoolMUD Builder Interface

CoolMUD was an original mud also authored by Stephen White and was released in September 1992. It featured an online building interface written entirely in a language called COOL. Stephen White was also the author of MOO, and CoolMUD is often dubbed MOO-2 considering the similarities in many of the commands.

The following is the builder's interface as documented in "Builder Command Guide for CoolMud" by Jon Lambert aka Tyche: 

@addo*wner <player> on | to | onto <objnum>  Adds player to the owner list for the given object. 
@addp*arent <objnum> on | to | onto <objnum> Gives an object an additional parent.
@clone <objnum> named <name> Creates a new child of an object and names it.
@create <objnum> Creates a brand new object.
@destroy <objnum> Destroys an object completely.
@dig <room name> Creates a room with the assign name.
@find <text>    Finds objects by searching the name property.
@link <exit> to <exit> Builds easy two-way links.
@list <method> on <objnum> Shows the methods code.
@open <text> to <room objnum> Creates an exit named <text> to a particular room number.  
Semi-colons multiple keywords to be used to refer to a single exit. 
@methods <obj> Lists the methods on an object
@mutate <objnum> to | into <objnum>  ***experimental*** attempt to morph objects.
@nick*name <objnum> is | as | to <text> Sets up a nickname for an object. Nicknames are referenced via the '!name' syntax.
@pub*lish|@unpub*lish Commands to make objects public or private.
@rmp*arent <object number> from | on | to | onto <object number> Remove a parent from an object.
@rmo*wner <object number> from | on | to | onto <object number>  Remove an owner from the object.
@show <objnum> Shows all the properties of an object.
@spew <methodname> on <objectnum> Shows the method code in tokenized form.
@tel*eport <object> to <room>  Moves objects directly to rooms.
@ve*rbs <obj> Shows all verbs on an object

Armageddon OLC

A privately distributed online building add-on for Dikumud was written by Dan Brumleve (aka Acidion/Jhalavar) for Armageddon MUD in April 92[8] and released in June 92[9]. Shop creation code was released in Oct 92 [10]. It was used on Armageddon's sister mud Artic[11] and found its way into Shine[12], Harshlands, Shadows of Isildur(source) and other Dikumuds.

It featured the following interface[13]: 

World Building
RNAME (22) - "rname <room name>"                             RLINK (22) - "rlink <dir> <room number>"
RLINKRM (22) - "rlinkrm <dir>"                               REXIT (22) - "rexit <dir> <room number>"
REXITRM (22) - "rexitrm <dir>"                               RFLAGS (22) - "rflags <flag>"
RSECTOR (22) - "rsector <sector>"                            RCREATE (22) - "rcreate <room number>"
RDESC (22) - "rdesc"                                         REDESC (22) - "redesc <keywords>"
RDDESC (22) - "rddesc <dir> <direction desc>"                RDKEY (22) - "rdkey <dir> <key>"
RDOOR (22) - "rdoor <dir> <keywords>"                        WSAVE (22) - "wsave"
ZSAVE (22) - "zsave <zone>"                                  ZCLEAR (22) - "zclear <zone>"
ZRESET (22) - "zreset <zone>"                                ZNAME (22) - "zname <zone name>"
ZSET (22) - "zset <zone> time|mode <value>"

Object Creation
ONAME (22) - "oname <obj> <object name>"                     OSDESC (22) - "osdesc <obj> <object short desc>"
OLDESC (22) - "oldesc <obj> <object long desc>"              ODESC (22) - "odesc <obj>"
OEDESC (22) - "oedesc <obj> <keywords>"                      OEDESCRM (22) - "oedescrm <obj> <keywords>"
OCREATE (22) - "ocreate <object number>"                     OSET (22) - "oset <obj> <field> <value>"
OTYPE (22) - "otype <obj> <type>"                            OAFFECT (22) - "oaffect# <obj> <value> <mod>"
OVAL (22) - "oval# <obj> <value>"                            OSAVE (22) - "osave <obj>"
OCOPY (22) - "ocopy <obj> <obj>"                             OEFLAGS (22) - "oeflags <obj> <extra flag>"
OWFLAGS (22) - "owflags <obj> <wear flag>"                   

NPC Creation
MNAME (22) - "mname <mob> <mobile name>"                     MSDESC (22) - "msdesc <mob> <mobile short desc>"
MLDESC (22) - "mldesc <mob> <mobile long desc>"              MDESC (22) - "mdesc <mob>"
MCREATE (22) - "mcreate <mobile number>"                     MSET (22) - "mset <mob> <field> <value>"
MDUP (22) - "mdup <mob>"                                     MSAVE (22) - "msave <mob>"
MAFFECT (22) - maffect <mob> <affect>"

MUME

Mudlle is a language designed for writing extensions to MUME, a diku-based MUD written in C. MUME stands for "Multi-User Middle Earth", and originates with Shadows of Isildur [14] Public archives have dated Mudlle around 1993. It had several conflicting design aims:

  • It should be simple and small. This translates into a simple compiler/interpreter, less bugs, and faster availability.
  • It should be easy to use (within the MUME framework).
  • It should be safe, ie bugs in programs written by gods should not crash the game. They are likely to cause strange behaviour, but this is more or less unavoidable.

MUME's Mudlle is similar to LP's solution for scripted actions, specialized objects and simulations. It was one of the first hybrid building languages developed for Dikumud.

Hidden Worlds' Online Building

Hidden Worlds online building system was written for Merc 1.0 by Kalgen of Zebesta. It was used as inspiration for NiMUD's OLC system, which became a popular OLC for Diku.

The Isles NiMUD's OLC

File:Scripting.png
NiMUD's OLC scripting language.
NiMUD OLC's full-screen debugger.

The first publicly available OLC among Diku derivatives was initiated as a periodically updated open source software package under the names NiMUD or "The Isles MUD" by authors Herb "Locke" Gilliland and Christopher "Surreal" Woodward in 1992, though the first public disclosure on Usenet was in 1993. Development was delayed due to the 1992 release of Wolf3d. NiMUD's OLC was the basis for their first mud, CthulhuMUD, was hacked and vandalized only a few short days after the project was initiated. In the following weeks they began a project called NiMUD, which contained the first publicly available OLC for Merc/Diku MUDs.

NiMUD's OLC feature was inspired by the online building system of Hidden Worlds and was later enhanced with ideas from PennMUSH, the software on which DuneMUSH was built. Though the project had started around the time of CthulhuMUD in May of 1993 using Merc 2.1, they adapted it to Merc 2.2 after its release in October 13, 1993 [15].

NiMUD OLC was publicly released in various stages of development from 1993 to 2006 by Locke. Locke alleges earlier versions have been tampered with by MUD Distro site owners.

Quotes from The Isles original web documentation [16]: "The virtual locations, objects, players and creatures that you see are all contained in a set of seperate [sic] but inter-referencing databases that build the "rules" of the world beyond the game mechanics. Due to the complexity of this system, a set of universal terms has been developed over time to describe various values and references within the database and how they are used within the world. . . . It is important that you familiarize yourself with the terms defined below, they will be used throughout the remainder of the Guide and are frequently used when discussing projects with other builders . . . the most fundamental of these terms, the virtual number or vnum. A vnum refers to the index in the hash table that holds a single database entry. In other words, the vnum is a unique number that references a specific entry in the database. In each of the three seperate [sic] database that make up the majority of the virtual objects, vnums are unique and do not repeat. A vnum in one database might match the value of a vnum in another database, but within a single database a vnum is never repeated and references only one entry."

It was the first to implement "MEDIT" "REDIT" "OEDIT" and "AEDIT" commands.

The Isles OLC became the source work for derivatives such as Ivan's OLC, EnvyOLC, ROMolc and ILAB/OLC. It was the first complete packaged OLC add-on for Merc.

It has a relatively restrictive open source license compared to other editors and DikuMUD itself, because one needs to not only contact and inform the author before doing so, but also get authorization to distribute derivatives. Many open source variations have been made without authorization, but the surviving author has forgiven fans of the software for illegally porting his open source software. Other mud softwares pre-dating Diku have had elements of 'live editing' or 'live creation' of mud content. It was a multi-state gaming engine/editor hybrid, which provided a unique interface solution for editing mud content online while playing.

ILAB/OLC

ILAB OLC stands for I Love Amy Barr On-Line Creation and was a port of NiMUD OLC completed with permission from Herb Gilliland, surviving co-author of OLC, by Jason Dinkel. It was first released in December of 1994 for EnvyMud. ILAB OLC was derived from the OLC in The Isles 1.1 released in July 1994. The ease of its installation into Merc derivative muds led to it being ported to many servers including Envy, UltraEnvy, Greed, ROM, Rot, Rogue, Mythran, Oblivion, SunderMud and many others. From this version came EnvyOLC.

Oasis OLC

Oasis OLC was authored by Harvey Gilpin and released April 1996[17] for CircleMUD 3.0. It was derived from the iedit/redit snippet by Julian Fong aka Levork[18][19] written around June 1995 [20], which was an adaptation of similar features present in NiMUD OLC.[citation needed]

"Your Job as a Tinyworld Architect: Wow, you finally got your mud up and running, and now you want to create a world to fit all of those stories you have running around your head. As a Tinyworld Architect or builder, your job is to create areas for players to roam around in, solve puzzles, and gain experience. There is a world included with the CircleMUD distribution which is intended to serve as a stepping stone and a basic guide on what can be done with a world for your mud."

"Muds may have many different ways of coding things, but in general, most people tend to judge them on the number and quality of areas that they possess. The areas are what tend to make a mud original. For example, one mud could be based upon a magic-rich world and the code and areas would reflect this, while another could revolve around cities and thieves. Each of these muds would have its areas designed in such a way to flesh out this theme. In essence, building an area is like writing a book. It needs to have a plot, needs to be descriptive, and needs to be populated with memorable people and places." - from the CircleMUD 3.0 Builder's Guide [21]

It supports the following command set[22]: 

redit                           - edit the room you are standing in
redit <virtual room num>        - edit/create room
redit save <zone>               - save all the rooms in zone to disk
zedit                           - edit the zone info for the room you are standing in
zedit <virtual room num>        - edit the zone info for that room
zedit save <zone>               - save all the zone info for that zone to disk
zedit new <one>                 - IMPLs only - create a new zone.
oedit <virtual obj num>         - edit/create object
oedit save <zone>               - save all the objects in zone to disk
medit <virtual mob num>	      - edit/create mobile
medit save <zone>               - save all the mobiles in zone to disk
sedit <virtual shop num>        - edit/create shop
sedit save <zone>               - save all shops in zone to disk.
set <player name> olc <zone>    - IMPLs only - allow player to edit zone.
olc                             - List all the things that have been edited but not yet saved.

Valhalla VME and Dil Scripts

Ken Perry of Valhalla VME invented "Dil Scripts" for Valhalla (Diku2).

Mozart OLC

Ted Halmrast (aka Winterstar) originally wrote Mozart's online building code. Further additions and bugfixes were done by Daniel Barron (aka Pharazon).

The current Mozart OLC code is quite extensive, and includes LP-mud style scripting ability. The TeraMUD variation of the Mozart OLC code includes a full implementation of Javascript.

Building was done through a command line interface similar to that of SMAUG (described below, as SMAUG's interface was modeled loosely on Mozart's).

SMAUG Online Building

SMAUG's online building was inspired by (but contains no code from) the online building system that was used by Mozart MUD, and was written completely from scratch.

It was built upon the existing Merc 2.1 commands to set flags on objects (oset) and mobiles (mset) through allowing changes of object and mobiles to be reflected onto the index objects if a prototype flag is set. Room editing does not depend on this as there is only ever one instance of a particular room, but many instances of the same object or mobile.

SMAUG's online building system is quite extensive, allowing editing of nearly everything you could imagine, including editing and creation of rooms, objects, mobiles, resets, mudprograms/scripts, message boards, races, classes, spells, shops and more.

It supports the following command set: 

redit <field> <value> - edit the room you are in (*)
rset <vnum> <field> <value> - limited room setting ability carried over from Merc 2.1
rpedit <command> [number] <program> <value> - mudprog roomprog editing
ocreate <vnum> [copy vnum] <item name> - create a new object
oset <vnum|name> <field> <value> - edit/set existing object (**)
opedit <vnum|name> <command> [number] <program> <value> - mudprog objprog editing
mcreate <vnum> [copy vnum] <mobile name> - create a new mobile
mset <vnum|name> <field> <value> - edit/set existing mobile (**)
mpedit <vnum|name> <command> [number] <program> <value> - mudprog mobprog editing
aset <area file> <field> <value> - set area-wide settings
makeshop <mob vnum> - turn a mobile into a shopkeeper
shopset <mob vnum> <field> <value> - set shop settings
makerepair <mob vnum> - turn a mobile into a repairshop
repairset <mob vnum> <field> <value> - set repairshop settings
makeboard <board filename> - create a new message board
bset <board filename> <field> <value> - set message board settings
sset create skill 'name' - create a new skill or spell (or herb)
sset <sn> <field> <value> - set skill/spell/herb specific settings
(*) new rooms are created by using the goto <vnum> command to an unused vnum within the builders allowed range
(**) oset/mset can be used to edit live objects as well as prototypes based on a ''prototype'' flag

DG Scripts

A scripting language for building from Death's Gate MUD. [23]

See also

References

NiMUD OLC

TinyMUD

CoolMUD

Retrieved from "https://en.wikipedia.org/w/index.php?title=Online_creation&oldid=39425884"