Misplaced Pages

Online creation: Difference between revisions

Article snapshot taken from Wikipedia with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.
Browse history interactively← Previous editNext edit →
Revision as of 01:20, 18 September 2006 editJlambert (talk | contribs)669 edits →EmlenMud's OLC← Previous edit Revision as of 22:19, 2 October 2006 edit undoJlambert (talk | contribs)669 edits rv - see talkNext edit →
(23 intermediate revisions by 6 users not shown)
(No difference)

Revision as of 22:19, 2 October 2006

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" and "immortal" features, or "online building".

Monster

The first publicly available mud that featured in-game creation of the game world was Monster and was released in November 1988 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

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> . Creates a thing with the specified name.
@describe <object> . 
@dig <name>. Creates a new room 
@fail <object> . 
@find . 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> . Changes the name of <object>. 
@ofail <object> . 
@open <dir>* . 
@osuccess <object> . 
@set <object>=<flag>; @set <object>=!<flag>. Sets (or, with '!', unsets) 
@success <object> . 
@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.

TinyMUCK

TinyMUCK 1.0 written by Stephen White was written and released sometime before Feb 1990 and was derived from TinyMud 1.5.2. The project was handed to Lachesis with TinyMUCK 1.2 and the ability to do online programming in a language dubbed MUF, or MultiUser Forth 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 ability to attach these programs to things, rooms and players (@action, @attach)
  • The ability to delete objects online (@recycle)

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.

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.

MOO and 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 on-line 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 builder 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)

Diku / Merc OLC

Diku and Merc MUDs were not packaged with an OLC. Instead, fans of the software created their own. The following is a list of influential OLCs, including the firsts, the most popular, and the most recent.

Armageddon On-line Creation Code

The first publicly available on-line creation add-on for Dikumud was written by Dan Brumleve (aka Acidion/Jhalavar) for Armageddon MUD in April 92 and released in June 92. Shop creation code was released in Oct 92 . It was used on Armageddon's sister mud Artic and found its way into Shine, Harshlands and Shadows of Isildur(source).

It featured the following interface: 

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's Mudlle

Mudlle is a language designed for writing extensions to MUME, a Diku-based MUD written in C. MUME stands for "Multi-Users in Middle Earth". Public archives have dated Mudlle around 1993, although it was not available during that year and has since been released with the original dates from the readme files intact. It had several 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, i.e. 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. It was written for Vego, a Diku-derived MUD server.

The Isles NiMUD's OLC

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

The Isles (also known as NiMUD) was written by authors Herb "Locke" Gilliland and Christopher "Surreal" Woodward. It was eventually released as a public package called NiMUD, containing the most widely distributed 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 project had started around the time of CthulhuMUD in August of 1993 using Merc 2.1, and was updated after Merc 2.2's release on November 24, 1993. It was later distributed to the public in 1994.

NiMUD OLC was publicly released in various stages of development from 1994 to 2006.

Selected quotes from The Isles original web documentation : "Instances are mobiles and objects that are copied out of the database, mass produced within the game, and are referential to originals, stored as entries in separate, type-specialized database entries which are indexed by vnums."

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

From the Immortal Reference or IMMREF (NiM5 Documentation): 

The Online Creation system, or Building System, provides immortals
with a method of extending the universe and adding to the game.
Online creation uses a series of editors to manipulate each
type of database  used in the game.  Most, if not all,
entries in the database have a Virtual Number or VNUM.  A VNUM
is a unique identifier which may be repeated across entity types;
for instance an actor may have the same Virtual Number as
a scene.
Help topics associated with OLC include the editors themselves:
AEDIT (legacy: MEDIT), SEDIT (legacy: REDIT), PEDIT (legacy: OEDIT), GEDIT,
ZEDIT, SPEDIT, SKEDIT, SCEDIT (For scripters, zone, spell/skill makers.)
As well as how-to documentation for the following topics:
Shopkeepers, Practitioners, Automatons, Questmaking, Aggressives
And finally, debugger tools: TRACE, DEBUG, TABLES, NOTIFY

The Isles OLC became the source work for derivatives such as Ivan's OLC, EnvyOLC, ROMolc and ILAB/OLC.

ILAB/OLC

