Jump to content

Online creation

Add links
From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by Young Zaphod (talk | contribs) at 17:08, 16 February 2006 (rv Unsubstantiated claims and vandalism by atari2600tim.). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

Online Creation (OLC, sometimes also referred to as Online Coding), 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 they typically require a restart in order 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", "customization"[1] and "immortal" features, or "online building".

Monster

The first publicly available mud that featured customization[2] of the game world was Monster and was released in November 1988[3] 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[4]

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. Later with TinyMuck (Stephen White), TinyMush (Larry Foard) and SMUG (Jim Aspnes and others) user free programming was added to the feature set.

The following is abridged from "Three's Unabridged Dictionary of Commands" by Chrysalis (1990). 

@chown <object>=<player>. Changes the ownership of an object.
@create <name> [=<cost>]. Creates a thing with the specified name.
@describe <object> [=<description>]. 
@dig <name>. Creates a new room 
@fail <object> [=<message>]. 
@find [name]. Displays the name and number ... whose name matches <name>.
@link <object>=<number>; @link <object>=here; @link <dir>|<room>=home. 
@lock <object>=<key>. 
@name <object>=<new name> [<password>]. Changes the name of <object>. 
@ofail <object> [=<message>]. 
@open <dir>[;<other dir>]* [=<number>]. 
@osuccess <object> [=<message>]. 
@set <object>=<flag>; @set <object>=!<flag>. Sets (or, with '!', unsets) 
@success <object> [=<message>]. 
@unlink <dir>; @unlink here. 
@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.

LPC

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[5] and was derived from TinyMud 1.5.2[6]. The project was handed to Lachesis with TinyMUCK 1.2[7] and the ability to do online programming in a language dubbed MUF, or MultiUser Forth[8] 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 the MOO programming language and released as part of the LambdaCore database.

Interface information extracted from a LambdaCore help file (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.

The LambdaCore interface implemented:

  • The ability to build and describe rooms and exits as well as linking them together (@dig, @exits, @add-exit, @entrances, @add-entrance, @resident)
  • The ability to create, describe, manipulate, and destroy objects (@create, @recycle, @describe, @move, @rename, @messages, @lock, @unlock)
  • Security and auditing of user created rooms and object (@quota, @count, @audit, @classes, @realm)

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. COOL implemented a form of dynamic object inheritance. ColdMud and Genesis/ColdC were inspired by CoolMud.

It implemented a bulder interface that allowed:

  • The ability to view and modify COOL programs online (@methods, @prog, @list, @rmmethod, @spew)
  • The ability to create commands (verbs) and attach them to objects (@verbs, @verb, @rmverb)
  • Task control for running programs (@ps, @kill, eval)
  • The ability to create, view and manipulate objects (@create, @destroy, @rmvar, @show, @clone, @find, @teleport)
  • Creation of rooms and linking them together (@dig, @link, @open)
  • Modify the object inheritance tree online (@addparent, @rmparent)
  • set the security and visibility of objects (@addowner, @rmowner, @publish, @unpublish)

Armageddon Shop Room and Shop Creation Code

Limited distribution of Armageddon MUD included similar features for a variation of Dikumud written by Dan Brumleve (aka Acidion/Jhalavar) in April 92[9] and released in June 92[10]. Shop creation code was released in Oct 92 [11]. It was used on Armageddon's sister mud Artic[12] and found its way into Shine[13], Harshlands, Shadows of Isildur(source) and other Dikumuds.

It featured the following interface[14]: 

World Building
rname <room name>                             rlink <dir> <room number>
rlinkrm <dir>                                 rexit <dir> <room number>
rexitrm <dir>                                 rflags <flag>
rsector <sector>                              rcreate <room number>
rdesc                                         redesc <keywords>
rddesc <dir> <direction desc>                 rdkey <dir> <key>
rdoor <dir> <keywords>                        wsave
zsave <zone>                                  zclear <zone>
zreset <zone>                                 zname <zone name>
zset <zone> time|mode <value>

Object Creation
oname <obj> <object name>                     osdesc <obj> <object short desc>
oldesc <obj> <object long desc>               odesc <obj>
oedesc <obj> <keywords>                       oedescrm <obj> <keywords>
ocreate <object number>                       oset <obj> <field> <value>
otype <obj> <type>                            oaffect# <obj> <value> <mod>
oval# <obj> <value>                           osave <obj>
ocopy <obj> <obj>                             oeflags <obj> <extra flag>
owflags <obj> <wear flag>                   

NPC Creation
mname <mob> <mobile name>                     msdesc <mob> <mobile short desc>
mldesc <mob> <mobile long desc>               mdesc <mob>
mcreate <mobile number>                       mset <mob> <field> <value>
mdup <mob>                                    msave <mob>
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 [15] 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 Merc 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 1993. The original surviving co-author claims it was created before that although it can't be confirmed because the surviving authors did not have access to their own shell accounts, uploaded files to extinct services (grind.isca.uiowa.edu, for example), and were "allowed in" to certain other Unix account holder's accounts with careful pleading by Locke over other muds, such as Hidden Worlds and Nameless, both Mercs. According to claims made by its original author, it was initiated as early as 1991. Early versions were lost on a variety of MUD different unix machines, and distributed through ISCA's FTP archives. After 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 August of 1993[16] using Merc 2.1[17], they adapted it to Merc 2.2 after its release in October 13, 1993[18].

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

Quotes from The Isles original web documentation [19]: "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" "SEDIT" 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[20] for CircleMUD 3.0. It was derived from the iedit/redit snippet by Julian Fong aka Levork[21][22] written around June 1995 [23], 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 [24]

It supports the following command set[25]: 

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. It was announced in August 94. Further additions and bugfixes were done by Daniel Barron (aka Pharazon). Building was done through a command line interface similar to that of SMAUG (described below).

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

SMAUG Online Building

SMAUG's mset command.

SMAUG's online building was inspired by the online building system that was used by Mozart MUD, and was written completely from scratch over the course of the summer of 1994[citation needed] by Derek Snider (aka Thoric) for Realms of Despair. The first official public release of the SMAUG code was on December 16th, 1996 (version 1.01). Private beta releases were given out in November.

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, including editing and creation of rooms, objects, mobiles, resets, mudprograms/scripts (an extension of mobprograms), 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. [26]

See also

References

NiMUD OLC

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