#HELPFILEDATA
colourcode `
security 7
END
#HELPENTRIES
keyword MOBPROG MOBILE-PROGRAMS~
level 1
category undefined~
text `+
Usually mobiles never do anything but wait to be slaughtered, unless
someone has added many special procedures called mobile programs. The
backbone of the mobile programs is called `#`Ytriggers`^, essentially
they are procedures calls which provide the context for what is going
on around the mobile. So if something happens in the mobile's room and
a trigger is activated, then a list of `#`Ycommands`^ is sent to the
interpreter in the mobile's name, thus making her/it/him do an
appropriate something.
Since knowing the appropriate response for every mobile to every
possible trigger is not easy, this command list shouldn't be a rigid
script, but needs to be somehow unique for the mobile and the situation
However, in order to know the situation, a mobile needs to know more
about the trigger than that it just happened. So we have to include
some sort of `#`Yvariables`^, as well as to set the context appropriately.
`+
`+
`#`CSEE-ALSO: `=_TRIGGERS`+, `=_VARIABLES`+, `=_MPCOMMANDS`+, `=_IF_CHECKS`+, `=_OPERATORS`+,
`=_MPSYNTAX`+, `=_MP-BUILDING`+, `=_MPEXAMPLES`+.`^
~
END
keyword TRIGGERS~
level 1
category undefined~
see_also VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES~
text `+
Triggers' Summary:
`+
`#`r-----------------------------------------------------------------------------------------
`+
`YTRIGGER `=?ARGUMENT`+
`+
`YACT`=? <string>`r..............`=?to match in a message on screen
`YSPEECH`=? <string>`r..............`=?to match in dialogue (say, tell) to mobile
`YRANDOM`=? <percent>`r.............`=?chance to check from time to time
`YGREET`=? <percent>`r.............`=?chance to check if a visible char enters mobile's room
`YGRALL`=? <percent>`r.............`=?chance to check when any char enters the mobile's room
`YENTRY`=? <percent>`r.............`=?chance to check when mobile moves to a new room
`YEXIT`=? <direction number>`r....`=?a visible char tries to exit the mobile's room
`YEXALL`=? <direction number>`r....`=?any char tries to exit the mobile's room
`YGIVE`=? <object name or vnum>`r.`=?to match when the object is given to mobile
`YBRIBE`=? <integer>`r.............`=?minimum amount of silver coins given to mobile
`YKILL`=? <percent>`r.............`=?chance to check when the mobile begins fighting
`YFIGHT`=? <percent>`r.............`=?chance to check at fight_pulse if mobile is fighting
`YHPCNT`=? <percent>`r.............`=?lower than mobile's hit/max_hit if mobile is fighting
`YDEATH`=? <percent>`r.............`=?chance to check after mobile has been slain
`YDELAY`=? <percent>`r.............`=?chance to check if the delay expires
`YSURR`=? <percent>`r.............`=?chance to activate when a char surrenders to mobile
`YREPOP`=? <percent>`r.............`=?chance to activate when the mobile is loaded on the room
`YROOMDEATH`=? <percent>`r.............`=?chance to activate when something dies in the room
`YTICK`=? <percent>`r.............`=?chance to activate when the tick changes
`YHOUR`=? <game hour>`r...........`=?to match when the game hour changes
`+
`r-------------------------------------------------------------------------------------------`^
`+
`+
SEE ALSO: TRIGGER_<TRIGGER NAME>
~
END
keyword ACT TRIGGER_ACT~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES SAY YELL EMOTE~
text `+
`#`=lSyntax:`^ `#`WACT`^ `#`R<string>`^
`+
The argument is a phrase, a text string. The trigger is activated
whenever the phrase is contained in the screen message. This is a most
general trigger and applies to almost every event which happens in the
mud, But the output of "say", "yell" and "emote" do not trigger this
event.
You can use only one word or a whole phrase, but to use a whole
phrase you need enclose it between quotes (''), be sure to know how the
message appears on the screen, to set this trigger and make the program
work properly.
`+
`#`BExamples:`^
`+
`#`WACT `Rflees`^
When the message "...flees..." appears on the screen, the trigger
will be activated.
`+
`#`WACT `R'has arrived' `^
When the message "...has arrived..." appears on the screen,
the trigger will be activated.
~
END
keyword TRIGGER_SPEECH~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES~
text `+
`#`=lSyntax:`^ `#`WSPEECH`^ `#`R<string>`^
`+
The argument is a phrase, a text string, this is only activated
when the phrase is contained in a message which has been said by a
player character (PC) in the same room as the mobile, this doesn't
work with 'yells'. The PC restriction is not necessary, but
infinite loops between two talking mobiles is impossible.
You can use only one word or a whole phrase, but to use a whole
phrase you need enclose it between quotes (''). Be sure to choose a
suitable word or phrase, because the trigger will be activated no
matter if a PC has said the word/phrase to the mobile (to trigger
the mobprog) or to another PC in the same room as the mobile, which
who he is talking about something else using the same word/phrase.
`+
`#`BExamples:`^
`+
`#`WSPEECH `Rhello`^
This trigger will be activated when the mobile hears someone in the
same room says the word hello.
`+
`#`WSPEECH `R'please open the door!' `^
This trigger will be activated when the mobile hears someone in the
same room says the phrase 'please open the door!', this trigger checks
the whole phrase, even the periods.
`+
~
END
keyword TRIGGER_RANDOM RANDOM~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES PULSE-MOBILE MOB_ACT_UPDATE_ALWAYS MOBPROGRAM_LIST~
text `+
`#`=lSyntax:`^ `#`WRANDOM`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100. This trigger is checked
at each `#`YPULSE_MOBILE`^ and if the argument is greater than a
percentage roll the trigger is activated. This will happen even if there
is no player character (PC) in the room with the mobile, but there must
be players in the same area. To activate this trigger without PCs inside
the area you need include the act flag `#`Yupdate_always`^ on the mobile.
Note that if the mobile has two random triggers and the first trigger
in the `#`YMOBprogram list`^ has an argument of 100, the other random
trigger will never be activated, no matter if you set it to 100 too.
It is very nice give a personality to a mob to make it more alive, but
don't set the argument too high to avoid spams. See the mobile doing
something different is nice, but after some time see the mobile doing
it over and over is annoying.
`+
`#`BExamples:`^
`+
`#`WRANDOM `R20`^
This trigger will be activated if the percentage roll is lower than 20.
`+
`#`WRANDOM `R100`^
This trigger will be activated each PULSE_MOBILE, because the percentage
roll will always be lower than 100.
`+
~
END
keyword TRIGGER_GREET TRIGGER_GRALL~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES MOB_AFF_DETECT_HIDE MOB_AFF_DETECT_INVIS~
text `+
`#`=lSyntax:`^ `#`WGREET`^ `#`R<percent>`^
`#`WGRALL`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100. This trigger is checked
whenever someone enters the room with the mobile, and the mobile saw
the person enter, this means that the mobile will not see hiding,
invisible or sneaking people, if the mobile has not the affect flag
`#`Ydetect_hide`^ and/or `#`Ydetect_invis`^.
If the argument is lower than 100, the trigger will be activated if
the percentage roll is lower than the argument. The greet trigger
activates only when the mobile is not busy (fighting, sitting, sleeping,
etc.).
If you want be sure to catch all the players, no matter if they
are hiding, sneaking or invisible use the trigger grall. The grall
trigger will be activated even if the mobile didn't see the arrival
or is busy.
Remember that only some mobiles are able to see hiding/sneaking/
invisible players, so please don't abuse the grall trigger, a normal
human citizen wouldn't be able to see those players, but a powerful
mage would be able to see them.
`+
`#`BExamples:`^
`+
`#`WGREET `R30`^
This trigger will be activated when someone enters the room with the
mobile, the mobile saw the person enter, the mob is not busy and the
percentage roll is lower than 30.
`+
`#`WGREET `R100`^
This trigger will be activated when someone enters the room with the
mobile, the mobile saw the person enter, and the mob is not busy.
`+
`#`WGRALL `R30`^
This trigger will be activated when someone enters the room with the
mobile, and the percentage roll is lower than 30, no matter if the
mobile is busy or not able to see the person.
`+
`#`WGRALL `R100`^
This trigger will be activated when someone enters the room with the
mobile, no matter if the mobile is busy or not able to see the person.
`+
~
END
keyword TRIGGER_ENTRY~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES SILVER GOLD~
text `+
`#`=lSyntax:`^ `#`WENTRY`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100. This trigger is the
opposite of the greet trigger, whenever the mobile itself enters
a new room and the percentage roll is lower than the argument this
trigger is activated.
One important thing to remember is that in the entry program,
the mobile can only refer to a random PC (the `#`Yvariable`^ $r in
`#`YIf_checks`^), there is no way to know how many PCs exist in the
room the mobile enters! Also, you must check the visibility of the
target in your program, because even if the player is hiding/sneaking
or invisible the mobile will be able to see them, even if the mobile
doesn't have the affect flag `#`Ydetect_hide`^ and/or `#`Ydetect_invis`^.
`+
`#`BExamples:`^
`+
`#`WENTRY `R30`^
This trigger will be activated when the mobile enters a new room
and if the percentage rolls is lower than 30.
`+
`#`WENTRY `R100`^
This trigger will be activated when the mobile enters a new room.
`+
~
END
keyword TRIGGER_EXIT TRIGGER_EXALL~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES MOB_AFF_DETECT_HIDE MOB_AFF_DETECT_INVIS MOB_TRANSFER MOB_GTRANSFER~
text `+
`#`=lSyntax:`^ `#`WEXIT`^ `#`R<exit number>`^
`#`WEXALL`^ `#`R<exit number>`^
`+
The argument is the exit number:`+
`+
`#`RNORTH`Y 0 `RUP `Y4 `RNORTHEAST `Y6`+
`REAST `Y1 `RDOWN `Y5 `RSOUTHEAST `Y7`+
`RSOUTH `Y2 `RSOUTHWEST `Y8`+
`RWEST `Y3 `RNORTHWEST `Y9`^`+
`+
This trigger is the opposite of the entry trigger. This is activated
when a PC tries to leave a room through an exit indicated by the argument,
and the mobile sees the person leave. This means that the mobile will not
see hiding, invisible or sneaking people, if the mobile has not the affect
flag `#`Ydetect_hide`^ and/or `#`Ydetect_invis`^. An exit trigger works
better than an entry trigger, since you can refer to a specific PC instead
of a random PC.
One important thing to remember is that if this event is triggered, the
victim will not move through the exit. If necessary, you must move the
character yourself in your program (using the commands `#`YMOB TRANSFER`^
or `#`YMOB GTRANSFER`^). Also this event is not triggered when a character
flees from combat, if the mobile is not in its default position or if the
mob is busy (fighting, sitting, sleeping, etc.).
If you want be sure to catch all the players, no matter if they are
hiding, sneaking or invisible use the trigger exall. The exall trigger will
be activated even if the mobile didn't see the person trying to leave or if
the mobile is busy.
Remember that only some mobiles are able to see hiding/sneaking/
invisible players, so please don't abuse the exall trigger, a normal
human citizen wouldn't be able to see those players, but a powerful
mage would be able to see them.
`+
`#`BExamples:`^
`+
`#`YEXIT `R0`^
This trigger will be activated when the mobile see someone trying to
leave the room through the north exit.
`+
`#`YEXALL `R9`^
This trigger will be activated if someone is trying to leave the room
through the northwest exit.
`+
~
END
keyword TRIGGER_GIVE~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES VNUM MOBPROGRAM_LIST~
text `+
`#`=lSyntax:`^ `#`WGIVE`^ `#`R<string>`^
`#`WGIVE`^ `#`R<object vnum>`^
`+
The argument is either a string containing words to be matched against
the keywords of the object name, or the word 'all'. The argument can be
the virtual number (`#`YVNUM`^) of a single object too.
This is triggered whenever something is given to the mobile. Since
the first trigger is the only one of the type which is processed, the
'all' argument in the script at the end of the `#`YMOBprogram list`^ is
essentially a default response.
To set a trigger using two words don't forget the enclose it between
quotes (''). Take care when you use the keywords of the name of the object
to trigger the mobile program, if the name has two words, the program will
be triggered if at least one word match the name of the object, see the
example bellow:
`+
`#`BExamples:`^
`+
`#`WGIVE `R'long sword'`^
This trigger will be activated if someone gives an object which has as
name's keyword long sword, or a long bow, or a small sword, etc. to
the mobile. Note that at least one word need match the keyword.
`+
`#`WGIVE `R250 `^
This trigger will be activated if someone gives the object which virtual
number (`#`YVNUM`^) 250 to the mobile.
`+
`#`WGIVE `Rall `^
This trigger will be activated if someone gives any object to the mobile,
except money, which has a proper trigger.
`+
~
END
keyword TRIGGER_BRIBE~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES SILVER GOLD~
text `+
`#`=lSyntax:`^ `#`WBRIBE`^ `#`R<number>`^
`+
The argument is any positive integer number, this trigger can be
activated whenever money is given to the mobile. If the amount given
exceeds the number, then the commands are processed. Note that the
argument of 1 would act as a default response. Also note that if the
script is not triggered (because of too little money having been
given), the mobile still keeps the money.
For this bribe trigger the amount to be given is converted to
`#`Ysilver`^ coins with the rate of 1 `#`Ygold`^ = 100 silver, thus the number
in the argument should be the expected amount in silver coins.
`+
`+
`#`BExamples:`^
`+
`#`WBRIBE `R50`^
This trigger will be activated if someone gives 50 silver coins or
more to the mobile.
`+
`#`WBRIBE `R1 `^
This trigger will be activated if somone gives any amount of silver
coins to the mobile.
`+
`+
~
END
keyword TRIGGER_KILL~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES~
text `+
`#`=lSyntax:`^ `#`WKILL`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100, this trigger is checked
whenever a PC attacks the mobile. The check occurs onle once, in the
beggining of the combat, and if the percentage roll is lower than the
argument the trigger is activated.
`+
`#`BExamples:`^
`+
`#`WKILL `R20`^
This trigger will be activated if a PC attacks the mobile and if the
percentage roll is lower than 20.
`+
`#`WKILL `R100 `^
This trigger will be activated if a PC attacks the mobile.
`+
~
END
keyword TRIGGER_FIGHT~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES PULSE-VIOLENCE~
text `+
`#`=lSyntax:`^ `#`WFIGHT`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100, this trigger is checked
every `#`YPULSE_VIOLENCE`^ when the mobile is fighting, in each PULSE_
VIOLENCE only one trigger of this type can be sucessful, to save time,
if the percentage roll is greater than the argument the trigger is
activated.
For example if you have four fight triggers on the same mob, every
PULSE_VIOLENCE those triggers are checked, if one is sucessful, only
this sucessful trigger is processed and no other fight trigger is
checked in the same PULSE_VIOLENCE.
`+
`#`BExamples:`^
`+
`#`WFIGHT `R20`^
This trigger will be activated every PULSE_VIOLENCE in which the mobile
is fighting and if the percentage roll is lower than 20.
`+
`#`WFIGHT `R100 `^
This trigger will be activated every PULSE_VIOLENCE while the mobile
is fighting.
`+
~
END
keyword TRIGGER_HPCNT TRIGGER_HIT_POINT_PERCENTAGE~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES MOBPROGRAM_LIST PULSE-VIOLENCE~
text `+
`#`=lSyntax:`^ `#`WHPCNT`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100, this trigger is checked
at each PULSE_MOBILE when the mobile is fighting, it is activated if the
hit points of the mobile are below the given percentage. If you want
include more than one hpcnt trigger on the same mobile it should be listed
in the `#`YMOBprogram list`^ in increasing order of percent since a 40%
will always be activated before a 20%, and only the first sucessful trigger
is performed. In the mobile stats we should have:
`+
`#`yMOBPrograms for [ 3000]:`+
Number Vnum Trigger Phrase`+
------ ---- ------- ------`+
[ 0] 3000 HPCNT 20`+
[ 1] 3001 HPCNT 40`^`+
`+
In this case when the mobile hp reachs 40% the mobprogram 3001 will be
processed and when it reachs 20% the mobprog 3001 will be processed.
`+
`#`BExamples:`^
`+
`#`WHPCNT `R20`^
This trigger will be activated if the hit point of the mobile is below
20% of its total hit points, while the mobile is fighting.
`+
`#`WHPCNT `R40`^
This trigger will be activated if the hit point of the mobile is below
40% of its total hit points, while the mobile is fighting.
`+
~
END
keyword TRIGGER_DEATH~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES SILVER GOLD~
text `+
`#`=lSyntax:`^ `#`WDEATH`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100. When the mobile dies, if
the percentage roll is greater than the argument the mobile performs the
MOBprogram commands (`#`YMPCOMMANDS`^) rather than the usual death cry
sequence. This is done before the corpse is made, so the command can be
considered the mobile last gasp. The position of the mobile is set to
`#`YSTAND`^, and so it can do all the normal commands, without worrying
about being `#`YDEAD`^. However even if the mobile restores itself to full
hit points, it will still die.
`+
`#`BExamples:`^
`+
`#`WDEATH `R20`^
This trigger will be activated if the mobile dies and if the the
percentage roll is lower than 20.
`+
`#`WDEATH `R100`^
This trigger will be activated when the mobile dies.
`+
~
END
keyword TRIGGER_DELAY~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES SILVER GOLD~
text `+
`#`=lSyntax:`^ `#`WDELAY`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100, this trigger is activated
when the delay of a mobile (set with the `#`YMOB DELAY`^ command) expires.
For example, the mob is processing a program and in its code has the
command:`+
`+
`#`y MOB DELAY 20`^`+
`+
When this timer 20*`#`YPULSE_MOBILE`^ expires the program will check
the delay trigger:`+
`+
`#`yMOBPrograms for [ 3006]:`+
Number Vnum Trigger Phrase`+
------ ---- ------- ------`+
[ 0] 3009 DELAY 20`^`+
`+
If the percentage roll is lower than 20, the program 3009 will be
executed.`+
A mobile can have several delay triggers, but every time the delay
timer expires, all the triggers are checked and the first sucessful one
is executed.
`+
`#`BExamples:`^
`+
`#`WDELAY `R50`^
This trigger will be activated if the mobile is processing a program which
has the command MOB DELAY and its timer has expired (timer*PULSE_MOBILE)
and if the percentage roll is lower than 50.
`+
`#`WDELAY `R100`^
This trigger will be activated if the mobile is processing a program which
has the command MOB DELAY and its timer has expired (timer*PULSE_MOBILE).
`+
~
END
keyword TRIGGER_SURR TRIGGER_SURRENDER~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES SURRENDER MOB_KILL~
text `+
`#`=lSyntax:`^ `#`WSURR`^ `#`R<percent>`^
`+
The argument is a number between 0 and 100, this trigger activates
when the mobile is fighting and the opponent issues a '`#`Ysurrender`^'
command, and if the percentage roll is greater than the argument.
When triggered, both parties will cease fighting, and the mobile can
accept the surrender. Note that if the mobile does not accept the
surrender, it must resume the fight with `#`YMOB KILL`^.
If the character surrenders and the mobile does not have a surrender
trigger, or the trigger does not activate, the fight resumes.
`+
`#`BExamples:`^
`+
`#`WSURR `R20`^
This trigger will be activated if the enemy surrenders and if the
percentage roll is lower than 20.
`+
`#`WSURR `R100 `^
This trigger will be activated if the enemy surrenders.
`+
~
END
keyword TRIGGER_REPOP~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES MOB_OLOAD~
text `+
`#`=lSyntax:`^ `#`WREPOP`^ `#`R<percent>`^
`+
The argument is a percentage, This trigger is checked when a mobile
is loaded in an area reset, and if the percentage roll is greater than
the argument the trigger is activated. Could be used for such things as
saying something, or loading an object, etc. It is a good trigger for
making mobiless load "rare" objects.
When this repop trigger gets activated, the mobile will not have any
of its equipment set on it yet, so if the mobile needs give an object it
should load it first with the `#`YMOB_OLOAD`^ command.
`+
`#`BExamples:`^
`+
`#`WREPOP`^ `#`R3`^
This trigger will be activated when the mobile load itself because of an
area `#`Yreset`^ and if the percentage roll is lower than 3.
`+
`#`WREPOP`^ `#`R100`^
This trigger will be activated when the mobile load itself because of an
area reset.
`+
~
END
keyword TRIGGER_ROOMDEATH~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES DEATH KILL OBJ_TYPE_TOKEN~
text `+
`#`=lSyntax:`^ `#`WROOMDEATH`^ `#`R<percent>`^
`+
The argument is a percentage, this trigger will be checked if
something in the mob's room gets killed, and when the percentage roll
is greater than the argument it will be activated. The mobile should be
able to hear the death cry in the room, if the mobile is sleeping it
doesn't get triggered.
The main function of this trigger is for work with the `#`Ytoken`^ system.
The killer can be refered as who activated the trigger (`#`Y$n`^).
`+
`#`BExamples:`^
`+
`#`WROOMDEATH`^ `#`R20`^
This trigger will be activated when something gets killed in the mobile's
room and if the percentage roll is lower than 20.
`+
`#`WROOMDEATH`^ `#`R100`^
This trigger will be activated when something gets killed in the mobile's
room.
`+
~
END
keyword TRIGGER_TICK~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES TICK~
text `+
`#`=lSyntax:`^ `#`WTICK`^ `#`R<percent>`^
`+
The argument is a percentage, this trigger is checked at each `#`Ytick`^
change and if the argument is greater than a percentage roll the trigger
is activated. This will happen even if there is no PC in the room with the
mobile. It will be activated no matter the position of the mobile (resting,
sleeping, etc.). It is not a good trigger to interact with players, since
players don't activate this trigger and some variables (`#`Y$n`^) would not work
properly, but the random variable (`#`Y$r`^) works fine.
`+
`#`BExamples:`^
`+
`#`WTICK`^ `#`R20`^
This trigger will be activated when the tick changes and if the percentage
roll is lower than 20.
`+
`#`WTICK`^ `#`R100`^
This trigger will be activated in each the tick changes.
`+
~
END
keyword TRIGGER_HOUR~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES TIME~
text `+
`#`=lSyntax:`^ `#`WHOUR`^ `#`R<game hour>`^
`+
The argument is the game hour (0-23). This trigger will be activated
when the game hour matchs the argument used in the trigger. As the tick
trigger, it is not a good trigger to interact with players, but the random
variable ($r) still works. This trigger will be activated no matter the
position of the mobile (sleeping, resting, sitting, etc).
`+
`#`BExamples:`^
`+
`#`WHOUR`^ `#`R6`^
This trigger will be activated when the game hour is 6 am.
`+
`#`WHOUR`^ `#`R12`^
This trigger will be activated when the game hour is 12 am.
`+
`#`WHOUR`^ `#`R18`^
This trigger will be activated when the game hour is 6 pm.
`+
`#`WHOUR`^ `#`R0`^
This trigger will be activated when the game hour is 12 pm.
`+
~
END
keyword OPERATORS~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS MPSYNTAX MP-BUILDING MPEXAMPLES~
text `+
Most of the basic numeric operators are legal and perform the same
function as in C.
`+
The Operators are:
`+
`#`Y<`r......`^is less than
`#`Y>`r......`^is greater than
`#`Y==`r.....`^is equal to
`#`Y!=`r.....`^is not equal to
`#`Y<=`r.....`^is less than or equal to
`#`Y>=`r.....`^is greater than or equal to
`+
`+
~
END
keyword VARIABLES MP-VARIABLES MOB-VARIABLES~
level 1
category undefined~
see_also TRIGGERS MPCOMMANDS IF_CHECKS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES MOB_REMEMBER MOB_FORGET~
text `+
To make things came alive, variables are needed. These are respresented
in mobile programs by using a dollar sign convention, when the mud command
is processed, those variables are expanded into the values shown below.
`+
`#`r-----------------------------------------------------------------------
`^`+
`#`YVARIABLES`^`+
`+
`#`Y$i`r....`^the first of the name of the mobile itself`+
`#`Y$I`r....`^the short description of the mobile itself`+
`#`Y$n`r....`^the name of whomever caused the trigger to happen`+
`#`Y$N`r....`^the short description of whomever caused the trigger to happen`+
`#`Y$t`r....`^the name of the secondary character target (i.e. A smiles at B)`+
`#`Y$T`r....`^the short description, or name and title of the target (NPC vs PC)`+
`#`Y$r`r....`^the name of a random PC in the room with the mobile`+
`#`Y$R`r....`^the short description, or name and title of the random PC`+
`#`Y$q`r....`^the name of the mobile program target (`#`YMOB REMEMBER`^)`+
`#`Y$Q`r....`^the short description of the mobile program target`+
`+
`#`Y$j`r....`^he, she, it based on the sex of $i`+
`#`Y$J`r....`^he, she, it based on the sex of $r`+
`#`Y$e`r....`^he, she, it based on the sex of $n`+
`#`Y$E`r....`^he, she, it based on the sex of $t`+
`+
`#`Y$k`r....`^him, her, it based on the sex of $i`+
`#`Y$K`r....`^him, her, it based on the sex of $r`+
`#`Y$m`r....`^him, her, it based on the sex of $n`+
`#`Y$M`r....`^him, her, it based on the sex of $t`+
`+
`#`Y$l`r....`^his, hers, its based on the sex of $i`+
`#`Y$L`r....`^his, hers, its based on the sex of $r`+
`#`Y$s`r....`^his, hers, its based on the sex of $n`+
`#`Y$S`r....`^his, hers, its based on the sex of $t`+
`#`Y$Z`r....`^his, hers, its based on the sex of $q`+
`+
`#`Y$o`r....`^the first of the names of the primary object (i.e. A drops B)`+
`#`Y$O`r....`^the short description of the primary object`+
`#`Y$p`r....`^the first of the names of the secondary object (i.e A puts B in C)`+
`#`Y$P`r....`^the short description of the secondary object`+
`+
`#`Y$V`r....`^the vnum of the room the mob is moving to with a premove trigger`+
`+
`#`r-------------------------------------------------------------------------`^
`+
In `#`YIf_checks`^ the accepted variable are the basics ones
(i,n,t,r,o,p,q). If the variable is referenced that doesn't exist,
then the value is simply left blank or replaced with 'someone' or
'something' in output.
If the variable $q has not been defined, it is automatically set
to the last player that has triggered the program being executed ($n).
Once $q has been defined, it can be modified with `#`YMOB REMEMBER`^
and `#`YMOB FORGET`^ commands in a program. Note that $q is set
automatically only the first time the mobile executes a program, every
time thereafter it must be set with `#`YMOB REMEMBER`^.
`+
~
END
keyword IF_CHECKS~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES~
text `+
The provided list of if_checks and their arguments are below. They
should all be fairly obvious in what they do, but some of the more obtuse
deserve a slight explanation.
`+
`+
There are five types of if_checks:
Type 1: `#`RKeyword and value.....................`^`#`Yhelp IFTYPE1`^`+
Type 2: `#`RKeyword, comparison and value.........`^`#`Yhelp IFTYPE2`^`+
Type 3: `#`RKeyword and actor.....................`^`#`Yhelp IFTYPE3`^`+
Type 4: `#`RKeyword, actor and value..............`^`#`Yhelp IFTYPE4`^`+
Type 5: `#`RKeyword, actor, comparison and value..`^`#`Yhelp IFTYPE5`^`+
`+
`+
~
END
keyword IFTYPE1~
level 1
category undefined~
see_also IF_CHECKS IF_RAND TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES IFTYPE2 IFTYPE3 IFTYPE4 IFTYPE5~
text `+
A value type of string is a sequence of characters. It does not need
to be included in quotes or anything like that (i.e. if objhere table )
`+
Type 1: `#`RKeyword and value`^`+
`+
`#`Yrand`^ `#`Rnum`^ Is random percentage less than or equal to num
`#`Ymobhere`^ `#`Rvnum`^ Is a NPC with this vnum in the room
`#`Ymobhere`^ `#`Rname`^ Is a NPC with this name in the room
`#`Yobjhere`^ `#`Rvnum`^ Is an object with this vnum in the room
`#`Yobjhere`^ `#`Rname`^ Is an object with this name in the room
`#`Ymobexists`^ `#`Rname`^ Does NPC 'name' exist somewhere in the world
`#`Yobjexists`^ `#`Rname`^ Does object 'name' exist somewhere in the world
`+
~
END
keyword IFTYPE2~
level 1
category undefined~
see_also IF_CHECKS IF_RAND TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES IFTYPE1 IFTYPE3 IFTYPE4 IFTYPE5~
text `+
Any '==' operator can be replaced with any of the available ones, and
the value is one integer.
`+
Type 2: `#`RKeyword, comparison and value`^`+
`+
`#`Ypeople`^ `#`B==`^ `#`Rinteger`^ Is the number of people in the room equal to integer
`#`Yplayers`^ `#`B==`^ `#`Rinteger`^ Is the number of PCs in the room equal to integer
`#`Ymobs`^ `#`B==`^ `#`Rinteger`^ Is the number of NPCs in the room equal to integer
`#`Yclones`^ `#`B==`^ `#`Rinteger`^ Is the number of NPCs in the room with the same vnum
as the NPC who activated the program equal to integer
`#`Yorder`^ `#`B==`^ `#`Rinteger`^ Is the order (of several similar NPCs) of the NPC who
activated the trigger equal to integer
`#`Yhour`^ `#`B==`^ `#`Rinteger`^ Is the hour (game time) equal to integer
`+
~
END
keyword IFTYPE3~
level 1
category undefined~
see_also IF_CHECKS IF_RAND TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES IFTYPE1 IFTYPE2 IFTYPE4 IFTYPE5~
text `+
The argument $* refers to any of the variables which make sense for
that if_check (i.e. for an if_check which is referencing a person the
only valid variables would be $i, $n, $t, $r or $q).
`+
Type 3: `#`RKeyword and actor`^`+
`+
`#`Yisnpc`^ `#`B$*`^ Is $* an NPC
`#`Yispc`^ `#`B$*`^ Is $* a PC
`#`Yisgood`^ `#`B$*`^ Does $* have a good alignment
`#`Yisneutral`^ `#`B$*`^ Does $* have a neutral alignment
`#`Yisevil`^ `#`B$*`^ Does $* have an evil alignment
`#`Yisimmort`^ `#`B$*`^ Is $* an immortal (level of $* > LEVEL_HERO)
`#`Yischarm`^ `#`B$*`^ Is $* affected by charm
`#`Yisfollow`^ `#`B$*`^ Is $* a follower with their master in the room
`#`Yisactive`^ `#`B$*`^ Is $*'s position > POS_SLEEPING
`#`Yisdelay`^ `#`B$*`^ Does $* have a delayed MOBprogram pending
`#`Yisvisible`^ `#`B$*`^ Is $* visible to NPC who activated the program
`#`Yhastarget`^ `#`B$*`^ Does $* have a MOBprogram target in the room
`#`Yistarget`^ `#`B$*`^ Is $* the target of NPC who activated the program
`+
~
END
keyword IFTYPE4~
level 1
category undefined~
see_also IF_CHECKS IF_RAND TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES IFTYPE1 IFTYPE2 IFTYPE3 IFTYPE5~
text `+
The argument $* refers to any of the variables which make sense for
that if_check (i.e. for an if_check which is referencing a person the
only valid variables would be $i, $n, $t, $r or $q). A value type of
string is a sequence of characters. It does not need to be included
in quotes or anything like that (i.e. if name $n fido )
`+
Type 4: `#`RKeyword, actor and value`^`+
`+
`#`Yaffected`^ `#`B$*`^ `#`Y'affect'`^ Is $* affected by 'affect'
`#`Yact`^ `#`B$*`^ `#`Y'act'`^ Is $*'s ACT bit 'act' set
`#`Yoff`^ `#`B$*`^ `#`Y'off'`^ Is $*'s OFF bit 'off' set
`#`Yimm`^ `#`B$*`^ `#`Y'imm'`^ Is $*'s IMM bit 'imm' set
`#`Ycarries`^ `#`B$*`^ `#`Y'name'`^ Is $* carrying object 'name'
`#`Ywears`^ `#`B$*`^ `#`Y'name'`^ Is $* wearing object 'name'
`#`Yhas`^ `#`B$*`^ `#`Y'type'`^ Does $* have object of item_type 'type'
`#`Yuses`^ `#`B$*`^ `#`Y'type'`^ Is $* wearing object of item_type 'type'
`#`Yname`^ `#`B$*`^ `#`Y'name'`^ Is $*'s name 'name'
`#`Yexactname`^ `#`B$*`^ `#`Y'name'`^ Is $*'s name 'name'
`#`Ypos`^ `#`B$*`^ `#`Y'position'`^ Is $*'s position 'position' (sleeping etc.)
`#`Yclan`^ `#`B$*`^ `#`Y'name'`^ Does $* belong to clan 'name'
`#`Yrace`^ `#`B$*`^ `#`Y'name'`^ Is $* of race 'name'
`#`Yclass`^ `#`B$*`^ `#`Y'name'`^ Is $*'s class 'name'
`#`Yobjtype`^ `#`B$*`^ `#`Y'type'`^ Is $*'s item_type 'type'
`#`Ysector`^ `#`B$*`^ `#`Y'sector'`^ Is the room's sector type where $* is
`#`Yarea`^ `#`B$*`^ `#`Y'full exact name of area'`^ Is the area's name 'area's name' where the $* is
`#`Yhas`^ `#`B$*`^ `#`Y'token's vnum'`^ Is $* carrying the token with that vnum
`#`Yroomflag`^ `#`B$*`^ `#`Y dark`^ Is dark the room where $* is
`+
~
END
keyword IFTYPE5~
level 1
category undefined~
see_also IF_CHECKS IF_RAND TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES IFTYPE1 IFTYPE2 IFTYPE3 IFTYPE4~
text `+
Any '==' operator can be replaced with any of the available ones
described above. The argument $* refers to any of the variables which
make sense for that if_check (i.e. for an if_check which is referencing
a person the only valid variables would be $i, $n, $t, $r or $q). The
value is any integer.
`+
Type 5: `#`RKeyword, actor, comparison and value`^`+
`+
`#`Yvnum`^ `#`B$* ==`^ `#`Rinteger`^ Is $*'s virtual number equal to integer
`#`Yhpcnt`^ `#`B$* ==`^ `#`Rinteger`^ Is $*'s hitpoint percentage equal to integer
`#`Yroom`^ `#`B$* ==`^ `#`Rinteger`^ Is vnum of the room $* is in equal to integer
`#`Ysex`^ `#`B$* ==`^ `#`Rinteger`^ Is $*'s sex equal to integer
`#`Ylevel`^ `#`B$* ==`^ `#`Rinteger`^ Is $*'s level equal to integer
`#`Yalign`^ `#`B$* ==`^ `#`Rinteger`^ Is $*'s alignment equal to integer
`#`Ymoney`^ `#`B$* ==`^ `#`Rinteger`^ Does $* have money (in silver) equal to integer
`#`Yobjval#`^ `#`B$* ==`^ `#`Rinteger`^ Is $*->value[#] equal to integer (# from 0-4)
`+
~
END
keyword IF_RAND~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES~
text `+
`#`=lSyntax:`^ if `#`Yrand`^ `#`R<number>`^
`+
The argument used on this if_check is a percentage number, between 0
and 100. This rand if_check, turns true if a random number (`#`Yrand`^) is less
or equal to the argument, and false if the random number (`#`Yrand`^) is greater
than the argument.
`+
`#`BExample:`^
`+
say head I win.
emote tosses up a coin.
`#`cif`^ `#`Yrand`^ `#`R50`^
say HEAD! I've won!!
`#`celse`^
say damned!! you've won!
`#`ymob oload`^ 5034
give coin $n
`#`cendif`^
`+
`+
~
END
keyword MPCOMMANDS~
level 1
category undefined~
see_also TRIGGERS VARIABLES OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES IF_CHECK~
text `+
`+
Mobile program pcommands are special commands that allow mobiles to
perform immortal-like actions within a mobile program (transferring
players or loading items, for example). Most mobile commands them are
wiz commands which have been changed to allow for mobiles to perform
the commands. In this version of mobile programs, players have been
prevented from using these commands by adding a separate interpreter
for mobile program commands.`+
`+
Here goes a list of the commands`+
`+
`#`r-------------------------------------------------------------------`^
`+
`#`YMOB ASOUND`^`#`r......`#`R[string]`^`+
`#`YMOB ZECHO`^`#`r.......`#`R[string]`^`+
`#`YMOB GECHO`^`#`r.......`#`R[string]`^`+
`#`YMOB ECHO`^`#`r..... ..`#`R[string]`^`+
`#`YMOB ECHOAT`^`#`r......`#`R[victim]`^`#`r........`#`B[string]`^`+
`#`YMOB ECHOAROUND`^`#`r..`#`R[victim]`^`#`r........`#`B[string]`^`+
`#`YMOB MLOAD`^`#`r.......`#`R[vnum]`^`+
`#`YMOB OLOAD`^`#`r.......`#`R[vnum]`^`#`r..........`#`B[level]`^`#`r..`#`G{'room'/'wear'}`^`+
`#`YMOB KILL`^`#`r........`#`R[victim]`^`+
`#`YMOB FLEE`^
`#`YMOB REMOVE`^`#`r......`#`R[victim]`^`#`r........`#`B[vnum/'all']`^`+
`#`YMOB JUNK`^`#`r........`#`R[object]`^`+
`#`YMOB PURGE`^`#`r.......`#`R[argument]`^`+
`#`YMOB AT`^`#`r..........`#`R[location]`^`#`r......`B[command]`^`+
`#`YMOB GOTO`^`#`r........`#`R[location]`^`+
`#`YMOB TRANSFER`^`#`r....`#`R[victim/'all']`^`#`r..`#`B[location]`^`+
`#`YMOB GTRANSFER`^`#`r...`#`R[victim]`^`#`r........`#`B[location]`^`+
`#`YMOB OTRANSFER`^`#`r...`#`R[object]`^`#`r........`#`B[location]`^`+
`#`YMOB FORCE`^`#`r.......`#`R[victim/'all']`^`#`r..`#`B[command]`^
`#`YMOB GFORCE`^`#`r......`#`R[victim]`^`#`r........`#`B[command]`^
`#`YMOB VFORCE`^`#`r......`#`R[vnum]`^`#`r..........`#`B[command]`^
`#`YMOB CAST`^`#`r........`#`R[spell]`^`#`r.........`#`B[victim]`^
`#`YMOB DAMAGE`^`#`r......`#`R[victim/'all']`^`#`r..`#`B[min]`^`#`r.....`#`G[max]`^`#`r.....`#`W[lethal]`^
`#`YMOB DELAY`^
`#`YMOB CANCEL`^
`#`YMOB REMEMBER`^`#`r....`#`R[victim]`^
`#`YMOB FORGET`^
`#`YMOB CALL`^`#`r........`#`R[vnum]`^`#`r..........`#`B[victim]`^`#`r..`#`G[target1]`^`#`r.`#`W[target2]`^
`#`YMOB TTIMER`^`#`r......`#`R[victim]`^`#`r........`#`B[token]`^`#`r...`#`G[time]`^
`#`YMOB TREMOVE`^`#`r.....`#`R[token]`^`#`r.........`#`B[victim]`^
`#`YMOB TGIVE`^`#`r.......`#`R[token]`^`#`r.........`#`B[victim]`^
`+
`r-----------------------------------------------------------------------`^
`+
`+
`+
~
END
keyword MOB_ASOUND MOB_ZECHO MOB_GECHO~
level 1
category undefined~
see_also MOB_ECHO MPCOMMANDS~
text `+
`#`=lSyntax:`+`^
`+
`#`YMOB ASOUND`^ `#`R[string]`^`+
`#`YMOB ZECHO`^ `#`R[string]`^`+
`#`YMOB GECHO`^ `#`R[string]`^`+
`+
The command `#`Ymob asound`^ prints the text string to the rooms around the
mobile in the same manner as a death cry. `#`YMob zecho`^ prints the string to
all players in the same area with the mobile. `#`YMob gecho`^ prints the string
to all players in the game.`+
We would like avoid the use of `#`Ymob gecho`^ in the game, it should only
be used in quests made by immortals.`+
`+
`#`BExamples:`^
`+
`#`YMOB ASOUND`^ `#`RYou hear a lovely music...`^`+
The message: "You hear a lovely music..." will be displayed in all
the rooms around the mobile's room, but not in the mobile's room!
If you want display a message in the same room as the mobile you
should use the `#`YMOB ECHO`^ too.
`+
`#`YMOB ZECHO`^ `RThe earth trembles!`^
The message:" The earth trembles!" will be displayed in all the
rooms of the area, try not abuse of this command, it should be
only used when you are sure the whole area would be able to hear it!
`+
`#`YMOB GECHO`^ `RThe sky turns dark!`^
The message: "The sky turns dark!" will be showed to all players
in the mud, even if they can see the sky or not, this command should
not be used, except by immortals for quests.
`+
`+
~
END
keyword MOB_ECHO MOB_ECHOAT MOB_ECHOAROUND~
level 1
category undefined~
see_also MOB_GOTO MOB_AT MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax`^
`#`YMOB ECHO`^ `#`R[string]`^
`#`YMOB ECHOAT`^ `#`G[victim]`^ `#`R[string]`^
`#`YMOB ECHOAROUND`^ `#`G[victim]`^ `#`R[string]`^
`+
The command `Y`#mob echo`^ displays the string to everyone in the room, the
`#`Ymob echoat`^ displays the string to the victim only, and the command `#`Ymob
echoaround`^ displays the string to everyone inside the room except to the
victim. The three options let you tailor the message to goto victims or
to do things sneaky.
`+
`#`BExamples:`^
`+
`#`YMOB ECHO`^ `#`RYou see a feather falling from the sky.`^
The message: "You see a feather falling from the sky." will be displayed to
everyone inside the room.
`+
`#`YMOB ECHOAT`^ `#`G$n`^ `#`RHelp me, please!!`^
The message: "Help me, please!!" will be displayed to the player who has
activated the mobprog trigger (`#`Y$n`^).
`+
`#`YMOB ECHOAROUND`^ `#`G$n`^ `#`R$N disappears on a puff of smoke!!`^
The message: "<victim short description> disappears on a puff of smoke!!"
will be displayed to everyone inside the room, except to the victim.
`+
`#`BMore Examples:`^
`+
A merchand could have the command on his mobprog:
`#`Ymob at`^ guard `#`Ymob echoat`^ guard rescue_please
`+
This coupled with a guard act trigger on rescue_please to:
`#`Ymob goto`^ $n
`#`Ymob echo`^ $I has arrived.
`+
It is an affective way of quickly bringing guards to the scene of
an attack. (Note that the merchant has to be the only one of its
kind in the game or have a unique name, otherwise the guard might
go to different mobile...).
`+
`+
~
END
keyword MOB_OLOAD MOB_MLOAD~
level 1
category undefined~
see_also MOB_AT MOB_TRANSFER MOB_OTRANSFER MPCOMMANDS VNUM~
text `+
`#`=lSyntax:`^
`+
`#`YMOB MLOAD`^ `#`R[vnum]`^
`#`YMOB OLOAD`^ `#`R[vnum]`^ `#`G[level]`^ `#`W{'room'/'wear'}`^
`+
The `#`Ymob mload`^ command creates a mobile and places it in the same room
with the mobile, and the `#`Ymob oload`^ command loads the object into the
inventory of the mobile which has the mobile program. Even if the item is
non-takable, the mobile will receive it in the inventory. This lets a
mobile distribute a quest item or load a key or something. The optional
3rd parameter can be specified; 'room' means to load the object to the
room, 'wear' means to force the mobile to wear the object loaded
(useful for equipping mobiles on the fly), but don't forget to include
the [level], otherwise the 'room' or 'wear'will not work.
To transfer objects or mobiles to other rooms you can use the commands
`#`Ymob transfer`^ and `#`Ymob otransfer`^ too.
`+
`#`BExamples:`^
`+
`#`YMOB MLOAD`^ `#`R3031`^
This command will load the mobile which has the vnum 3031 in the same
room of the mobile. To load mob on other places you can use the command
`#`YMOB AT`^ before the `#`Ymob mload`^ command.
`+
`#`YMOB OLOAD`^ `#`R3021`^ `#`G5`^ `#`Wwield`^
This command will load the object 3021 with level 5 and wield it.
`+
`#`YMOB OLOAD`^ `#`R3010`^ `#`G5`^ `#`Wroom`^
This command will load the object 3021 with level 5 and left it on the
room's ground. To load objects on another rooms you can use the command
`#`Ymob at`^ before the `#`Ymob oload`^ command.
`+
`+
~
END
keyword MOB_KILL~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`+
`#`YMOB KILL`^ `#`R[victim]`^
`+
This command lets a mobile kill a player without having to murder. Lots
of mobile programs end up with mpkill $n commands floating around. It
works on both mobiles and players.
`+
`#`BExamples:`^
`+
`#`YMOB KILL`^ `#`R$n`^
This command forces the mobile to attack the player who activated the
program (`#`Y$n`^).
`+
`#`YMOB KILL`^ `#`R$r`^
This command forces the mobile to attack a random player in the room
(`#`Y$r`^).
`+
`+
~
END
keyword MOB_FLEE~
level 1
category undefined~
see_also MPCOMMANDS TRIGGERS TRIGGER_HPCNT WIMPY~
text `+
`#`=lSyntax:`^
`+
`#`YMOB FLEE`^
`+
This command causes a mobile to unconditionally flee from combat. Can
be used for example with the hit point percentage trigger (`#`Yhpcnt`^ trigger)
to simulate "wimpy" behavior.
`+
`#`BExample:`^
`+
`#`YMOB FLEE`^
The mobile will flee when the interpreter reachs this command.
`+
`#`BMore Examples:`^
`+
If you set a trigger hpcnt:
`#`y
MOBPrograms for [ 3002]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 3005 HPCNT 20`^
`+
And in the code of the program you use the command:
`+
`#`YMOB FLEE`^
The mobile will flee when its hit points of the mobile is below 20%.
`+
`+
~
END
keyword MOB_REMOVE~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES VNUM~
text `+
`#`=lSyntax:`^
`+
`#`YMOB REMOVE`^ `#`R[victim]`^ `#`G[vnum|'all']`^
`+
This command lets the mobile to strip an object of given vnum from the
victim. Objects removed are destroyed. If the vnum is replaced with "all",
the whole inventory of the victim is destroyed. This command is probably
most useful for extracting quest items from a player after a quest has
been completed.
`+
`#`BExamples:`^
`+
`#`YMOB REMOVE`^ `#`R$n`^ `#`G3000`^
The mobile will remove the object which has the vnumber 3000 from the player
who activated the trigger (`#`Y$n`^).
`+
`#`YMOB REMOVE`^ `#`R$r`^ `#`Gall`^
The mobile will remove all the equipment from a random player inside the room.
`+
`+
~
END
keyword MOB_JUNK~
level 1
category undefined~
see_also MPCOMMANDS~
text `+
`#`=lSyntax:`^
`+
`#`YMOB JUNK`^ `#`R[object]`^
`+
This command destroys the object refered to in the mobile's inventory.
It prints no message to the world and you can do things like junk all.bread
or junk all. This is nice for having janitor mobiles clean out their
inventory if they are carrying too much. Don't use the vnum of the objects
because it doesn't work.
`+
`#`BExample:`^
`+
`#`YMOB JUNK`^ `#`Rkey`^
This command will destory the key which the mobile is carrying.
`+
`#`YMOB JUNK`^ `#`Rall.ring`^
This command will destroy all the rings which the mobile is carrying.
`+
`+
~
END
keyword MOB_PURGE~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`+
`#`YMOB PURGE`^ `#`R[argument]`^
`+
This command destroys the argument from the room of the mobile. Without
an argument the result is the cleansing of all NPC's and items from the room
with the exception of the mobile itself. However, mob purge $i will indeed
purge the mobile, but it MUST be the last command the mobile tries to
do, otherwise the mud can't reference the acting mobile trying to do the
commands and bad things happen.
`+
`#`BExamples:`^
`+
`#`YMOB PURGE`^ `#`Rtable`^
This command will destroy any object called table which is inside the room.
`+
`#`YMOB PURGE`^
This command will destroy everything inside the room.
`+
`#`YMOB PURGE`^ `#`R$i`^
This command will destroy the mobile itself, remember that it MUST be the last
command of the program.
`+
`+
~
END
keyword MOB_AT~
level 1
category undefined~
see_also MPCOMMANDS MOB_KILL VARIABLES~
text `+
`#`=lSyntax:`^
`+
`#`YMOB AT`^ `#`R[location]`^ `#`G[command]`^
`+
This command perfoms the command at the designated location. Very
useful for doing magic slight of hand tricks that leave players
dumbfounded.. such as metamorphing mobiles, or guard summoning, or
corpse vanishing. Remember that the mobile only performs the command
on the location, the mobile itself is not there.
`+
`#`BExamples:`^
`+
`#`YMOB AT`^ `#`R$n`^ `#`YMOB KILL`^ `#`R$n`^
This command will force the mobile to attack the player who activated
the mobprogram, no matter where the player is.
`+
`#`YMOB AT`^ `#`R3004`^ `#`Gsay hello!`^
This command will force the mobile to say hello in the room number 3004,
no matter if there is a player there or not.
`+
`+
~
END
keyword MOB_GOTO~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES MOB_ECHO~
text `+
`#`=lSyntax:`^
`+
`#`YMOB GOTO`^ `#`R[location]`^
`+
This command moves the mobile to the room or mobile or object requested.
It makes no message of its departure or of its entrance, so these must be
supplied with `#`Ymob echo`^ commands if they are desired.
`+
`#`BExamples:`^
`+
`#`YMOB GOTO`^ `#`R3000`^
This command moves the mobile to the room 3000.
`+
`#`YMOB GOTO`^ `#`Rguard`^
This command moves the mobile to the same room where there is a mobile
called guard. Take care with this command, there are lots of mobs
called guards.
`+
`#`YMOB GOTO`^ `#`Rtable`^
This command moves the mobile to the same room where there is an object
called table. Take care with this command, there are lots of objects
called table.
`+
`#`YMOB GOTO`^ `#`R$n`^
This command moves the mobile to the same room where the player who
activated the program is.
`+
`+
~
END
keyword MOB_TRANSFER MOB_GTRANSFER MOB_OTRANSFER~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`#`YMOB TRANSFER`^ `#`R[victim|'all']`^ `#`G[location]`^
`#`YMOB GTRANSFER`^ `#`R[victim]`^ `#`G[location]`^
`#`YMOB OTRANSFER`^ `#`R[object]`^ `#`G[location]`^
`+
The `#`Ymob transfer`^ command sends the victim to the destination or to
the room of the mobile as a default. If the victim is "all" then all the
characters in the room of the mobile are transfered to the destination. Good
for starting quests or things like that. There is no message given to the
player that it has been transfered and the player doesnt do a look at the
new room unless the mob forces them to. The command `#`Ymob gtransfer`^ works like
transfer, except that the group the victim belong to is transferred with
the victim. The command `#`Ymob otransfer`^ transfers an object in the room.
`+
`#`BExamples:`^
`+
`#`YMOB TRANSFER`^ `#`R$n`^ `#`G3020`^
This command transfer the player who activated the program to the room
3020.
`+
`#`YMOB TRANSFER`^ `#`Rall`^ `#`Gguard`^
This command will transfer all the players from the room to another room
where there is a mob called guard. Take care when you use the name of a
mobile or of an object to give the location, because there are lots of
mobs called guard.
`+
`#`YMOB TRANSFER`^ `#`Rghost`^ `#`G$n`^
This command will transfer the mobile called ghost which is in the same
room as the mobile, to the room where the player who activated the program
is.
`+
`#`YMOB GTRANSFER`^ `#`R$n`^ `#`G3030`^
This command will transfer the player who activated the program and all
his group to the room number 3030.
`+
`#`YMOB OTRANSFER`^ `#`Rring`^ `#`G$n`^
This command will transfer the object ring, which the mobile is carrying
to the room where the player who activated the program is.
`+
`+
~
END
keyword MOB_FORCE MOB_GFORCE MOB_VFORCE~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`#`YMOB FORCE`^ `#`R[victim|'all']`^ `#`G[command]`^
`#`YMOB GFORCE`^ `#`R[victim]`^ `#`G[command]`^
`#`YMOB VFORCE`^ `#`R[vnum]`^ `#`G[command]`^
`+
The `#`Ymob force`^ command forces the victim to do the designated command.
The victim is not told that they are forced, they just do the command,
so some echos message would be nice. You can force players to remove
belongings and give them to you, etc. The player sees the normal command
messages (such as removing the item and giving it away in the above
example). If the victim is "all" then everyone in the mobiles room does
the command.
The `#`Ymob gforce`^ command works like force except that it affects the
group the victim belongs to. The `#`Ymob vforce`^ command affects all mobiles
with given vnum in the game world. This is useful for, for example,
purging certain type of NPCs from the game (by forcing them to purge
themselves).
`+
`#`BExamples:`^
`+
`#`YMOB FORCE`^ `#`R$n`^ `#`Gpkill $r`^
This commansd will force the player who activated the program to attack a
random player in the same room, or attack himself too.
`+
`#`YMOB FORCE`^ `#`Rall`^ `#`Grest`^
This command will force all the players in the room to rest.
`+
`#`YMOB GFORCE`^ `#`R$n`^ `#`Gdrop all`^
This command will force all the group of the player who activated the
program to drop everything they are carrying.
`+
`#`YMOB VFORCE`^ `#`R3002`^ `#`Gsing`^
This command will force all the mobiles which has the vnum 3002 to sing.
`+
`+
~
END
keyword MOB_CAST~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES SPELLS~
text `+
`#`=lSyntax:`^
`+
`#`YMOB CAST`^ `#`R[spell]`^ `#`G[victim]`^
`+
This command lets the mobile to cast spells. Beware, this does only
crude validity checking and does not use up any mana. All spells are
available regardless of the race or other abilities of the mobile.
Casting the spell occurs silently, but spell effects are displayed
normally. Remember to write the spell name between quotes (''), if it
has two words.
`+
`#`BExample:`^
`+
`#`YMOB CAST`^ `#`R'cause light'`^ `#`G$n`^
The mobile will cast the cause light spell on the player who activated
the program.
`+
`#`YMOB CAST`^ `#`Rdecay`^ `#`G$r`^
The mobile will cast the decay spell on a random player inside the room.
`+
`+
~
END
keyword MOB_DAMAGE~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`+
`#`YMOB DAMAGE`^ `#`R[victim|'all']`^ `#`G[min] [max]`^ `#`W`lethal}`^
`+
This command causes unconditional damage to the victim. Specifying
"all" as victim causes damage to all characters in the room except the
mobile. Min and max parameters define the minimum and maximum amounts of
damage caused, remember that this damage is like a damage of a weapon, all
`#`YAC`^s and affects of the victim will be taken in account and the damage
that the victim will sufer will be lower than that used on the `#`Ymob damage`^
command. By default, the damage is non-lethal, but by supplying the optional
'lethal' parameter, the damage can kill the victim.
This command is silent, you must echo all messages yourself in the
program. Useful for implementing special attacks for mobiles.
`+
`#`BExamples:`^
`+
`#`YMOB DAMAGE`^ `#`R$n`^ `#`G10 100`^ `#`Wlethal`^
The mobile will causes from 10 to 100 damage to the player who has
activated the program, remember that the player will be protected
with armor and magic, so the damage he will sufer will be lower, but
this damage will be able to kill him.
`+
`#`YMOB DAMAGE`^ `#`Rall`^ `#`G100 1000`^
The mobile will causes from 100 to 1000 damage to all the players
inside the room, remember that the player will be protected
with armor and magic, so the damage they will sufer will be lower, and
the damage will not be able to kill them, once their hp reaches 3, they
will not sufer further damage.
`+
`+
~
END
keyword MOB_DELAY MOB_CANCEL~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES PULSE_MOBILE TRIGGER_DELAY~
text `+
`#`=lSyntax:`^
`+
`#`YMOB DELAY`^
`#`YMOB CANCEL`^
`+
The `#`Ymob delay`^ command sets the time in `#`YPULSE_MOBILE`^ after which the
mobile's `#`Ydelay trigger`^ is activated. If the mobile has a program defined
for delay trigger, the program is executed when the timer expires.
The `#`Ymob cancel`^ resets the delay timer.
For example, the mob is processing a program and in its code has the
command:
`+
`#`YMOB DELAY`^ `#`R20`^
`+
When this timer 20*PULSE_MOBILE expires the program will check
the delay trigger:
`+
`#`yMOBPrograms for [ 5000]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 3000 DELAY 20`^
`+
If the percentage roll is lower than 20, the program 3000 will be
executed.
`+
`#`BExamples:`^
`+
`#`YMOB DELAY`^ `#`R10`^
The mobile will look for a `#`Ydelay trigger`^ after 10*PULSE_MOBILE.
`+
`#`YMOB CANCEL`^
The mobile resets the delay timer.
`+
`+
~
END
keyword MOB_REMEMBER MOB_FORGET~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`+
`#`YMOB REMEMBER`^ `#`R[victim]`^
`#`YMOB FORGET`^
`+
The `#`Ymob remember`^ command enables the mobile to remember a player for
future reference in a MOBprogram. The player can subsequently be referred
as '$q' in programs activated by the mobile. The `#`Ymob forget`^ clears
the target. Note that if the first time the mobile runs a program, $q is
automatically set to the player who triggered the event. Most commonly
this command is used in delayed programs, where the mobile has to remember
the player who triggered the original event, for example to continue
conversation.
`+
`#`BExample:`^
`+
`#`YMOB REMEMBER`^ `#`R$n`^
The mobile will remember the name of the player who activated the program
to use on other program as `#`Y$q`^.
`+
`#`YMOB CANCEL`^
The mobile will forget its target.
`+
`+
~
END
keyword MOB_CALL~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES~
text `+
`#`=lSyntax:`^
`+
`#`YMOB CALL`^ `#`R[vnum]`^ `#`G{victim}`^ `#`W{target1} {target2}`^
`+
The `#`Ymob call`^ command lets you call MOBprograms from within a
running one, i.e. to call a MOBprogram subroutine. The first parameter is
the vnum of the program to execute, the second is the victim's name (for
example $n), and the third and fourth are optional object names. All other
parameters except vnum can be replaced with word 'null' indicating ignored
parameter. MOBprograms can be called recursively, but as a safety measure,
parser allows only 5 recursions.
`+
`#`BExamples:`^
`+
`#`YMOB CALL`^ `#`R5003`^ `#`G$n`^ `#`Wnull null`^
While running one program the mobile will call the program num 5003, the
victim of this program will be the player who activated the first program.
`+
`+
~
END
keyword MOB_TGIVE MOB_TREMOVE MOB_TTIMER OBJ_TYPE_TOKEN~
level 1
category undefined~
see_also MPCOMMANDS VARIABLES OBJ_TYPE_TOKEN~
text `+
`#`=lSyntax:`^
`+
`#`YMOB TTIMER`^ `#`R[victim]`^ `#`G[token]`^ `#`W[time]`^
`#`YMOB TREMOVE`^ `#`R[token]`^ `#`G[victim]`^
`#`YMOB TGIVE`^ `#`R[token]`^ `#`G[victim]`^
`+
Those commands are used to work with a new object type called token.
`#`YTokens`^ are items created expressly for use in mobile programs.
They are totally undetectable unless for immortals. These tokens can be
used as budget variables on mobiles programs, for such things as marking
killers, adding people on to the healer's list of not welcome players,
etc. It is recommended to name the tokens in a uniform way so they are
easier to identify with their proper mobprogs.
`+
`#`Glong desc: TOKEN##### <string>`^
`+
Where ##### would be the vnum of the mobile program and the string
would be a short description of its use. When a player dies, a set flag
(v0 dropdeath) will decide whether the token dissolves of the token is
stripped from the corpse and reset in the mortal's inventory. They are
weightless, invisible and can't be handled amongst mortals.
`+
The `#`Ymob tgive`^ command is used to give a mortal a token. Since
players may not receive what they cannot see, the normal give command won't
work correctly, the `#`Ymob tremove`^ command is used to easily remove the
token from the chosen player's inventory without having to steal it from
them, and the `#`Ymob ttimer`^ command puts a timer on a token that's in
the inventory of the designated player. After the set number of ticks, the
token will automatically disintegrate and vanish from the inventory of who
ever happens to be carrying it. Remember that the mobile will only be able
to use the `#`Ymob tgive`^ commands after have loaded the proper token on
its inventory.
`+
`#`BExamples:`^
`+
`#`YMOB TGIVE`^ `#`Rtoken5008`^ `#`G$n`^
This command will give the token5008 which is in the mobile's inventory
to the player who has activated the program.
`+
`#`YMOB TREMOVE`^ `#`Rtoken5009`^ `#`G$n`^
This command will remove the token5009 from a player's inventory who has
activated the program.
`+
`#`YMOB TTIMER`^ `#`Rtoken5020`^ `#`G$n`^ `#`W10`^
This command will set a timer on the token5020 which the player who has
activated the program is carrying, after the 10 ticks the token will
disappear from the player's inventory.
`+
`+
~
END
keyword MPSYNTAX~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS IF_CHECKS OPERATORS MP-BUILDING MPEXAMPLES~
text `+
The syntax of any mobile program can be as shown below:
`+
`#`Yif`^ <if_check_1> <argument> <operator> <value>
`#`Yor`^ <if_check_2> <argument> <operator> <value>
`#`Yor`^ <if_check_N> <argument> <operator> <value>
`#`Yand`^ <if_check_N> <argument> <operator> <value>
`#`Yand`^ <if_check_N> <argument> <operator> <value>
`+
<program_command_1>
<program_command_2>
`#`Ybreak`^
<program_command_N>
`#`Yelse`^
<program_command_1>
<program_command_2>
`#`Ybreak`^
<program_command_N>
`#`Yendif`^
`+
Basically it is an '`#`Yif`^' line, followed by '`#`Yand`^' and/or '`#`Yor`^' lines,
followed by some mud commands, which may contain a '`#`Ybreak`^' line, possibly
followed by an '`#`Yelse`^' line, followed by more mud commands, which may contain
a '`#`Ybreak`^'line, followed by an '`#`Yendif`^' line.
The 'if' line is any valid `#`Yif_check`^ expression, those if_check
expression can be conbinated with the logic operators or and and. The BREAK
command bails out of the entire mobile program regardless of the level if
nesting. (END is a synonym for BREAK).
`+
`#`BExamples:`^
`+
`#`yMOBPrograms for [ 5003]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 5009 ACT pokes you in the ribs.`^
`+
#5009
if isnpc $n
chuckle
poke $n
break
else
if level $n <= 5
or isgood $n
tell $n I would rather you didnt poke me.
else
if level $n > 15
scream
say Ya know $n. I hate being poked!!!
if mobhere guard
mob force guard kill $n
endif
kill $n
break
endif
slap $n
shout MOMMY!!! $N is poking me.
endif
endif
`+
This trigger will only happen when the mobile gets the message "... pokes
you in the ..." If the offender (recall the $n and $N refer to the char
who did the poking...) is an NPC, then the mobile merely chuckles and
pokes back. If the offender was a PC then good and low level characters
get a warning, high level chars get attacked, and midlevel chars get
slapped and whined at. Also, when attacking, the mobile will check if
there are guards in the room (if mobhere guard) and if one is found,
it will be forced to attack the player, too (mob force guard mob kill $n).
Notice the use of a mobile command "mob force".
`+
`+
~
END
keyword MOBPROGRAM_LIST~
level 1
category undefined~
text `+
MOBprogram list, is a list that contains virtual numbers of the
programs, its triggers and arguments, that is set on the mobile.
On the olc building it can be seen when you type medit <mob's vnum>,
and it looks like the table below:
`+
`#`yMOBPrograms for [ 3004]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 3005 REPOP 3
[ 1] 3009 HPCNT 20
[ 2] 3004 ACT sits
[ 3] 3006 SPEECH help me please!!
[ 4] 3008 GREET 100`^
`+
The first number [ 0] is the number of the program on the MOBprogram
list, the second number 3005, is the virtual number of the program which
is called when the trigger REPOP is activated, and the last number or
phrase is the argument to activate the trigger.
`+
On the text file of the area, the MOBprogram list is included below
the mobile statistics, and it looks like the list below:
`+
`#`y
M repop 3005 3
M hpcnt 3009 20
M act 3004 sits
M speech 3006 help me please!!
M greet 3008 100`^
`+
`+
`#`CSEE ALSO: `=_MEDIT`+, `=_MOBPROG`+.`^
~
END
keyword MOB_ACT_UPDATE_ALWAYS MOB_AFF_DETECT_HIDE MOB_AFF_DETECT_INVIS~
level 1
helpflags builder~
category undefined~
text `+
UNDER CONSTRUCTION! :)
`+
`#`Y
\
\
\
\
\
\ /\
/ \
\ .
\. /
`^
`+
~
END
keyword PULSE-MOBILE PULSE-VIOLENCE~
level 1
category undefined~
text `+
Each pulse mobile is set to 4 seconds.
While fighting each round is set to one pulse violence, so in the
fight trigger if you set it to 100% each round it will be activated.
`+
~
END
keyword MP-BUILDING~
level 1
category undefined~
see_also MPEXAMPLES MUDFTP MP-BUILDING1~
text `+
The first step to build a mobile program is building the mobile, see
which trigger is better to use, and build the code. To build the code
you need see what virtual numbers are available for the mobile program,
use the command `#`Ymplist`^ to see all the mobile programs of the current
area and its vnums, you will see something like the list below:
`+
1`#`s[`c 3070`y-mekali `g Reave `s]`r healer throws you out`^
2`#`s[`c 3069`y-mekali `g Reave `s]`r healer shit list`^
3`#`s[`c 3060`y-mekali `g Reave `s]`r towel boy takes towel as player leaves bathhouse and thanks them for coming`^
4`#`s[`c 3059`y-mekali `g Reave `s]`r towel boy transfers player into bath when they pay 3 gold admission`^
5`#`s[`c 3058`y-mekali `g Reave `s]`r towel boy prevents those who havent paid form entering bath house`^
6`#`s[`c 3057`y-mekali `g Reave `s]`r towel boy welcomes to bath and states price`^
`+
Where you see the number of the mobile program, its virtual number, the
name of the area, the builder's name and the title of the mobile program.
To start or edit one mobprogram you have the command:
`+
`#`Ympedit create `R<vnum>`^ - To create a new mobprog
`#`Ympedit `R<vnum>`^ - To edit an old mobprog
`+
when you type the command to create a new mobprog the message below will
appear:
`+
MobProgram Code Created.
`+
Now you are on the mobprog editing mode, to see the statistics and code
of the mobile program type show or hit the return bottom on your keyboard
you sill see the table below:
`+
`#`s=============================================================================`^
`#`yVnum:`^ 5011 `#`yTitle:`^`#`s unknown`^
`#`yAuthor(s):`^`#`r Ninive`^
`#`yCode:`^
`#`s=============================================================================`^
Currently no mobiles use this program.
`#`s=============================================================================`^
`+
You have some commands to change those settings, to see all the available
commands type `#`Ycommand`^:
`+
`#`W--=========== `YMPEDIT COMMANDS`^ `#`W===========--`^
commands create code author title
show ?
`+
`#`Ycommands`^ - List the available commands
`#`Ycreate`^ - Creates a new mobprog (`#`Ympedit create `R<vnum>`^)
`#`Ycode`^ - To edit the code
`#`Yauthor`^ `#`R<builder's name>`^ - To set the author's name
`#`Ytitle`^ `#`R<mobprog name>`^ - To set the mobprog's name
`#`Yshow`^ - To see the mobprog statistics and code
`+
To start coding the mobile program, type `#`Ycode`^ and you will start
the text editor mode, the `#`Ymudftp`^ is very useful for coding your
program.
`+
-=======- Entering APPEND Mode -========-
Type .h on a new line for help
Terminate with a - or @ on a blank line.
-=======================================-
`+
`+
When you finish the coding and type show you will see something like
this:
`+
`#`s=============================================================================`^
`#`yVnum:`^ 3001 `#`yTitle:`^`#`r mekali guards dying thrust`^
`#`yAuthor(s):`^`#`r Reave`^
`#`yCode:`^
`#`csay Curse you to hell, evil one!
mob echoat $n The guard thrusts his blade deep into your midsection with his last bit of strength!
mob damage $n 25 50`^
`+
`#`s=============================================================================`^
Currently no mobiles use this program.
`#`s=============================================================================`^
`+
see `#`Chelp MP-Building1
`+
~
END
keyword MPEXAMPLES~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES1~
text `+
Here goes some mobile programs examples:
`+
In #MOBILES:
`+
`#`yM act 1000 pokes you in the ribs.`^
`+
Or in the olc mobile editing:
`+
`#`yMOBPrograms for [ 1000]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 1000 ACT pokes you in the ribs.`^
`+
In #MOBPROGS:
`+
#1000
`#`yif isnpc $n
chuckle
poke $n
break
else
if level $n <= 5
or isgood $n
tell $n I would rather you didnt poke me.
else
if level $n > 15
scream
say Ya know $n. I hate being poked!!!
if mobhere guard
mob force guard kill $n
endif
kill $n
break
endif
slap $n
shout MOMMY!!! $N is poking me.
endif
endif`^
`+
Ok.. time to translate.. the trigger will only happen when the mobile
gets the message "... pokes you in the ..." If the offender (recall
the $n and $N refer to the char who did the poking...) is an NPC, then
the mobile merely chuckles and pokes back. If the offender was a PC
then good and low level characters get a warning, high level chars
get attacked, and midlevel chars get slapped and whined at.
Also, when attacking, the mobile will check if there are guards in the
room (if mobhere guard) and if one is found, it will be forced to
attack the player, too (mob force guard mob kill $n). Notice the
use of a MOBcommand "mob force".
`+
Note that two of these mobiles could easily get into an infinite poke
war which slows down (or frequently crashes) the mud just a bit :(
Be very careful about things like that if you can. (i.e dont respond
to a poke with a poke, and try not to let heavily programmed robot mobiles
wander around together. More on that is given above.)
`+
Also, it is clear that the 'order' command could get confused with the 'or'
control flow. However, this is only the case when 'order' is abbreviated to
its two letter form, and placed immediately following an 'if' line. Thus,
if you want to be that malicious in trying to break the MOBprogram code,
noone is going to stand in your way (However, the result of this would be
a bug message and a bail out from the ifcheck so things dont really break)
`+
`#`BMore Examples:`^ `#`Chelp mpexamples1`^
`+
~
END
keyword MPEXAMPLES1~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES2~
text `+
Another example:
`+
This program could be used on a temple guardian mobile, whose job is to
prevent evil characters from entering the sanctuary. Let's assume
the exit to the temple is north (exit 0) and the temple antechamber is
room 2301
`+
In #MOBILES text file:
`+
`#`yM exit 1001 0`^
`+
Or in the olc mobile edit:
`+
`#`yMOBPrograms for [ 1000]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 1001 EXIT 0`^
`+
In #MOBPROGS
`+
#1001
`#`y
if isgood $n
say Hail!
emote salutes $n.
if carries $n holy
mob transfer $n 2301
else
say If you wish to enter the temple, get a holy symbol.
endif
else
curse $n
say Get lost, you scum!
endif
`^
`+
How this works: The trigger is activated when the player tries to exit
north from the room. If the player is of good alignment, the guard will
greet the player. However, the guard will not let the player to the
temple unless he or she carries a holy symbol. If the player is neutral
or evil, the guard will curse and block the way.
`+
`#`BMore Examples:`^ `#`Chelp mpexamples2`^
`+
`+
~
END
keyword MPEXAMPLES2~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING MPEXAMPLES3~
text `+
Example of using DELAY and REMEMBER:
`+
In #MOBILES text file:
`+
`#`yM greet 1002 100
M delay 1003 100`^
`+
In the olc mobile edit:
`+
`#`yMOBPrograms for [ 1000]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 1002 GREET 100
[ 1] 1003 DELAY 100`^
`+
In #MOBPROGS
`+
#1002
`#`yif isevil $n
say You infidel! Go away or face the wrath of mighty Mota!
mob remember $n
mob delay 10
break
endif`^
`+
#1003
`#`yif hastarget $i
growl
mob echo $I screams and attacks $Q.
mob kill $q
else
mob forget
endif`^
`+
How this works: When the player enters a room, the mobile checks if the
player is evil. If this is the case, the mobile makes the player the
target (mob remember) and sets up a delay of 10 * PULSE_MOBILE.
When the delay expires, program #1003 is activated. The mobile checks
if the target is still in the room (hastarget), and if the player hasn't
left, the mobile attacks ($q and $Q refer to the target). If the player
has left, the mobile will forget the player (mob forget).
`+
`#`BMore Examples:`^ `#`Chelp mpexamples3`^
`+
`+
~
END
keyword MPEXAMPLES3~
level 1
category undefined~
see_also TRIGGERS VARIABLES MPCOMMANDS OPERATORS MPSYNTAX MP-BUILDING~
text `+
A Officer requires a "Just Visiting" card in order to enter the jail
area. If the person doesn't have it then they cannot enter, but if they
do have it, they can. The card would only be good for one visit though
before they would have to get another one.
`+
In the #MOBILE text file should have:
`+
`#`y
M grall 3019 100
M delay 3018 100
M give 3017 visiting`^
`+
In the olc mobile edit:
`+
`#`yMOBPrograms for [ 3000]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 3019 GRALL 100
[ 1] 3018 DELAY 100
[ 2] 3017 GIVE visiting
`^
`+
#3017
`#`y
say Your papers seem to be in order.
mob transfer $n 3054`^
`+
#3019
`#`y
if isdelay $i
break
else
say Your papers please.
mob remember $n
mob delay 5
endif`^
`+
#3018
`#`y
if hastarget $i
say Begone if you do not have your papers!
emote shows you the door.
mob transfer $q 3054
else
mob forget
endif`^
`+
When you walk into the room where Hassan is you trigger mprog 3019 where
he asks for your papers. If you don't give him your papers within 5
pulses, mprog 3018 kicks in where he tells you to leave and then transfers
you to another location. (To simulate actually showing you out the door)
If you give Hassan something that has the 'name' visiting card then you
activate program 3017 and he will transfer you to another location.
`+
If I were going to do something like a Jail, I would make it where there
was no physical entrance, just something in the room description where the
jailkeeper mob was that indicated a door. Then if I handed the correct
paperwork to the mob, it would transfer me inside the Jail. Once inside,
just have a one-way exit that would allow someone to leave the jail.
`+
`+
~
END
keyword MP-BUILDING1~
level 1
category undefined~
text `+
To set the mobprog on the mobile, first you need have built the mobile
(see `#`Chelp MOB-BUILDING`^), while editing the mobile , if you type
`#`Ycommand`^ you will notice some commands to deal with mobprog:
`+
`#`Yaddmprog`^ `#`R<vnum>`^ `#`G<trigger>`^ `#`W<argument>`^ - To add a mobprog
`#`Ydelmprog`^ `#`R[number]`^ - To remove the mobprog
`+
When you type show or hit the return bottom on your keyboard you
will see the statistics of the mobile and at the end you will see the
`#`YMOBprogram list`^
`+
`#`yMOBPrograms for [ 3001]:
Number Vnum Trigger Phrase
------ ---- ------- ------
[ 0] 3001 DEATH 50
[ 1] 3010 GREET 100
[ 2] 3011 GREET 100`^
`+
Where you see the number of the program on the mobprogram list, the
vnum of the program, its trigger and argument.
`+
After you have added the mobile program on your mobile, if you edit the
program again you will see at the end of the table the vnum and the short
description of the mobile which has the mobprog:
`+
`#`s=============================================================================`^
`#`yVnum:`^ 3002 `#`yTitle:`^`#`r storyteller-asks for a story`^
`#`yAuthor(s):`^`#`r Reave`^
`#`yCode:`^
`#`csay Ah, you say you want to hear a story?`^
`+
`#`s=============================================================================`^
`#`yMobiles that use this program are:`^
3017 the storyteller (storyteller old man) uses prog 3002.
`#`s=============================================================================`^
`+
Sometimes one defective mobprog (usually invalid if-check) can make all
the mobprogs don't work, to see the vnum of the defective mobprog you can
use the command `#`Ympinfo`^, and see the list below:
`+
`#`B-==============================`^ `#`YMOBPROGS INFO`^ `#`B==============================-`^
Displaying mobprog callstack - calllevel currently is 0
[ 0] MOBprog 2503 on mob 2505 (in room 2521) `#`RABORT (BUGGY???)`^
[ 1] MOBprog 0 on mob 0 (in room 0)
[ 2] MOBprog 0 on mob 0 (in room 0)
[ 3] MOBprog 0 on mob 0 (in room 0)
[ 4] MOBprog 0 on mob 0 (in room 0)
You can select the number of loglines, type mpinfo <number of lines>
`#`y-===================`^ `#`YPiping:`^ tail admin\mpbugs.txt -n 10 `#`y===================-`^
`+
If the message `#`RABORT (BUGGY???)`^ appears next to the mobprog's
number, you should fix the mobprog, usually you have at the end of the
list the error on the mobprog. After you have fixed the mobprog type
`#`Ympreset`^ to reset the mobile programs.
`+
`+
`#`CSEE ALSO: `=_MOB-BUILDING`+, `=_MOBPROGRAM_LIST`+`^
~
END
keyword MP-BOOK~
title THE MAGNIFICENT WORLD OF MOBILE PROGRAMS (MPROGS)~
helpflags builder mud_specific mud_should_customize~
category undefined~
continues MP-BUILDING~
text In this guide to the world of mobile programs `#`C(MPROG)`^ we will discuss each
and every function that we have at this time to our disposal to use on the
Dawn of Time. The section will cover detailed descriptions on every
`#`CIF_CHECK`X, `CTRIGGER`X,`^ and `CVARIABLE`X`^. Along with many, many more abilities, and
functions in the mprog world. I'll try to explain as much as I can with as
much clarity as possible, and help guide you into becoming an Mobile
Programmer. In each section where I explain different types of mprogs,
there will be Mprog examples to help you along the way as well. `1`1First off, let us begin with what exactly is a Mobile Program `#`C(MPROG)`^.
Explaining what an mprog is, is much more simpler than showing how to make
one. First off, a mobile program is something you use for a huge variety of
things. Believe me, as we study deeper into this vast field, more abilities
crop up in the mix, leading one to believe there is no limit's to how much
an mprog can do, the only limit is the mobile programmer's imagination.
Well of course, there is some limits, but once you get the hang of coding
mprog's, you'll see what I mean. Common things that we use Mprog's for are
things like: `CSpecial Attacks`X, `CGuarding Exists`X, `CPC Interaction`X, `CGreetings`X,
`CQuests`X, the list goes on and on. `1`1So let us begin through the step-by-step process on how to create a mobile
program. First off, you'll need to get your `#`CMPROG-CODE-BOOKLET`^ Now what
this booklet does, is its your plane ticket for the ride of your life into
the world of Mprogs. To get your own Mprog-code-booklet go to
`#`Cwww.dawnoftime.org/olc`^`X. Here you will find documents for how to
build your own area, as well as this mprog booklet. Before going any
further through the helpfiles of this introduction to mprogs, go to the site
mentioned above and download the MPROG-CODE-BOOKLET. After downloading the
booklet if you have a printer I suggest printing out the booklet, after
printing the booklet out get a hole puncher and punch holes in the far left
sides of the paper and place each piece in a folder. If you don't have a
printer just copy it to floppy disk and carry it to your local Kinko's, if
there isn't one around where you live, your work office, any other type of
business that will print out for you, will do fine as well. If you have no
access whatsoever to a printer then, loading it up in MSWord or any sort of
text viewing program you have. `1`1As I said above this section will carry you breifly into what Mprog's can
do. If you want a more detailed and full blown small book on how to do
mprog's then download the mprog booklet from the site listed above. If
you've already got the MPROG-CODE-BOOKLET then open it up in a view file or
have your folder handy to use. If you don't have the MPROG-CODE-BOOKLET
then you must at least have the old mprog. Txt file from the site listed
above. So as I discuss how to make these mprogs, you can use the mprog.
Txt of MP-CODE-BOOKLET for reference in its charts, tables, and definitions.
~
END
keyword COMMAND_TRIGGER~
level 92
category undefined~
text Add the Command Triggers in here as you use them please.`+`+`+
~
END
keyword MOBLOG MPTRACE MPINFO DEBUG MOBHELP IFHELP~
helpflags builder~
category olc~
see_also CHECKMOBLOG MEDIT~
text Debugging mobprogs without tools can at times be near impossible at the best
of times. This help entry documents some of the mobprog debugging features
and commands built into the dawn codebase.`+
`+
`=lSyntax:`=? mptrace [lines to look back]`+
`+
The mud mobprog system remembers the last 500 mobprogs triggered. In
addition it records, the type of trigger, the mob which the mobprog was
triggered on, the room the mob was in and the time of the triggering. All
this information can be displayed with the mptrace command. By default
mptrace only displays the most recent 20 triggered mobprogs. You can view
earlier triggerings by specify how many lines back into the trace you want
to look.`+
`+
`=lSyntax:`=? mpinfo [lines to look back]`+
`+
Often bugs in syntax within a program are not obvious initially. In
addition some syntax errors in mobprogs will cause the program to terminate
and be marked inactive until edited. These errors are logged and can be
displayed using the mpinfo command.`+
`+
`=U medit's act moblog flag`=? `+
At times, a mobprog can be behaving in ways you don't intend or not behave
at all... you can tell it is triggering using mptrace and no errors are
showing up in the mpinfo log. In situations like this it can be useful to
see 'what the mob sees'. A mob with the 'act moblog' flag turned on will
log all output from commands run by the mob and other events to the moblog
file. The contents of this file can then be seen using the `=_checkmoblog
command.`+
`+
An example line in a mobprog might read '`gmq6 at 3118 mob transfer $n 3119`=?'.
This may appear to be correct at first, but at is an immortal command.
Turning on the moblog for a mob running this prog, you would shortly see
that the at command was running attune. Then you could correct the prog to
read '`gmq6 mob at 3118 mob transfer $n 3119`=?'.`+
`+
In addition there are two reference commands to help check syntax...`+
`+
`=lSyntax:`=? mobhelp - display a list of all mob commands.`+
`=lSyntax:`=? mobhelp [command] - display matching example notes.`+
`=lSyntax:`=? ifhelp - display help on 'if' mobprog syntax.`+
`=lSyntax:`=? ifhelp [check] - display help on specific 'if' check.`+
~
END
EOF~
#$