The History of Majik
In the beginning
In the beginning of computers there were no graphics, there were big servers,
usually UNIX or even VMS and then there were small text-based terminals used
to connect to those servers. The terminals were only capable of displaying
vertically flowing text. There weren't any special control characters.
All you could do was to scroll the text and sometimes add some characters
to the stream.
Will Crowther was the one one who discovered that it was possible to have some
fun with those primitive terminals - he wrote the first adventure game ever,
called Adventure, a single-user text-based game. It quickly grew to be very
popular, especially since it was packaged with a UNIX distribution from
Berkeley. It was soon in all the universities using UNIX from Berkeley.
It looked like this:
The time of MUDs
The game was usually played on multi-user UNIX networks. What if
simultaneously playing Adventure players could see each other and interact?
This idea gave birth to MUDs (Multi User Dungeons). MUDs are generally nothing
more than just Adventure-clones with multi-user support, and an environment
that is loosely based on a role-playing game called Dungeons & Dragons. In
Adventure, one could only collect points from solved quests while in MUDs one
killed monsters to gain experience points, and by experience points gained
levels, and by levels gained power, and by power became a more efficient killer
until he was powerful enough to became a wizard, an immortal being who was able
to extend and further develop the gaming world. One of the most popular and
advanced MUDs ever is a BatMUD, which looked like this in 1999:
Adventure's story was linear, only one main quest after which the game was
over. MUDs usually had no story at all, the only way to "play it over" was to
achieve wizardhood by simply killing monsters, even the same monsters day after
day. It was simple, usually quite boring after the initial charm of
novelty, and usually took years to become something more than just a
newcomer. Without the ability for players to interact with other players, MUDs wouldn't
have survived this long; they would have been forgotten history like the
Adventure game is now.
Majik
In the year 1999 there were 1315 active MUDs listed in the world's largest
MUD-listing (http://www.mudconnect.com), and in fact, they're all basically
based on the same old idea. Some offer "roleplaying" more than others, some do
not offer roleplaying possibilities at all, simply monster-whacking. Some are
based on killing players instead of monsters and some are only social
environments, chatting places more than games. This static situation was the
main inspiration for the creation of Majik. We wanted to make a different MUD,
based on the same user interface as Adventure and all other MUDs, but not
inheriting the idea of experience-based advancement by killing monsters. We
wanted to create a world where players could really live, a world as real as
possible, ultimately offering the best roleplaying atmosphere.
NetRPG
Before first version of Majik in the year 1994 or so, there were some tests of
a turn-based MUD game distributed in an UUCP-network, thus all the BBS's in
the network could have their players join the game. All players could have had
something like one to three turns per day, and they would have lost their turn
if they hung up or died. They could have seen the other players even if they
were not online, they could send messages to them, kill them or whatever. Then
when the player would become interactive, he/she could have seen a report of
what happened yesterday. It was initially called NetRPG, created by Jarko
Nikolai Riikonen, "Werc" for short, and then it evolved in a game called
NetHunt, created by the original creator of Majik. It was the first effort.
Majik1
The first version of Majik (Majik1) called "Unreal Reality MUD" was opened in
the year 1995 in a BBS (Bulletin Board System) owned by the original creator
of Majik. It was simple and not very multi-user since the BBS had only one
phone line, allowing only two players to be in the game at a time.
Majik2
The second version of Majik (Majik2) was the first version to be
truly publicly available to the whole Internet and was the first version
that was called by the "Majik" name, given by Teemu "Shinael"
Peltola. It quickly grew to be quite popular as a small MUD, despite the fact that
it was a very new one, had been online for only few weeks, and
had not been systematically advertised. It was based on the same code as
Majik1, a Diku MUD engine, which was just too restricting for our use.
Majik3
When Majik2 was almost ready, we saw that what we already had was not enough
and moved to a new engine, LPMUD, which allowed modifying the code on the
fly without needing to reboot the server after each change. It was time for
Majik3, which was started from scratch, as every version of Majik had been,
unlike other MUDs which were usually (99.9% or so) based on a ready world,
thus decreasing the diversity even more. Majik3 was the most largest and
most versatile of all the Majik versions so far, and all of our great ideas
got developed there, including the idea of "gridmap" which then led to the
development to the fourth major version of Majik.
Majik3 was the first version of Majik to introduce the gridmap system borrowed
from "roguelike" games, such as Nethack. In MUDs (and Adventure) the game
consists of rooms. All rooms have a description telling what the room looks
like and after the description comes a short description of objects, such as
items and players in the room. Majik3 did show all those, but
it showed the room from a top-down perspective. However, the view was only
cosmetic and merely served as a clarifying factor as you couldn't
move within the room. It looked like this:
It was also possible to show the mini-maps of all the nearby rooms, thus
forming a larger map of the area, which was actually quite useful too. It
looked like this:

As we tried to make Majik3 as realistic as possible, we couldn't forget the sky,
stars, moons and a sun orbiting the planet Majik. This is how the sky looked
at night (during the day there was a sun and a blue sky without visible stars):

Majik3 was also the first incarnation of Majik which had a real worldmap. The worldmap was separate from
the areas. One grid in the worldmap equaled one kilometer, and inside "areas"
such as cities etc, one grid equaled only one meter. It was highly
unrealistic - a player could walk 100 kilometers just in minutes - but
unfortunately it was not possible to do anything better. No one would want to
type "north" 1000 times in order to advance a single kilometer.

Descriptions for what the grid symbols in the worldmap mean:

Majik4
When Majik3 was opened for public alpha-testing, nearing pre-beta testing,
we saw that we really wanted to use all possibilities given by the gridmap
system. We wanted characters to be able to actually move within the rooms and
we wanted to remove the "all rooms are square" limitation. We wanted real
caverns, roads, woods and such. Of course, Majik3 had all those but they were
only described in the long and/or short descriptions of the "room", so it was
necessary for the user to read them through, otherwise the user had little
chance of knowing in what kind of environment he/she was wandering. The
little gridmap "window" at the left side of the room's long description told
only in which directions there were exits from the room, and whether the room
was indoors or outdoors.
We actually coded such a system to Majik3, but it didn't quite work as we
wanted. Telnet protocol with VT100 or similar terminal emulation can do screen
clears and move the cursor, but most of our users used MUD-clients such as
TinyFugue or zMUD, so we couldn't use those. It was a bit funny: when the user
moved a single grid, Majik always sent the entire mini-map of the area to the
user which resulted in quite a spam. Besides, we couldn't simply modify
the system so that a user could immediately see if someone moved on the
map since it would have created a horrible flood of text, so the users had to
type "look" quite often. Yes, it would have "worked" this way, but it would
have needed more than a little recoding, because the whole thing was coded to
support rooms, not gridmap. All systems, from the battle system to the area building
system would have had to be recoded. It would have taken months.
First we decided we would still use the mud-like system, but would change to use
the DGD LPC driver from MudOS and code the whole thing from scratch. We also
decided to wipe out all of our nearly 100 "coders" of Majik3, and to only keep
four of the best: Namhas,
Dazzt,
Yorkaturr and
Harum All others who showed some
serious eagerness with the project were assigned as designers. Their job was
to design the world: the worldmap and it's places, history, mythology,
player/monster races, pantheon of gods, magic and such things. However,
mud-like Majik4 on DGD driver did not show any progress and we decided to end
the project and start another one. This time we decided it would be a real
roguelike game like Nethack, ADOM and such. It would require it's own
client but the server would still use MudOS, thus allowing the coders to code
it with the language they're extremely familiar with: LPC. So the real Majik4
was begun. Eventually we reached a point where it looked like this:
Majik4's development was much better planned than Majik3's. We didn't just
blindly code whatever we wanted, we instead aimed for certain milestones and
didn't code anything "outside" them, avoiding the "collapsing tower"
-phenomenon which happened with Majik3. It took about a half a year for us to
to reach the point where the base code for the server was ready and the client
was almost fully ready too, so it wouldn't require any major changes anymore
and the coders could direct their power only to the server's development. From
a coder's point of view, Majik4 was actually ready at the time. All was
working, stable and ready except the world itself. The designers we had
arranged had actually done nothing. We expected a ready world which we could
code to be true when the base code was ready, but we got nothing. We would have
been satisfied with Majik4, despite the limitations of the engine found within
the development, but as we had no world, we had nothing wise to do.
Majik4's developers started improving the client and the server while waiting
for the designers to do something and at the end we saw nothing but the
extreme urge to break the limitations of our engine by one way or the other
while still using the same server, as we didn't really want to start the whole
project from scratch again! The first, most serious limitation was that we had
no unlimited amount of tiles The ASCII characters we were using as
tiles weren't enough, we actually ran out of them! We decided to break that
limitation by coding a 2D tile-based, graphical client, so we coded its
base. It looked like this:
Well, then we remembered the other limitation which we wanted to break. A 2D
engine allowed no chance for height differences in the landscape. We
could never have real mountains, we only could have some stupid mountain
terrain, which would only have the mountain's colors in a pattern and
then trying to walk over it would result in the server informing something
like "You can't pass". That would have worked if we had used 1km x 1km scale,
but we used 1m x 1m scale! No mountain is so steep from every angle. So then
we coded a 3D isometric client, this time using Java. It looked like this:
Then we found a new problem with the 3D isometric engine: one could end up
behind the mountain! See the screenshot above. There is some "flat" terrain,
no grid there is more slanting than 45 degrees and if we break the 45 degree
barrier, then we can have some real mountains such as in the bottom-right
corner, but there is the problem also. One could end up behind the mountain,
and thus, the player wouldn't be able to see his own character.
There were two ways to solve it: a "mountain hiding" system, which would make
the mountain transparent if there would be something to see behind the
mountain, and another way would be making the client truly 3D so it could be
rotated in any way.
Majik 3D
We selected the second way to solve it. We decided to do a real 3D Majik.
At this point we actually decided to throw out most of the textual
descriptions as well and realized that it is more convenient to represent the
surroundings in a more visual way: the gridmap. The 3D engine actually does
exactly the same thing, except it has an unlimited amount of tiles and it has real
height differences. It is just a little more versatile, nothing more. The
graphics never will be the major factor using which we try to impress our
users, the versatility and the world - the roleplaying atmosphere and realism
is the factor. Compare them! In text-based the user could only see "It starts
to rain", it wouldn't really matter to the user in any significant way. Coding
penalties for raining would have been just so vain. In a graphical environment, the user can
actually see the rain. It will block their visibility; it will
really matter to the user. Do you really want to see, for example, a text
saying "Wow, you see for miles and miles.", instead of seeing it for real? :)
Also, in a text-based mud-like system there is no meaning to where you stand
in the battle. There is only one room where there's a monster and then
there's the exp-maker trying to kill it. A graphical system brings more
tactical possibilities. A group of players can set their characters
to be in various tactical places, surround the monster, and, for example,
archers and spellcaster can hide behind some nearby tree and so on.
This is the last and final incarnation of Majik MURPE and it looks like
this:
Majik Development Team
Mon 17 January 2000
|