ILAB OLC stands for I Love Amy Barr On-Line Creation and was an authorized port of NiMUD 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 be installed in many server distributions including Envy (Merc's sequel project), UltraEnvy, Greed, GodWars, Shadowgames, dystopia, Wurm, Tartarus, Anatolia, IceyDepths, Rogue, EmberMUD, ROM (MUD), RoT, Rogue, Mythran, Oblivion, SunderMud and many others. From this version came derivative add-ons EnvyOLC, ROMolc and Ivan's OLC.

EmlenMud's OLC

EmlenMud was written by Owen Emlen and is a derivative of the original NiMUD 1994 release that matched the ILAB/OLC release. It's date of public release is in 1996. The OLC in EmlenMUD is based on TheIsles OLC. There are slight changes in Emlen OLC. SPEDIT is now SEDIT, EDIT (for script code), SCRIPTEDIT (triggers that run scripts using mobs, objects, rooms, with certain commands like give, enter, leave). 

Examples of EmlenMUD OLC commands.
AEDIT - Area editor: aedit create would create a new area or an aedit while in an area
        would allow admins to edit that area or an aedit <area number> would allow 
        an admin to edit an area from anywhere on the mud. 
OEDIT - Object editor: oedit create <vnum>; A way to create an object in an area. 
        oedit <vnum> The commands to modify that object after it has been created.
OLOAD <vnum> load the object into either your inventory if flagged ''take'' or to the room.
MEDIT - Mob editor: medit create <vnum>; A way to create a mob in an area. medit <vnum> 
        The commands to modify that mob after it has been created.
MLOAD <vnum> loads the mob into the room but does not reset the mob in the room.
REDIT - Room editor: A room can be made in many different ways. redit create <vnum> 
        only creates a room, <direction> dig <vnum> will create the vnum number you 
        have chosen, create it, and also link it in the direction you specified. 
example: 
up dig 70
Room created.
Exit linked.
reset - this can be used to reset either mobs or objects.
Also includes:
ASAVE - has many options:
    asave changed  - saves all changed areas and spells/skills
    asave zone     - saves the area list and the area you're in
    asave world    - begins a background world save
    asave complete - begins a foreground world save
    asave list     - saves the area list
    asave clans    - saves all clans
    asave rand     - saves all random pops
    asave code     - saves all code labels
    asave triggers - saves all triggers
GEDIT - Guild editor
PEDIT - Player File editor
pset - Mini-version of PEDIT
sset - to set spells/skills on players or immortals sset all <player name> or 
       sset <spell/skill name> <player name>
NOTIFY - like Wiznet
DEBUG - script debugger

Sam's OLC

A version of OLC for CircleMUD was written and released in October of 1994, and seems to be the basis for the later package Oasis OLC written for CircleMUD 2.2 around the time CircleMUD 3.0 was being developed. It was referred to as Samedi's OLC by a fellow CircleMUD List poster and earned the nickname Sam's OLC by word of mouth. This version may be written under the pseudonym of Jeremy Elson , "Samedi". Contributions also by "Levork".

It implements the commands seen in the later release of Oasis OLC.

Select Citations (from CircleMUD List)

Oasis OLC

A screenshot of a OasisOLC session at ActsMUD - A room is being updated using redit

Oasis OLC was a repackaged, updated and derived work authored by Harvey Gilpin and released April 1996 for CircleMUD 3.0. It was built around the iedit/redit snippet by Julian Fong aka Levork written around June 1995 .

"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

It supports the following command set: 

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.

RoAOLC

A version of OLC for RoAMUD similar to Oasis and Sam . It includes a "quest editor" to generate rewards and quests and is written for Windows 32-bit.

Winterstar's OLC for Mozart

Ted Halmrast (aka Winterstar) originally wrote Mozart's online building code which 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 WinterStar's OLC for Mozart MUD, and was written 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 includes 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>                 - Merc 2.1 command
rpedit <command>  <program> <value> - mudprog roomprog editing
ocreate <vnum>  <item name>      - create a new object
oset <vnum|name> <field> <value>            - edit/set existing object (**)
opedit <vnum|name> <command>  <program> <value> - mudprog objprog editing
mcreate <vnum>  <mobile name>    - create a new mobile
mset <vnum|name> <field> <value>            - edit/set existing mobile (**)
mpedit <vnum|name> <command>  <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

DG scripts is a scripting language for building from Death's Gate MUD.

Valhalla VME and Dil Scripts

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

External links

References

NiMUD OLC