Misplaced Pages

Revision as of 01:18, 19 July 2005

Someone complemented the article this morning. To a subset of the online virtual community, this is a significant portion of this software's history, and is not considered a "plug" or "vanity page"

Hi there,

Welcome to Misplaced Pages! Misplaced Pages would love if you join, but you're welcome to edit anonymously if you wish.

Nice online creation article, but just look in the page history to see some changes I made to it, to bring it up to Misplaced Pages's style standards.

Anyway, thanks for joining, I hope you'll stay! If you need any help, just ask me on my talk page, or ask at the Village pump.

- user:zanimum

Down and Dirty in the MUD: OLC means Online Creation

Removed due to blatant advertisement.

Information about the origins of the first publically released OLC

Locke says, "Hi, how's it going. Here's my story."

In 1992 and 1993, Chris Woodward and I released the world's first publically available "online creation" software for Merc 2.1c; its original release occured in the form of a Merc derived codebase called "The Isles 1.5" and was uploaded to ftp.game.org in 1994. It was later ported under the popular package "ILAB/OLC" and is the basis for all Merc-derived MUD OLCs, despite what others claim. ILAB/OLC, ROMolc, OLC/2 and even SMAUG OLC are all derived from our work. Chris programmed the main features while I developed the interface, which we learned how to use on Hidden Worlds Diku and Zebesta, two excellent Merc-derived muds. Those were command-driven systems; it was Kalgen's editor which we liked so much we decided to first copy, then improve into what became Online Creation, OC or OLC.

Read about this historic event on wikipedia.

Back then the world of mudding was still a fairly small place; MUDs were a homegrown type of open source, available only to those who had access to terminal machines and supercomputers. At my height of mudding there were probably fewer mud in a list than you could hold on a floppy disk. I played my first MUDs on green-screen VAX terminals in the back of Ms. Zaitsoff's Computer Science class in high school. I even wrote a single player mud-like game for her class in Pascal for VAX/VMS. I was lucky enough to end my high school mudding career coding on Job's NextSTEP.

Although multiplayer gaming is a much broader topic, and has been around longer, the term 'Dikumud' and the world of Diku are still less than two decades old.

My first muds were Diku and Merc. I didn't know what a MUCK was until a few years later - and soon after I learned what a MUSH was. I've played countless muds, but I will never forget my first: Nameless MUD, some flash in the pan Merc that averaged 14 players. The agony at losing levels and being PK'd was a wonderful distraction from an otherwising boring late-highschool experience. I wasn't the quarterback or the prom king, but I definitely knew my way around the command 'backstab' and could rescue your corpse faster than you could gossip help.

After Nameless, it wasn't really the same until we discovered Hidden Worlds. At this point I had collected about 4-6 others and we would all sit in the back on our VAX terminals and agonize through hours of play. In Nimud some of my real-life mudding friends are immortalized in the socials that come predefined in the mud. This is directly related to why I didn't write a socials editor - I was afraid someone might change those oh-so-important memories. When I would get home from high school I would mud for hours and hours, sometimes days at a time during the summer months, because it made BBSes a thing of the past and flame wars a complete bore. One of my BBS friends, Chris, came along for the ride.

It's only a matter of time before a mudder decides to either quit mudding or move on to the next level: immortality. I never immorted on Nameless: the mud wasn't around long enough for me to and there was no incentive, but on Hidden Worlds, immortality was a key feature of the rewards system. We had heard rumors that once you became an immortal, you were given a chance to give back to the game and to the gaming community by building new areas and levels and that seemed really cool.

Well, as any mudder knows, it takes forever to become an immortal. After 26 levels (there were only 30 on HW) Chris and I discovered DuneMUSH and our perception of multi-user shared environments changed again. DuneMUSH, unlike Hidden Worlds or Nameless, was a complex political game between the 30 or so players who were always involved in an ongoing storyline. This is the first time I played a roleplaying game online and actually had experiences that I doubt anyone could recreate. The phone rang on Kaitain my character was caught up in political intrigue and assassination.

It was wonderful. Chris exploited features to gain attention, while I smoozed my way up the chain to get the solaris I needed for our RP 'business' - a detective agency for the Landsraad - when we quit after a dispute over "X-Ray Glasses" that Surreal had conjured up through a hole in one of the DuneMUSH functions. Once we had returned to our endeavors with The Isles, there was no turning back on OLC.

Aside from the online creation elements included in our software, Chris and I had many years of BBS programming experience and used some of the features from Telegard and Renegade in The Isles. One of these features was ANSI color support; our code was the first to support a limited version of the ANSI escape sequences. Our codes were simplified for use with terminals that already supported VT100; and are superior to stock ROM and Envy codes, as they are not simplified and have problems being translated through certain Unix clients, such as tintin and Tf. The most interest aspect of both OLC and ANSI, has been watching it propegate through Merc/Diku.

What happened to Nimud.org?

For long-time fans, you might be wondering 'what happened to nimud.org'? The answer: capitalism. Nimud.org was purchased when I tried to transfer it from Network Solutions to Godaddy. I was a little spammed to death and a bit broke at the time the domains came up for renewal, so when I went to renew nimud.org, it got auto-purchased by one of those companies that specializes in buying your old domain names, and then selling them back to you at a huge markup. This happened in the few days between Netsol's release of the domain and Godaddy's attempt to purchase it. Well, I refuse. Please feel free to commit haenous acts of DOS, prank calling or attracting spam to this site:

Domain ID:D104070209-LROR Domain Name:NIMUD.ORG

  Created 08-Mar-2004 19:35:14 UTC
  Last Updated 30-Dec-2004 23:17:19 UTC
  Expiration 08-Mar-2006 19:35:14 UTC
  Sponsoring Registrar:

Intercosmos Media Group Inc. (R48-LROR)

  Status:CLIENT DELETE PROHIBITED
  Status:CLIENT TRANSFER PROHIBITED
  Status:CLIENT UPDATE PROHIBITED
  Registrant ID:IMG-613898

Domain Purchase / NOLDC, Inc 838 Camp Street Apartment C New Orleans, LA 70130 US +1.5045230360 +1.5042740360 support@noldc.com

  Name Server:NS0.DIRECTNIC.COM
  Name Server:NS1.DIRECTNIC.COM

If you want to hear more about my friend "Chris" please visit his virtual shrine: Surreality

Remember muds, like this page, are hand-crafted.

2 changes on Jul 10, '05

I see no justification on the talk page for this change, so I am replacing the Hidden Worlds reference and making it more accurate. I researched it first, and found info here, where the author says:

1992: MUDs 
A discovery which grew from the BBS hobby, I waltzed into MUDDING in 1992 as a
programming student at Fox Chapel Area High School. The first text-based game
I wrote was for VMS and was a single player version of a MUD, more like a Zork
or Planetfall, written in VMS Pascal. It was called "Search for the Mystic Z",
an inside joke about a magic wand called the "Z" which had to be found after
traversing object-oriented puzzles and quests.
Before the Mystic Z, I had distributed the telnet address to a mud called
Nameless MERC, a somewhat generic Merc/Diku MUD that quickly became a classroom
addiction. My friends eventually migrated to Hidden Worlds, a MUD that offered
the unique (at the time) feature of Online Building, a way that, through the
game itself, a player could extend the world and add enemies, magic items and
puzzles/quests.
By 1993, I was writing my own MUD software, Nimud, and had released "OLC" with
co-author Chris "Surreal" Woodward. Chris, who I had met through his Telegard
BBS, Infinity, was an avid programmer and computer hobbyist who was admitted
to Penn State's main campus for Electrical and Computer Engineering. Our
software package, "The Isles" became the basis for many derived works,
including ports of the first publically available OLC source code to a
variety of MUD softwares.

The original message (which implied that HW wrote it and then it was released by these 2 guys) seems to be wrong, unless the NiMUD one is based on it (it sounds like it was made separately from the Hidden Worlds one... since the HW one was 'unique', it must not have been publically released). So, I'm just going to say that it was inspired by it. Someone more knowledgable might know if it's based on it or not. I don't know their history with HW. Please do not remove the Hidden Worlds reference without justifying it on the talk page.

Someone deleted this without discussing it on the talk page too:

In 1996, SMAUG was released with its own completely independent "Online
Building" system, which was inspired by an older non-OLC online building
system used by some SillyMUDs.

The fact that that message was on the page from Nov 19, '04 to Jul 8, '05 lends to its credibility. I'm not going to go researching SMAUG to check on it, but please research SMAUG yourself before removing this, especially if you're an anonymous user.

It seems to me that the SMAUG comment is being written by SMAUG's author, who attests that he "wrote his own" - but many of the commands and the basic structure of his editors is almost identical to Chris and Herb's OLC. If you examine OLCs after TheIslesOLC, you'll note the similarity in editor names. Hidden World's editor is NOT THE BASIS, code-wise, for any OLC released publically, it was just the first one ever written for a Merc-derived MUD, and its authors, which included Kalgen of Zebesta, contributed to the thought-processes behind the development of what became TheIsles OLC. This was the first publically released OLC.

The reason the SMAUG line was on there is because I stopped using the WIkipedia in November and picked it up again only recently; it's a false claim made by someone who is attempting to saturate MUDs with his own impression of what MUDs are. Thoric (of SMAUG) has said that he didn't show up into mudding until 1995, but because of his control over its distributions since 1995, he has been able to modify the history of mudding to his own designs and devices. Just because something is left untouched for a period of time doesn't mean it's correct or that it is legitimized any more than something that was deleted back in 2002. The WikiPedia, while often accurate, is rarely moderated by anything other than collective opinions, and not by actual facts or proof.

As an afterthought; since all of this work is digital, it is very difficult to prove anything since it can be manipulated, however since the software was available well before Thoric made it to mudding, it can be assumed that even if he 'wrote his own OLC' he borrowed many ideas from OLC and thus engineered his own based on the originally publically available OLC. He has also used a file format similar to the original modification of the Diku format made by TheIsles when OLC was written.

It's ludicrous to suggest that I somehow tampered with the "history of mudding". There's no conceivable reason why I'd go out of my way to orchestrate a grand conspiracy coverup of falsifying the evolution of SMAUG's online building. How would it benefit me in any way? If I had known your OLC was available at the time, why would I have wasted months creating my own? Anyone who cares to analyze the code is free to do so, in fact I wish you would take the time to do it yourself to support your claims. I built SMAUG's online building code during the fall of 1994. It was designed about a year after my experience of using Mozart MUD's online building system (a SillyMUD, not a Merc MUD) in 1993. Since as you claim, TheIsles OLC was not officially publically released until 1995, how could my work (done in 1994, based on my online building experiences in 1993) be based on your OLC code? Nothing can be "assumed". Reinvention and convergence are not uncommon. --Thoric 04:26, 12 July 2005 (UTC)

Date question

Found this in isles/src/oc.c in ftp://ftp.game.org/pub/mud/diku/merc/nimud/Nimud.4.5.tar.gz

/*****************************
 *                           *  Who was Surreal "Chris Cool" Woodward?
 * Nimud OLC - copywrited to *
 * Christopher Woodward 1995 *  Christopher Woodward was a student at Penn State in 1994.  A freshman in computer science,
 *                           *  he developed this online creation software in 1991 for The Isles, a Merc-derived MUD hosted
 * THE ORIGINAL ONLINE       *  by the Hacks users group at the University of Arizona.  It was first released publically in 1994.
 * CREATION SYSTEM.          *
 *                           *  Originally developed as an answer to a lack of readily accessible area editors, the OLC has been 
 * Locke's additions 99-2003 *  expanded to include new features over the years while still retaining core functionality.
 * Krayy's HEDIT version 1.0 *
 *                           *  The Isles and NiMUD software has been dedicated to his memory.  Chris died on December 13, 1995. 
 *****************************/

The article claims '92 or '93, the oc source code says '94. Which is correct? Atari2600tim 20:13, 10 July 2005 (UTC)

From some random site in europe: TheIsles1.1.tar.gz appears 'conveniently located by the author of SMAUG'

(I located it with Google... you then asked me at add it to ftp.game.org... now you turn around and make accusations against me) --Thoric 04:42, 12 July 2005 (UTC)

I have never claimed it was released in 1991. Version 4.5 is a 'questionable' quick-and-dirty release, a better citation would have been TheIsles15 or earlier versions. I question the authenticity of 1.1, but it may be one of the first versions. Someone, not necessarily Thoric, required the removal of all area files in version 15 as they were supposedly 'copyrighted to someone else' - this may follow the line of thinking that Diku and Merc would not consider TheIsles/NiMUD to follow the Diku and Merc licenses because only 'Based on Merc' appears in the title screen in earlier versions of TheIsles/NiMUD, and not the original author's names. By 2000, NiMUD possessed less than 20% of the original DikuMUD functionality, and by 2002, NiM5 possesses less than 5% similar code. If you examine NiM5's code, you will note using diff or other file comparisons that almost none of the code is similar to Diku and does not need to follow its license. Sadly, this is the reason Kyndig.com no longer allows NiMUD to be hosted there, citing that it does not follow a license under which it may not be legally bound. Copyright law is debated by case law at this point, suffice to say NiM5 is released under a similar kind of license, one which permits copy and use, though no redistribution under repackaging without permission. Parts of the code may be used in other softwares only when the original surviving author permits it, or when it is cited and contains information to contact the original author. If you examine NiM5, you will note that much of it is vastly different in its core structure, communication routines, database manipulation routines, file structure and gameplay. Like the Diku license, NiM5 is a restricted open source license which provides room for private extensibility and modification, without public redistribution after repacking by prospective authors (I believe, I will have to check the specifics of that). Regardless, feel free to use and enjoy the software. This is similar to what Merc did- augmenting a previous licensing agreement. Also, it may be of note that NiM5's license does not change the previous releases, which all contain reference to Diku, Merc and diku.txt, explain completely where the code originated, and how it came to be. --Locke

According to 'TheIsles1.1' it's 1994; according to my own memories, I released first a version called 15, which was hacked to bits by someone who wouldn't host it with the Merc/Diku areas, because 'technically those are mercs' yet is still considered to be under the dikumud license (I do not argue that it is not, as I have included the diku.txt) and so someone else released it as TheIsles15.tar.gz, not me. Many of the versions do not seem to match with the original releases, because people who host mud ftp services tend to make their own additions, comments, and function as censors. I do not remember releasing TheIsles 1.1, but it is possible; I've noticed many people are trying to 'cover up' the origins of this feature, which was the product of work produced by Chris Woodward and myself.

I have photographs from high school where I learned how to use VAX; it was that year I learned it; I took those courses Sophomore and Junior years in high school, which would have been when I was 15, about 12-13 years ago.

As an aside; I don't think releases after NiMUD2000 and before NiM5 (an upcoming version) are very accurate, and I question some of NiMUD's own historical releases; needless to say many of the original TheIsles releases are missing, tampered with, or just gone. It was 1995 or 1996 when Jason Dinkel first approached me, it was several years after Chris had already left. I think it was 1993 that Chris died, so we had already been working on it for several years at that point, placing it in the 1992-1993 range, if this is 2005, and you subtract 13, that puts it at 1992.

One of the reasons that the source seems to be missing, is the choice of mud ftp hosting services to remove NiMUD because 'it doesn't follow the Dikumud license' specifically because the names of Diku's founders aren't in the title screen; this would be the only modification to the license. There are issues surrounding this which differ in various cases. The reason I did this originally was because I felt it was unnnecessary to keep a long list of names in the title, and it was deemed a small but necessary risk, seeing as "HELP CREDITS" and the Diku.txt file were included with the original releases; it has not been claimed that NiMUD was ever a) not based on Diku, at least partially, or b) was ever distributed without the diku.txt contained in its source intentionally. Many uploads to various archives/ftp sites were tampered with by either Thoric, creator of SMAUG, or by other ftp archival site owners.

Members of DikuMUD Team and Merc team have basically said, in communications since 1993, that they are not concerned with such a small discrepancy, and are more concerned with fiscal remuneration from folks like Medievia.

I no longer have any copies of the original releases, though I do maintain copies of whatever has been floating around since the early nineties.

