Note: This article is about a game aspect that it only accessible to the immortal designers, and is of no use to mortal players.
A Mudprog, sometimes called mprog, mobprog, or just prog, is a program that a builder or immortal writes to create a game-world that is deep, interesting, and interactive. This allows builders to do more than simply create maps and dump soulless characters and mundane objects in to them. Any room, mobile, object, or kflag can have a mobprog on it. Sharmair has designed a fantastic and extremely deep mudprogging system, which allows for an extremely in-depth interactive world.
Mudprog Creation Summary Edit
Several elements come in to play when dealing with mudprogs. A mudprog may interact with any number of objects, characters, rooms, and kflags. There are a number of commands to edit each type of mprog. Each mobprog is activated with a trigger. Once the trigger is triggered, the mudprog's code is executed. The code usually including ifchecks, mpcommands, regular commands, replacement tokens, and other keywords.
Mudprog Editing Commands Edit
mpstat <target> opstat <target> rpstst kpstat <vnum> mpedit <target> <command> [number] <trigger> <value> opedit <target> <command> [number] <trigger> <value> rpedit <command> [number] <trigger> <value> kpedit <vnum> <command> [number] <trigger> <value>
mpstat, opstat, rpstat, and kpstat will display the mprogs that are already on the target mobile, object, room, or kflag (respectively). mpedit, opedit, rpedit, and kpedit will work on mprogs on the target mobile, object, room, or kflag (respectively). You must be in the room which you are working on. The mobile you are working on should be in the room with you. Any object you are working on should be in your inventory.
target: either the vnum or name of target. Targets called by name should be with you.
|add||creates a new mprog|
|delete||deletes mprog number|
|creates a new mprog at number|
|edit||edit mprog number|
|list||lists the current mprogs on target by number|
trigger: the type trigger or program you wish to edit or create. For a full list of triggers, see mptriggers.
The Editing BufferEdit
When you edit or add an mprog, you are put in to the editing buffer. While it is possible to write your mprogs on-the-go in the buffer, it is much easier to write your program in notepad or any other text editor and then paste it in to the buffer. That way, you only need to remember two buffer commands, but you can edit your programs in your own time, and in a familiar, natural way. Nevertheless, here are the buffer commands:
|/l||list buffer contents|
|/c||clears the entire buffer|
|/d line||deletes a line|
|/g line||goes to a line|
|/i line||inserts a new line before line number|
|/r old new||global replace|
|/a||exit the buffer without saving|
|/! command||executes command outside the buffer|
|/s||saves and exits the buffer|
The editing buffer in PLANES supports pasting of many lines of text at once, and the maximum program length is extremely long. PLANES also supports long lines, whereas SMAUG and other codebases only allow up to 80 characters in length. This makes it much easier to simply edit your program in an outside text editor and paste it in to the game. To do so, simply enter the buffer,
Begin entering your text now (/? = help /s = save /c = clear /l = list ---------------------------------------------------------------------- >
- /c to clear whatever is already in there if you are editing or updating a prog.
- (paste your program)
- /s to save and exit the buffer.
Mprogs can use any regular mortal command to interact with characters, objects, rooms, and anything else. They can also use special //mpcommands// which are simply immortal commands which can only be used in mprogs. For a full list, see mpcommands.
It is perfectly acceptable to have a program that simply acts on a trigger. For example, if I want to have a mobile say "Hello!" every time someone enters the room, I would have a program that is just:
However, if I wanted to only say hello to people who are level 1, I would enter:
if %actor.level% == 1 say Hello! endif
This checks the actor's level, and checks if it is equal to 1. If so, the programs says Hello! If not, it does nothing. In this case, %actor.level% is a replacement token. There are many other replacement tokens. For a full list, see replacement tokens. There are other instances where you you an ifcheck. Also, == is an operator. There are other types of operators as well; for a full list, see operators. Every if must also have an endif, so don't forget to endif at the end of your if.
Suppose you want to have something to happen if the character isn't level one?
if %actor.level% == 1 say Hello! else say Hi! endif
Here, else tells the program what to do if the if's conditions aren't met. Remember to always close with endif.
For more choices, you can use elseif.
if %actor.level% == 1 say Hello! elseif %actor.level% == 2 say Hey! else say Hi! endif
If the character is level 1, the programs says "Hello!" If they are level 2, the programs will say "Hey!" If they are any other level, the programs says "Hi!"
switch, case, break, doneEdit
You may have a situation where there are a great many possibilities for a particular replacement token or ifcheck. It may be simpler to just use a switch, like so:
switch %actor.level% case 1 say Hello! break case 2 say Hey! break case 3 say Hi! break case 4 say Huh? break default greet %actor% break done
Use switch <condition> to set a condition. In this case, the condition is the character's level, %actor.level% Then use case <condition> to compare against the original condition. Use break to exit the switch. If you do not use break, the switch will continue to go through all the conditions, even if they are false! At the end, instead of a case, there is default, which means anything else.
Always close the switch with done!
The halt keyword immediately ends the flow of the current program. If you are in a subprogram, it will return flow to the program where the call came from.
Subprogs and callEdit
Often, you will have a program that you will want to execute the same code in many cases. A great way to avoid re-writing the same code over and over (and fix it over and over if you want to change it) is to call a subprogram. For instance, if I wanted my NPC, named barmaid, to say "hello" every time someone over level 10 waved, greeted it, smiled at it, or said hi or hello, I would:
mpedit barmaid add sub hello10
if %actor.level% > 10 say Hello! endif
Then I would create act and speech triggers for greeting, waving, smiling, and saying hi and hello, and simply have each trigger consist of:
Now, if I want to change her to greet the person by name, saying "Hello, %actor.name%!" I only have to change one program instead of five.
Subprogs can also be called (and take a return value) as a replacement token: %call.subname% . . . more on that later. Subprogs are also very handy for organizing how you think about your progs. Use subprogs as much as you possibly can!
return and setreturnEdit
The return keyword is used in mprogs to return a value and end the program.
return *same as halt return 0 *when used in COMMAND or LEAVE progs, cancels input return whatever *useful for subprogs
return with no argument is just the same as halt, simply ending the program. In command and leave mprogs, return 0 will override the player's input, so their command or movement will not go through. The third example could be the return value of a subprog, called using %call.subprogname%. In this example, %call.subprogname% is a replacement token for whatever. Whatever can be anything, even another replacement token. In this way, subprogs can be used like functions in traditional programming languages.