Palandian Majica

Majik 3D, the last incarnation of Majik MURPE

[ introduction | screenshots | latest news | faq | conventions | mailing lists | art gallery | bug tracking ]
[ www statistics | download | project status | features | the team | history ]

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