First of all, TheIsles is a Merc 2.x derivative. Merc 1.0 was released in December of 1992. DikuMud gamma was released in 1991, DikuMud alfa was released in 1993, and Merc 2.0 was also released in 1993. That TheIsles OLC was developed in 1991 (as credited above) is highly suspect. I have never tampered with any distribution apart from the addition of an "ftp_game.org" text file to indicate the point of distribution (which I started doing in 1997 for a while during the peak of other sites leaching their content from ftp.game.org without permission or attribution). Whatever exists on ftp.game.org are the works that were submitted. --Thoric 04:42, 12 July 2005 (UTC)

TheIsles originated with Merc 2.0c and was later augmented to work with 2.1c? or a similar Merc release. The OLC and some of the functionality of the Isles pre-dates these releases, as they were present in a Merc 1.0 modification called CthulhuMUD. The original CthulhuMUD was hacked, its source retained but its areas and player files completely lost. Someone 'hacked it' and modified the title screen to read 'REVENGE OF CTHULHU', removing access to immortal's player files, and sabotaging the effort. --Locke

Is this CthulhuMUD source available? --Thoric 16:43, 12 July 2005 (UTC)

No, the base was deleted and the source replaced with a Merc 2.x after the initial hacking- mainly because it was painful. The game started in Arkham, and quickly lead into the Sewers where you could use a ritualistic dagger as a spell catalyst. The word 'catalyst' used in some NiMUD sources refers to that 'ritualistic magic'- a magic system tied to special objects and used with the 'ritual' command and associated skill. The only items I had created, aside from modifications to the score and other fundamental commands, were a ceremonial dagger (chris=kris:) and a silver-plated revolver. Ritual magic was a way to explain the way an 'investigator' would be able to cast spells, as the mana statistic was removed from CthulhuMUD. Ritual magic was pretty powerful: once you had the item, you could cast the spell as many times as you liked. It is also the inspiration for what became the alchemical system on The Isles / NiMUD. Re: hacking - Some of these ideas persist (CthulhuMUD has a ceremonial dagger and a silver-plated revolver, as well as an Investigator class) but I think they are taken from various works by H.P. and not necessarily from my CthulhuMUD. (it may be a genre-thing, and not evidence that CthulhuMUD of today is somehow related to the CthulhuMUD of 1992/3.) Or perhaps its a message from the CthulhuMUD people as to who it was who hacked me --Locke

SMAUG vs. TheIsles/NiMUD code comparison

Since nobody else is doing it, I decided to compare some of the "similar" building code - redit. Since it is lengthy, I've only compared two of the room editing commands. I can put up more comparisons upon request, but I really suggest that someone else do a comparison. Please note that both code bases are derivative works of Merc 2.x, and inherit much in the way of form, style, data structures, functions and macros.

SMAUG 1.0 (dec 1996) file: build.c  Function: do_redit
NiMUD 1.5 (aug 1994) file: oc.c     Function: redit

Flag toggling

SMAUG: redit flags <flag name> (i.e. redit flags dark death nomob)

char *  const   r_flags  =
{
"dark", "death", "nomob", "indoors", "lawful", "neutral", "chaotic",
"nomagic", "tunnel", "private", "safe", "solitary", "petshop", "norecall",
"donation", "nodropall", "silence", "logspeech", "nodrop", "clanstoreroom",
"nosummon", "noastral", "teleport", "teleshowdesc", "nofloor",
"nosupplicate", "arena", "nomissile", "r4", "r5", "prototype", "dnd"
};
int get_rflag( char *flag )
{
    int x;
    for ( x = 0; x < (sizeof(r_flags) / sizeof(r_flags)); x++ )
      if ( !str_cmp(flag, r_flags) )
        return x;
    return -1;
}

if ( !str_cmp( arg, "flags" ) )
{
    if ( !argument || argument == '\0' )
    {
        send_to_char( "Toggle the room flags.\n\r", ch );
        send_to_char( "Usage: redit flags <flag> ...\n\r", ch );
        return;
    }
    while ( argument != '\0' )
    {
        argument = one_argument( argument, arg2 );
        value = get_rflag( arg2 );
        if ( value < 0 || value > 31 )
            ch_printf( ch, "Unknown flag: %s\n\r", arg2 );
        else
        {
            if ( 1 << value == ROOM_PROTOTYPE
            &&   get_trust( ch ) < LEVEL_GREATER )
                send_to_char( "You cannot change the prototype flag.\n\r",
            else
                TOGGLE_BIT( location->room_flags, 1 << value );
        }
    }
    return;
}

NiMUD: (redit) <flag name> (i.e. no_mobs)

int room_name_bit( char* buf )
{
    if ( !str_cmp( buf, "dark"         ) ) return ROOM_DARK;
    if ( !str_cmp( buf, "no_mobs"      ) ) return ROOM_NO_MOB;
    if ( !str_cmp( buf, "indoors"      ) ) return ROOM_INDOORS;
    if ( !str_cmp( buf, "private"      ) ) return ROOM_PRIVATE;
    if ( !str_cmp( buf, "safe"         ) ) return ROOM_SAFE;
    if ( !str_cmp( buf, "solitary"     ) ) return ROOM_SOLITARY;
    if ( !str_cmp( buf, "pet_shop"     ) ) return ROOM_PET_SHOP;
    if ( !str_cmp( buf, "no_recall"    ) ) return ROOM_NO_RECALL;
    if ( !str_cmp( buf, "bank"         ) ) return ROOM_BANK;
    return 0;
}

if ( room_name_bit( arg1 ) != ROOM_NONE )
{
    pRoom->room_flags  ^= room_name_bit( arg1 );
    SET_BIT( pArea->area_flags, AREA_CHANGED );
    send_to_char( "Room flag toggled.\n\r", ch );
    return;
}

Exit creation

SMAUG: redit exit <dir> (i.e. redit exit n 10101)

/* from mud.h */
struct  exit_data
{
    EXIT_DATA *         prev;           /* previous exit in linked list */
    EXIT_DATA *         next;           /* next exit in linked list     */
    EXIT_DATA *         rexit;          /* Reverse exit pointer         */
    ROOM_INDEX_DATA *   to_room;        /* Pointer to destination room  */
    char *              keyword;        /* Keywords for exit or door    */
    char *              description;    /* Description of exit          */
    int                 vnum;           /* Vnum of room exit leads to   */
    int                 rvnum;          /* Vnum of room in opposite dir */
    int                 exit_info;      /* door states & other flags    */
    int                 key;            /* Key vnum                     */
    sh_int              vdir;           /* Physical "direction"         */
    sh_int              distance;       /* how far to the next room     */
    sh_int              pull;           /* pull of direction (current)  */
    sh_int              pulltype;       /* type of pull (current, wind) */
};

/* from act_move.c */
EXIT_DATA *get_exit( ROOM_INDEX_DATA *room, sh_int dir )
{
    EXIT_DATA *xit;
    if ( !room )
    {
        bug( "Get_exit: NULL room", 0 );
        return NULL;
    }
    for ( xit = room->first_exit; xit; xit = xit->next )
       if ( xit->vdir == dir )
         return xit;
    return NULL;
}
EXIT_DATA *get_exit_to( ROOM_INDEX_DATA *room, sh_int dir, int vnum )
{
    EXIT_DATA *xit;
    if ( !room )
    {
        bug( "Get_exit: NULL room", 0 );
        return NULL;
    }
    for (xit = room->first_exit; xit; xit = xit->next )
       if ( xit->vdir == dir && xit->vnum == vnum )
         return xit;
    return NULL;
}

/* from build.c, inside function do_redit */
if ( !str_cmp( arg, "exit" ) )
{
    bool addexit, numnotdir;
    argument = one_argument( argument, arg2 );
    argument = one_argument( argument, arg3 );
    if ( !arg2 || arg2 == '\0' )
    {
        send_to_char( "Create, change or remove an exit.\n\r", ch );
        send_to_char( "Usage: redit exit <dir>    \n\r", ch );
        return;
    }
    addexit = numnotdir = FALSE;
    switch( arg2 )
    {
        default:    edir = get_dir(arg2);                     break;
        case '+':   edir = get_dir(arg2+1); addexit = TRUE;   break;
        case '#':   edir = atoi(arg2+1);    numnotdir = TRUE; break;
    }
    if ( !arg3 || arg3 == '\0' )
        evnum = 0;
    else
        evnum = atoi( arg3 );
    if ( numnotdir )
    {
        if ( (xit = get_exit_num(location, edir)) != NULL )
          edir = xit->vdir;
    }
    else
        xit = get_exit(location, edir);
    if ( !evnum )
    {
        if ( xit )
        {
            extract_exit(location, xit);
            send_to_char( "Exit removed.\n\r", ch );
            return;
        }
        send_to_char( "No exit in that direction.\n\r", ch );
        return;
    }
    if ( evnum < 1 || evnum > 32766 )
    {
        send_to_char( "Invalid room number.\n\r", ch );
        return;
    }
    if ( (tmp = get_room_index( evnum )) == NULL )
    {
        send_to_char( "Non-existant room.\n\r", ch );
        return;
    }
    if ( addexit || !xit )
    {
        if ( numnotdir )
        {
            send_to_char( "Cannot add an exit by number, sorry.\n\r", ch );
            return;
        }
        if ( addexit && xit && get_exit_to(location, edir, tmp->vnum) )
        {
            send_to_char( "There is already an exit in that direction leading to that location.\n\r", ch );
            return;
        }
        xit = make_exit( location, tmp, edir );
        xit->keyword                = STRALLOC( "" );
        xit->description            = STRALLOC( "" );
        xit->key                    = -1;
        xit->exit_info              = 0;
        act( AT_IMMORT, "$n reveals a hidden passage!", ch, NULL, NULL, TO_ROOM );
    }
    else
        act( AT_IMMORT, "Something is different...", ch, NULL, NULL, TO_ROOM );
    if ( xit->to_room != tmp )
    {
        xit->to_room = tmp;
        xit->vnum = evnum;
        texit = get_exit_to( xit->to_room, rev_dir, location->vnum );
        if ( texit )
        {
            texit->rexit = xit;
            xit->rexit = texit;
        }
    }
    argument = one_argument( argument, arg3 );
    if ( arg3 && arg3 != '\0' )
        xit->exit_info = atoi( arg3 );
    if ( argument && argument != '\0' )
    {
        one_argument( argument, arg3 );
        ekey = atoi( arg3 );
        if ( ekey != 0 || arg3 == '0' )
        {
            argument = one_argument( argument, arg3 );
            xit->key = ekey;
        }
        if ( argument && argument != '\0' )
        {
            STRFREE( xit->keyword );
            xit->keyword = STRALLOC( argument );
        }
    }
    send_to_char( "Done.\n\r", ch );
    return;
}

NiMUD: link (i.e. north link 12001)

/* from merc.h */
struct  exit_data
{
    ROOM_INDEX_DATA *   to_room;
    EXIT_DATA *         next;
    int                 vnum;
    sh_int              exit_info;
    int                 key;
    char *              keyword;
    char *              description;
    sh_int              rs_flags;       (reset flags)
};

/* from oc.c */
int get_direction_number( char *arg )
{
    if ( !str_cmp( arg, "n" ) || !str_cmp( arg, "north" ) ) return DIR_NORTH;
    if ( !str_cmp( arg, "e" ) || !str_cmp( arg, "east"  ) ) return DIR_EAST;
    if ( !str_cmp( arg, "s" ) || !str_cmp( arg, "south" ) ) return DIR_SOUTH;
    if ( !str_cmp( arg, "w" ) || !str_cmp( arg, "west"  ) ) return DIR_WEST;
    if ( !str_cmp( arg, "u" ) || !str_cmp( arg, "up"    ) ) return DIR_UP;
    if ( !str_cmp( arg, "d" ) || !str_cmp( arg, "down"  ) ) return DIR_DOWN;
    if (!str_cmp( arg, "ne" ) || !str_cmp( arg, "northeast" )) return DIR_NE;
    if (!str_cmp( arg, "nw" ) || !str_cmp( arg, "northwest" )) return DIR_NW;
    if (!str_cmp( arg, "se" ) || !str_cmp( arg, "southeast" )) return DIR_SE;
    if (!str_cmp( arg, "sw" ) || !str_cmp( arg, "southwest" )) return DIR_SW;
    return MAX_DIR;
}

/* from oc.c, inside function redit */
if ( ( door = get_direction_number( arg1 ) ) != MAX_DIR && arg2 != '\0'
{
    argument = one_argument( argument, arg1 );
    strcpy( arg2, argument );
    if ( !str_cmp( arg1, "link" ) )
    {
        if ( arg2 == '\0' || !is_number( arg2 ) )
        {
            send_to_char( "Syntax:   link \n\r", ch );
            return;
        }
        value = atoi( arg2 );
        if ( get_room_index( value ) == NULL )
        {
            send_to_char( "REdit:  Cannot link to non-existant room.\n\r", ch );
            return;
        }
        if ( !IS_BUILDER( ch, get_room_index( value )->area ) )
        {
            send_to_char( "REdit:  Remote side not created, not a builder there.\n\r", ch );
            return;
        }
        if ( get_room_index( value )->exit] != NULL )
        {
            send_to_char( "REdit:  Remote side's exit already exists.\n\r", ch );
            return;
        }
        if ( pRoom->exit == NULL )
        {
            pRoom->exit = new_exit();
        }
        pRoom->exit->to_room = get_room_index( value );
        pRoom->exit->vnum = value;
        pRoom                   = get_room_index( value );
        door                    = rev_dir;
        pExit                   = new_exit();
        pExit->to_room          = ch->in_room;
        pExit->vnum             = ch->in_room->vnum;
        pRoom->exit       = pExit;
        SET_BIT( pArea->area_flags, AREA_CHANGED );
        send_to_char( "Exit linked.\n\r", ch );
        return;
    }

The source code for both distributions is freely available on ftp.game.org: SMAUG and NiMUD. --Thoric 05:35, 12 July 2005 (UTC)

Basic Structure of OLC

Hey man it's good to see you hang out on the 'new mud' (wikipedia d=):

Likewise ;)

NiMUD/TheIsles, written 1992-1993/1994: Commands: redit oedit medit aedit

Enters a 'special mode' which responds to user input; this is the editor mode, and is an extension of the communications routines.

STR(b,c); <- added to NiMUD source code to fix a distinction problem related to referencing strings in both the "index" of the entry and the "incidence" of the entry (the copy created for the world), this may be the easiest way to trace DIRECT CODE INSERTION into new code, because it is an indicator of NiMUD's original code design change to the standard Merc/Diku string routines; this is often 'hacked out' in copies that were ported to other softwares. For those who just 'studied NiMUD and then modified and/or created new code to match its features', this macro may be omitted.

(A nice macro that certainly may have made the SMAUG code cleaner. I really don't see the point of anyone hacking it out to purposely make their code more cumbersome. --Thoric 14:52, 12 July 2005 (UTC))

It is an indicator of what Merc-derived sources use TheIsles-based OLC. -Locke

SMAUG (as distributed) does not contain this STR(b,c) macro. --Thoric 17:44, 13 July 2005 (UTC)

Another note is that NiMUD's feature set is this:

Security for Building Special 'mode' Bit Keywords- Keywords at the command line to toggle bits "Dig" or "dig-like" command, borrowed from MUSH New database file format made similar to Merc's playerfile format Prompt manipulation

I believe that Thoric, based on a statement he made to me over email similar to "I wanted to start with NiMUD", read through and understood OLC before writing a similar OLC, to say it was developed independently is not correct because he obviously read and understood the core features and functionality of the original Isles OLC, possibly his inspiration.

(The statement was, "I wish I had started with NiMUD". Not only was NiMUD unreleased at the time (June 1994), my only inspiration came from using Mozart MUD's online building. --Thoric 14:52, 12 July 2005 (UTC))

You also made a statement to me that you started mudding in 1995. -Locke

No, I told you I opened ftp.game.org in 1995. Realms of Despair opened in 1994, I mudded on Mozart in 1993, and mudded on VieMUD in 1992. --Thoric 17:44, 13 July 2005 (UTC)

Zebesta's OLC, for instance, is not a direct correlation in its features or functionality to NiMUD/TheIsles OLC, as it uses these commands:

oset zset mset rset

Has security, has limited (no user control) prompt manipulation.

Has a special mode only for entering strings.

SMAUG does contain functionality similar to "worldgen.c" from NiMUD's earlier releases.

(It was I who pointed that out to you. --Thoric 14:52, 12 July 2005 (UTC))

Is it credited? -Locke

No, that will have to be fixed. -Thoric

Thanks, please do so. Surreal had left the project at that point, worldgen.c was an afterthought I added to inspire future mudders. I noticed that several mud engines now use code similar to this for generating areas; they also borrowed the terrain and ascii mapping features for some of the more 'ascii graphical' muds -- I think that's great, when properly cited; it was an idea borrowed from Rogue and Rogue-like games, which generate a lot of their content using random number generators with predetermined seeds. - Locke

SMAUG, written 1995/1996: (Realms of Despair was started in June of 1994, and released as SMAUG in 1996 --Thoric 14:52, 12 July 2005 (UTC))

Commands: redit oedit medit aedit

Enters a 'special mode' which responds to user input; this is the editor mode, and is an extension of the communications routines.

(Incorrect. SMAUG has the commands: redit oset mset aset rset (and others). They do not enter a 'special mode' unless you type for example "oset <object> on", a functionality added later when builders requested it. SMAUG originally didn't even support a special editing mode... it was added later. --Thoric 14:52, 12 July 2005 (UTC))

If it was added later, then it was borrowed from the dominant and accepted form of OLC, TheIslesOLC, which uses that mode, and is a feature that is indicative of the modal design choice in TheIslesOLC. -Locke

It is likely that the builder(s) who requested it were used to it from building on OLC-based MUDs, so yes, that specific functionality indirectly came from OLC. --Thoric 20:28, 13 July 2005 (UTC)

Security for Building Bit Keywords- handled differently, but still present "Dig" or "dig-like" command, borrowed from MUSH New database file format similar to Merc's playerfile format Prompt manipulation/indicators

(SMAUG does not have a "dig" or a "dig-like" command. Are you certain that you are looking at the original SMAUG distribution, and not one that has OLC ported into it? --Thoric 14:52, 12 July 2005 (UTC))

By the way, ideas are not permissable as a copyright; you cannot own an idea, merely the expression of it. Thoric "owns" his building system, but to state that it was developed independently is completely false, as it is similar to and was influenced by TheIsles OLC, the original publically available OLC.

Of course it is going to be similar since both systems are used to edit Merc 2.x data structures online, but if you take a close look at the code, you can see obvious and striking differences. --Thoric 14:52, 12 July 2005 (UTC)

Also, it might be of note that NiMUD OLC versions 5 and later use these commands translations (with legacy macros): redit->sedit oedit->pedit medit->aedit aedit->zedit (aedit removed)

Thoric also added additional editor(s): a skill, spell, race and document edit.

(SMAUG has sset, setrace, hset and hedit. Again, if you look at the code you'll see it's completely different stuff, especially sset which supports SMAUG's "SMAUG spells", which allows you to create new spells online without having to know how to write C code. --Thoric 14:52, 12 July 2005 (UTC))

Main differences between SMAUG's online building and NiMUD OLC

Most of SMAUG's online building and editing commands are extensions of commands that came with Merc already... rset, oset, mset, etc. Editing works using a prototype flag system whereby you take an object or mobile, toggle its prototype flag, and while the prototype flag is set, changes made to that instance object or mobile will be reflected onto the "index" or prototype object or mobile. Newly created objects or mobiles (created with the commands ocreate and mcreate respectively) start out with the prototype flag on. Rooms don't really need a prototype since there is no "index" or prototype room, but the flag is still used, and can be used to disable certain functionality during development if required (for example, players are not allowed to use prototype objects). This prototype model of design was used on Mozart MUD (which used SillyMUD code, not Merc).

NiMUD OLC on the other hand uses redit, oedit and medit exclusively to put you into an editing mode, where you type "create <vnum>" to create a new obj/mob or room, and these commands work exclusively on the "index" objects and mobiles, leaving the Merc oset/mset commands to operate exclusively on non-index (instances of) objects and mobiles.

To clarify things for those unfamiliar, Merc uses a system whereby instances of objects and mobiles are cloned off of a master "index" object or mobile (of a particular vnum -- virtual number identifier).

Merc came with oset and mset commands to allow editing specific instances of objects or mobiles (the copies), but to change the master copy of an object or mobile, you would have to edit the area file by hand with a text editor, and restart the mud. SMAUG extended the oset/mset commands to support editing the master index objects/mobiles when a prototype flag was set on the object/mobile. NiMUD OLC instead added new editing commands to work on the master index objects/mobiles directly. I believe this in itself is evidence that they are not based on each other. If anything it seems like SMAUG's online building is closer to the Zebesta OLC you mention --Thoric 14:52, 12 July 2005 (UTC)

NiM Scripts

The goal of NiM scripts was to generate a way to develop spells online as well, and was a component of the earlier versions, as well as an implementation in later versions (NiM5). -Locke

SMAUG Spells are a simple matter of setting flags, values, strings and dice-role formulas into the skill data structure... no fancy scripting (unfortunately). --Thoric 17:44, 13 July 2005 (UTC)

NiM5's scripting language and OLC are intertwined, but could be seperated from the source and put in a box all of its own. There are instructions for porting this, and it could be run 'simultaneously' with Mobprogs or other scripting languages. If you extract the data structures, file routines, interpreter and modify or reduce the functions, the scripting language should work on any Merc-derived software with about 1-2 weeks of solid effort. As far as I can tell, it is not the reason behind persistant crashes, and the interpreter code is rock solid. Also, as far as I can tell, the functions are rock solid, but a few more may need to be written, the functions are macro-ized for ease of porting. NiMScripts comes under its own license, and permission would be granted to do so if someone chose to email me and ask. The spell systems in place are alchemical and gem-mana based, but that is all in cmd_cast() and is seperate from the language itself. There would be some symbol changes, specifically with relationship to the BONUS_DATA (affect_Data) structure - mainly just name changes, the code itself may, in the macros, use the STR() thing, but few other NiMUD-specific macros, and is inclusive, containing its own macros necessary to ease creation of new functions for the language which match databases that are different from NiMUD's.

This was designed to improve upon an already public system called mobprogs, and to borrow ideas from MUSH-code, which is really slick and interesting to play. It would be possible, with some minor changes to the source, to make a MUSH look like a Diku, for instance. It is in no way related to mobprogs, no code is like mobprogs, but I did take a look at mobprogs only to see how they inserted the data structure and the additions to main_loop, however, I ended up deciding to use another system. I do mention mobprogs, and had hoped that NiM would replace mobprogs- but due to a bug, it was unpopular, and people didn't like to use the braces {,} - often the complaint I got was because it looked similar to "C"

By the way I chose these because I had braces at the time, and because " and ' are used as commands by the MUD command parser. I called them 'curlies' to distinguish them from Brackets -- "curlie brackets" - the name my father's secretary used to describe them. I do see a slight sexual overtone in the use of the word 'curlies' and have tried to move away from that when rewriting or adding documentation to the latest release. I now refer to them as what they are, "braces" and not "curlie brackets", though they look like (trivia question) an entirely different typographical symbol, even though they aren't called that. Of course, I first wrote that at the height of puberty, so no wonder. At least mudding kept me away from my early-teenage porn addiction.

NiMUD's OLC has had a contribution, by Krayy, who eventually 'stole a development copy of the source and disappeared': hedit, a buggy help document editor.

I should also mention that version "beta 3" has a significant bug fix to the interpreter which has eluded me for a long time. I see mudding generally as a waste of time, but it does teach you challenging text manipulations and makes you think of language, symbolic structures and issues in computer science (such as its relationship to engineering usable systems and competition, even though remote, in a business sense; but also is the product of the inability of the rigid laws of computing relating to the universe which cannot be fully approximated).

Mudding is most directly related to natural language processing (CS), psychology, sociology, and entertainment technology. I look at it as a way for kids to express not only their gaming ideas, which come from the world, but also as a sort of 'bardic C' -- a cute way for humans to express linguistics in a more rigid and defined format, and a way to record their internal ideas about the structure of the world around them. Sometimes it encourages research into those systems, especially when a participant in mudding isn't familiar with them. Its also a non-visual way of describing these systems, and perhaps, psychologically, creates reinforcement of those ideas through testing and redesign. It IS computer science, it is NOT a very lucrative one in the sense of making money, at least not when in competition with more advanced immersive experiences. It's also a great way to draw sketches of 'interactive' experiences, something which is difficult to do using linear media (writing, drawing, storyboards). For me, mudding was sometimes a way to capture ideas from other games that I thought particularly interesting, or expand upon existing game ideas, or in some cases, 'predict' or create a cognitive model of ideas that I thought would be 'hot' or 'trendy' in future games. I also think that a course in Game Theory teaches you similar ideas, and that it is just impressions in the 'mud' of other software and real-world systems.

Another reason the bug has been elusive, perhaps more rationally, due to inexperience at the time. The interpreter is not well commented, and I'm not really sure where to put those comments, but the ones that are there are important and I can still determine their meaning, although certain lines of code I had to study. I basically had to 'prove' an interpreter without really knowing anything more than a compiler from an end-user standpoint - these two proofs are similar. Chris did teach me a few things about what .o files were and why the mud had to be rebuilt when you make modifications to mud.h, even if its only a MACRO change. I don't see why that is to this day .

A change to an included header file (.h) requires recompilation of every .c file that uses the part you changed. Especially important are changes to data structures. Think of a macro definition as being the same as a constant value definition inside a .h file (for example #define MAX_LEVEL 50), if you change the value, and do not recompile all the .c files which depend on the MAX_LEVEL value, the .o files will not be using the new value. A macro definition is defined in the same way (#define STR(b,c) ...), and therefore all .c files which use it will need to be recompiled if it is changed. --Thoric 17:23, 14 July 2005 (UTC)

The bug was ~9-11 years old when I finally discovered and removed it. It took two days and a brief discussion with a CS roommate (which yielded very little as he had little idea about the source itself, though he recommended a few tools which tracked memory leaks). That was the bug that made the Isles less stable after I started working on the scripting language - a mem leak that forced NiMUD to crash within 2-4 hours consistently. I should also mention that it is possible that Krayy, while adding the help editor, inserted the bug, but I believe it was just a bug from back in the day. --Locke

Permission need not be granted

I guess, unless you are going to use NiM commercially, permission does not need to be granted to use any of the work of NiMUD. It is distributed under both DIKU and GPL, and is permissable to be used in conjunction with other software work as long as it is cited and its copyrights are prominently displayed in appropriate help files, documentation and in the credits help entry.

The NiMUD license has many conflicts with GPL. I would suggest for User:141.158.97.121 to read the readme files or to sipmly ask Locke. I'm actually confused as to why User:141.158.97.121 made this change which is talking about how nobody has permission to distribute OLC derivatives, yet they also on this talk page said that permission does not need to be granted.

Here is my comparison based on the readme files I have read so far:

• GPL license (4 things quoted from the GPL article)
  • The freedom to run the program, for any purpose.
  • The freedom to study how the program works, and modify it. (Access to the source code is a precondition for this)
    • This one is the only one that the 2 licenses agree on.
  • The freedom to redistribute copies.
  • The freedom to improve the program, and release the improvements to the public. (Access to the source code is a precondition for this)
• NiMUD license
  • Diku license restricts you to non-commercial usage, and you must inform Diku and Merc people saying that you're using their code, and you even need to keep some diku credits in your login screen. GPL has no restrictions on your interface when you use the program, and only talks about your distribution of the actual software. The GPL does require for you to give credit where it's due, but just in the source code.
  • You can only distribute copies if you have permission from Locke beforehand.
  • You need permission beforehand from Locke to distribute your derivatives.

I'll note that the GPL was included in some of the NiMUD distributions, so I don't know if the licensing has changed, and perhaps User:141.158.97.121 was referring to the old license when updating the article, or what. I'm guessing maybe they downloaded a more recent version and discovered that it was under GPL now. After all, that change was on July 10, and this little thing on the talk page talking about GPL was added on the 14th. Assuming the best possible scenario, it would be best to assume that User:141.158.97.121 had downloaded the newer NiMUD sometime between the 10th and 14th and was unaware of the GPL part until now. Atari2600tim 02:49, 17 July 2005 (UTC)

It is possible that versions of NiM5 (NiMUD's current platform) contain conflicting copyright and/or information. I have several times requested that Thoric remove it from his archive. Kyndig has threatened to sue me, but I doubt it will ever go to court (mainly because he cannot sue on behalf of Diku, he is not a lawyer, and it is something for which remuneration cannot be granted). He has stopped allowing NiM5 distributions on his service because of breaking the "login screen" requirement from the Diku license; I have talked to Whistler of Diku][ and he has expressed little concern with this discrepancy, citing that I do include credit information and the license in the releases. I do not have federal U.S. copyrights (I forgot to turn in the NiMUD application) and have never made a penny off the development of NiMUD. There is a level of disinterest I hold for the copyright part of this software package, because no one aside from Jason Dinkel has ever contacted me to say anything other than 'we'd like to run nimud' -- and for some reason they immediately rename the server to something else and begin working on it. Also, I have never granted permission for it to be included in additional softwares. Chris would probably not care either, but he might find it humorous that we were robbed so blatantly for years, especially since our contemporaries jumped on the back of Medievia for blatant disregard of the Diku license.

-Locke

Tim on Jul 16

When Chris died seems to be a big part of the dating stuff. The readme file that I quoted on the talk page says that he died December 13, 1995... the NiMUD page says December 13th, 1996... this talk page says 1993, and then uses relative dates for everything else (X years before Y, where Y is only guessed at). http://www.mugs.net/nimud/surreal.html says it was 1995. I think any dates mentioned on this article are questionable for that reason. However, I'm adding that 1994 is when it was publically released, because that's what the readme file I quoted on the talk page says. I also opened TheIsles15.code.tar.gz and all the files in it are timestamped 1994. I am not implying that anything intentionally bad was going on, because I am in the same situation and understand completely... I mess up dates myself because I compare things to when my mom died, which was in Feb 2003, yet sometimes I think it was 2002 or 2004. I imagine I'll be off by 3 years or more by the time a decade has passed.

Second thing, I don't know enough about this to rewrite it very accurately, but the part talking about SMAUG's online building sounds like it has changed and isn't clear in what way it has. The original message says that SMAUG's system was completely separate from the one called OLC, and inspired by some other online building systems, and the new one says that it was influenced by OLC with no references to the other systems. After reading the entire article, one comes away with the idea that all online creation systems (at least all diku ones) were based on this one system and that there have never existed any other systems. For the SMAUG one, I don't know where it had inspiration from because I'm not terribly interested in diku muds. Someone should probably e-mail whoever's responsible for SMAUG and ask them directly, and then put their response on this article, or else go from the SMAUG readme (which I haven't looked for due to not being interested enough).

Doesn't anyone read anymore? I've already stated serveral times in this talk page that SMAUG's online building was created in 1994 after using MozartMUD's online building in 1993. I am responsible. I wrote the code. --Thoric 16:02, 18 July 2005 (UTC)

All I have info about is that OLC was inspired by Hidden Worlds' system... and that comes straight from the surviving author, so that's pretty clear. I quoted that on the talk page earlier, and here is another more recent quote saying basically the same thing. This quote comes from NiM5.beta_2.prerelease.tar.gz:

We stole the ideas from Hidden Worlds MUD, 
who had the initial working concept of an OLC; a very
advanced feature at the time for a Diku/Merc 1.0; and
perhaps the only Merc 1.0 boasting an online zone
building system.
Surreality wrote the major framework.  It was designed
by both Surreality and Locke by stealing ideas from
Kalgen, who ran a mud called Zebesta with his friend
Zlixlt.  Kalgen (Alex Dzur of University of Washington,
Seattle, Washington) had designed an interesting
derivation of Merc after his time as an immortal on 
Hidden Worlds, where he was among the more prestigious 
immortals.  Kalgen's Mud Zebesta has disappeared; sad
but true it is lost to history.  One of the greatest
muds ever seen, which had many of the features and
careful considerations of a game worthy of being called
"great" --
The "Mozart" OLC software was not written at the time,
and has come later, perhaps developed simulteanously,
but most likely a "reinvented wheel" to avoid the NiMUD
OLC license, which of course has been ignored by a
great many MUD developers.  Thoric of Realms of Despair
lends this to the fact that much of the godwars variants,
pirate and deluxe for example, were "leaked" and being
that this is true, often MUD developers, often in their
secretive nature, have failed to follow Jason Dinkel's
license which stated that those using the EnvyOLC/ILAB
OLC ports must CONTACT LOCKE@MUGS.NET (now swerves@hotpop.com

The current page has no reference to Hidden Worlds, I assume this was a mistake in editing, because the current context makes it sound like NiMUD had it, and Locke never became an immortal to build, and thus implies that Locke was never an immortal on NiMUD or something. Please re-read before clicking submit, everyone, and use the preview button too :)

Licensing... I was confused from reading the article, and I didn't know why it mattered that ILAB/OLC had permission to edit it or not. I have a better understanding after reading some files, but I think others shouldn't have to go to as much trouble. The current message sounds like it was written from an anti-OLC point of view and might scare people from using it based on fears of an overly restrictive license. In reality, NiMUD's license sounds like they require you to follow the diku and merc licenses, plus get permission of Locke if you're going to re-distribute any of his code in a derivative. That's not very limiting in relation to other diku derivatives I've seen. Getting permission before re-distributing is the only weird thing. It's not the most open of licenses, but isn't terrible scary like the article suggested. I'm just going to add a quick thing saying that OLC is under the same license as NiMUD, and then maybe later I'll update NiMUD so that it talks about the license. I think the "no permission was granted" line sounds very anti-OLC, so I'm going to keep it but reword it slightly and just say that other users haven't followed the license when distributing their code. Misplaced Pages also shouldn't be used for keeping a running tally of who has been granted permission or not, for obvious reasons.

Ick, that's alot of stuff I wrote and researched for such a small amount of changes. Hopefully you can see exactly why I changed the parts I did though.

Locke's Clarifications to Dating

1,2,3 removed for relevance

4) The word 'beforehand' does not exist in the human language; it was a side-effect of my efforts as a youth to create 'a new language' - thus the convention of 'Darkwood' and its appearance in Wildgames' FATE. It's before hand or before-hand (arguably). This appears in earlier NiMUDs but was corrected.

5) The original message posted about his death is still visible at

6) I do not believe Thoric did not use NiMUD's OLC as a model for his own. I also think the influence of his builders on features is part of the way that the influence was transmitted. I think he should use OLC, and hereby grant him permission to do so, with his SMAUG releases. No author of a server has ever been given that permission before. The stipulations of that permission is that we are properly credited and cited and that he includes a link to The Isles webpage and email address in his documentation.

7) I think Thoric is embellishing and that is why I am here to try to state things as clearly as possible: we started playing in 1992, Chris and I started writing muds together in 1993; by 1994 we were working hard and I was getting ready to release it. I met Chris when I was 13, we had experience in BBSes. Discovering muds was amazing for us. We spent a lot of time on DuneMUSH, which influenced our design, but that was happening after the release of at least one of the earlier versions. I remember someone, and I truly believe it was the owner of ftp.game.org, Derek Snider, refused to host The Isles because the area files, which had been converted to a new file format, weren't "allowed" there, and I saw it as a direct act of sabotage.

Points 6 & 7 -- I already stated that MozartMUD had it's own online building code in 1993. If you were "working hard" in 1994, then how could your OLC have predated Mozart's online building? It sounds to me like I was developing SMAUG's online building at the same time that you were getting your OLC ready for release. --Thoric 15:56, 18 July 2005 (UTC)

It was being developed around the same time, who knows? But as I stated earlier, 'building' is different and could be a seperate article. Also, please provide some proof of this to strengthen this repository. -Locke

Proof for which? I guess we'd need statements from Mozart builders that were around in 1993 (and earlier) for that. The same probably goes for Realms of Despair. If you like I could send you a copy of build.c from August 1995 from when we first started using RCS, before switching to CVS (which you can compare to the one in the SMAUG 1.01 distribution). This would give you an idea of how advanced the code was at that time, and from looking over it, I've noticed it is pre-"mset on"/"oset on", meaning that you can't lock into an editing mode onto an object or a mobile. It wasn't added until we were preparing for the SMAUG release, and was likely added at the request of a beta tester:

revision 1.133
date: 1996/10/09 22:19:07;  author: derek;  state: Exp;  lines: +230 -27
Added lock-in modes for redit, oset and mset

I doubt I have copies of the code from 1994 (the hard-drives have been replaced a few times since then, and it didn't have its own dedicated box in 1994 either), but I can dig around and see if I can find something pre-RCS. --Thoric 23:33, 18 July 2005 (UTC)

There is no evidence for the origin of the term other than my statements, but the term at the time was "building" and Chris' term was 'creation' - or at least it was something from our vocabulary. "online building" may be a seperate article entirely, but this was the first publically released version available for any Diku variants, and any Merc variants, though it was a feature made present later in Circle and Silly (according to Thoric).

8) I tend to think but am not entirely sure that the two events; hacking of Cthulhu and later the truncating of my source code are related, but there is no way to prove that, and it may be purely coincidental activities of youthful anger and taking 'gaming' to another level.

9) The way the filesystem works in SMAUG and the way the filesystem worked in that truncated version are very similar, even if the monikers are changed. It may be that it was the next logical step for a developer to write a filesystem that way, as it basically took what the Player files were using and adapted it to the entire filesystem.

10) I have twice asked Thoric to remove all NiM5.beta* copies from his service, as they claim that I own copyrights which I do not. I apologize, but I just never filed the paperwork. I will release another copy sometime this year (probably around Christmas) which has updated documentation, but the current build is available at .

Cheers, Locke locke@mugs.net

If you live in the US, then anything you write is copyrighted automatically, even without any form of registration. This has been true since the late 80's.

Here are 2 web sites that have some useful info about copyrights:

• http://www.keytlaw.com/Copyrights/top10myths.htm
• http://www.templetons.com/brad/copymyths.html

They both are pretty accurate and match up with what I learned when I was working in an Intro to Law class.

Summary of a key point, combining quotes from both pages:

• Almost all things are copyrighted the moment they are written, and no copyright notice is required.
• No publication or registration or other action in the Copyright Office is required to secure the copyright.
• There are, however, certain definite advantages to registration.

Atari2600tim 08:50, 18 July 2005 (UTC)

oh, and of course, the Copyright article on wikipedia is great too

More on copyrights

Well, I agree with you, but one must be very careful in these days, especially for these reasons:

1) No ordinary citizens can give legal advice, so without the disclaimer in the how_to_copyright.txt I might be breaking the law.

2) he's also paying his wife to work on MudMagic.com, while he's in Baghdad(or so he is saying, it might be true, but aside from his email testimony there is no proof), and it's sad to say that, quoting Kyndig after I asked him whether or not he was interested in the truth (because he refuses to host NiMUD, but also refuses to remove source code packages that include OLC without proper credit) he responded, "I'm a 'hater'" - meaning, he hates me for what I've "done" - I suppose in other words, he's a rascist(?) and is doing things in a self-interested way, and not in the interested of the group, truth, or fairness, only, as he puts it, 'business' - he said he would sue me in 8 months when he returns from his tour as a soldier. He lacks some level of moral character, which Thoric possesses* (or atleast attempts to maintain a level of truth-preservation to the history of mudding in his later years).

His response made no sense because a) he is not the owner of Diku b) he wasn't interested in hearing my side of the story in any way and c) he moved right to the statement 'I'll sue you' - after that I asked him what sort of remuneration he thought he would desire, and he said 'his attorney would contact me' which has not happened. I think he thinks he's "fighting for the Rights of Diku" or something, but ignoring the fact that Diku has stated that, well, they don't really care anymore about Diku.

They like to censor things over there: including the forums, even for statements that are outlandish and flamish.

I guess he's just some ignorant psychopath.

I was actually referring to #10 on that list above :P It says "I apologize, but I just never filed the paperwork." Registering a copyright is not necessary and hasn't been for over 1 1/2 decades... no paperwork is required; your work is automatically copyrighted as soon as you record it somewhere outside of your brain (written on a napkin, typed into a computer, whatever). That how_to_copyright.txt file is definitely inaccurate, if you're referring to the one on ftp.game.org. In fact, almost no part of that file is correct :P I haven't checked out the stuff from http://www.mugs.net/~theisles/files/ for comparison, but I will look later. I will note that the how_to_copyright.txt file does indeed have a disclaimer about not being a lawyer, so I think it's not quite breaking the law, and is simply just misleading.

According to several sources, registration is just a better way of proving it in court as it provides recognized dates and times.

This is correct. It is not required in any way, and ONLY helps you if you go to court. If you think the date that your MUD code was created is important enough to sue over, then feel free to spend the money registering it. However, from the vastly varying dates of things claimed in this wikipedia article, it sounds to me like you would be one of the last people to want provable dates on your code. Atari2600tim 00:39, 19 July 2005 (UTC)

For the Kyndig bashing part, I'm curious...

• What is it that you're wanting proof of? That he's paying his wife or that he's out of town? It does sound a bit weird to pay his own wife, but maybe they have separate bank accounts or something? I guess we'll find out when they release their financial documents when the MudMagic.com IPO happens :)

An unlikely business arrangement. They don't have to necessarily release their records to anyone but the IRS. It is arguable that they are making any money at all- Imperian staff has admitted that they make very little from donations, and that mudding itself is not exactly a 'lucrative market'

I was pointing out the silliness at being surprised and requiring proof, when hearing that someone is paying their wife to do stuff. Perhaps if you owned stock in mudmagic.com then you would have a right to be informed of their financial decisions. Thus, we can start worrying about it when they do an IPO. :) Atari2600tim 00:39, 19 July 2005 (UTC)

Proof? I want him to recognize NiMUD and put it on his site without Diku in the title screen, as it is no longer solely under the Diku license, OR if he refuses, to remove or rectify all OLC-variant muds that didn't get permission to use the work in their packages, as this follows Kyndig's strange brand of logic. Kyndig has a one-sided view of the world. I just, at this point, would like him to leave me alone*.

The line I read says he's also paying his wife to work on MudMagic.com, while he's in Baghdad(or so he is saying, it might be true, but aside from his email testimony there is no proof)". What are you suggesting he should prove with something stronger than e-mail "testimony"? It's not unusual for someone in the military to travel, and it's not unusual for spouses with separate incomes to have separate bank accounts and such. If either one of those things were untrue, would it affect anything? If anything, him being out of the country would actually help your argument, because his wife is probably less familiar with the licensing issues than he is. If it could be proven that he is or isn't paying his wife, I have no idea how that would help prove any point :P Atari2600tim 00:39, 19 July 2005 (UTC)

I removed the negative comments about Kyndig.

• What is he claiming that you did which he's going to sue you for? I see that you asked him what he was going to request of you, but on what grounds would this request be made? It seems that at worst, he may have been tricked into temporarily hosting some illegal files, after uploading them and giving the impression that they were following the license. Since it's so easy to remove it, I doubt he would try to claim any damages on something like that.

NiMUD is not illegal*- why would that be an issue? Also, NiMUD is not distributed solely under the Diku license, and thus only follows parts of it. NiMUD is not very similar, anymore, to Diku. If you diff the files, its hardly comparible and thus could be considered New Work. He didn't say Why* - he just refused to host the files, and wants to attack me because he is psychotic. He's also hypocritical if he is going to refuse to host the OLC. He's just bullying me for his own amusement*. He says he's done this to other people and enjoys doing it - in other words, he plays a video game with people's lives; very similar to the occupation he is currently in.

Yes, this is what I'm referring to. It is derived from diku, and does not fully follow the license. We seem to agree on this. It sounds like you didn't read either of the links I gave, but #9 on http://www.keytlaw.com/Copyrights/top10myths.htm#modify addresses this issue specifically. Kyndig has every reason to believe that the files given to him are in violation of the diku license. Kyndig did say why he removed it, "Because NiMud doesn't follow the license terms, and the author didn't care to add them.". In fact, scrolling up on this very page, you said that he refuses to host it, citing license issues. So, perhaps you forgot after writing that. It is in Kyndig's interest to host only files that are legal, for obvious reasons. Atari2600tim 00:39, 19 July 2005 (UTC)

According to the U.S. Copyright website, New Work is considered the owner of the person who does the New Work. Additions are owned by the adder- so if the new work involves changing the title greeting, then that new work is owned by the new writer. Also, if you look at NiM5, you will note that not much of it is Diku. So then I own the OLC portions of all of the derived muds, who did so without permission. If he wants to be completely accurate in hosting muds that are 'legal', he must remove 90% of the derived source codes from Merc/Diku. I'd rather he just hosted them both.

• I'm impressed by how well it was handled. He's obviously not the owner of Diku, but as a promoter of the MUD community, he recognizes the need to filter the files that he distributes, and sees the benefits of checking things himself rather than forcing the burden on the original authors. "Fighting for the Rights of Diku" is much different than deleting illegal stuff off of your own computer. I understand your view: that he never asked you for your side. But, what's there to ask about? It's based on diku, and doesn't follow the rules of diku (which are fairly simple). If he should have asked you your side, what relevant info is there that he doesn't know about just from looking at it?

But a contract can have additions to it that are verbal, and if in a conversation someone adds that it doesn't matter, then it doesn't matter. Diku has stated that they don't care about the omission in the title screen, so thus, it is legal. I don't have any record of the conversation, but it was stated. Perhaps I should have logged it.

But NiMUD is not illegal, and he can't really sue me - I've asked lawyers about this and unless Kyndig would like to dump loads of money into a corporate IP lawyer ($150+ an hour) it's unlikely and even if it went to court it might be seen as a way to waste the court's time - which it would certainly be. It's not like I've demanded service, and, despite what I said earlier, I don't really care. He keeps banning me and then unbanning me to see what I'll do next, so he can catch me in some crime or something, which is just not going to happen as I will not further express anything to him, his wife, or Kyndig.com, which could be viewed as Harassment by Communication or something, but it's unlikely that it will be prosecuted, as anything that might be regarded as harassment ceased, and that it started with a request from Kyndig's wife to link them to the web page, which shows that there was an established relationship that just went south. During a conversation with mudconnect.com, when I requested service and was refused, mudconnect.com contacted my University's abuse email- the response was "We don't care" not that I recommend being belligerant or bothering people or harassing them.

I was saying that because he has every reason to think that it's illegal, it would make sense to remove it unless you bring up some reason why it's not illegal. See the above: what info is there that he is unaware of? He is not obligated to host every legal MUD file in existance, so it'd make sense for him to not host questionable files, just to be on the safe side. As far as I know, he has no grounds to sue you, and it seems doubtful that he would have made such threats based solely on the contribution of your MUD code.Atari2600tim 00:39, 19 July 2005 (UTC)

as I said earlier, I don't care if he hosts it or not. diku has said they dont care about the discrepancy. so let's just leave it at that. i have never made a penny and don't accept donations for it. --Locke

• Most of the stuff in your message there is pretty silly, no offense intended :)

Atari2600tim 18:11, 18 July 2005 (UTC)

I had time to check the official site and read the how_to_copyright from http://www.mugs.net/~theisles/files/NiM5-beta3.tar.gz and it's very very inaccurate. It says the same thing as the ftp.game.org one except for 2 paragraphs added.Atari2600tim 18:22, 18 July 2005 (UTC)

It is silly - it is intended - in some strange way, it's comedy. By the way the how_to_copyright.txt on ftp.game.org is stolen from NiMUD. Am I cited? I wrote that... but it may be illegal or perhaps, more justifiably, in bad form. Thoric has been copyrighting the work of others (arguably) for years*, ever since he copyrighted the public domain Diku Family Tree- he will undoubtably respond "I did not!" -- who knows, perhaps he's the original author from the R.G.M.D Diku Family Tree. Regardless, I have personally spoke with Diku and they made the statement (Hans or someone) that they just don't care about the title screen thing, and they liked my work. Whatever the disease is, it seems to be catching.. to quote William S. Burroughs - 'language is like a virus'