-------------------------------------------------------------------------------
                              SLAVE/MASTER HOWTO
-------------------------------------------------------------------------------
 
This document deals with how to use SlaveMaster.muf ('sm' command) in order to
obtain the desired effects.
 
1.- A few words of WARNING (please, READ !):
 
First of all, bear in mind that, despite the authorization scheme implemented
in the program, SlaveMaster.muf is basically a non-consensual program, which
means that once the slave gave the 'OK' OOCly via the said authorization
scheme, many things can happen to them without any further OOC consent being
asked. If you do not agree with the non-consensuality principle, please do NOT
use this program !  Of course, this is not an excuse for players of Master/Dom
characters to violate your right to safeword OOCly any IC action (see the rules
in 'news consent'). Such a violation would be considered an abuse.
 
2.- Checking your current status:
 
Simply type 'sm #who' and it will tell you who you can control, who can control
you, and what is your current status (collared or not, leashed or not, anchored
or not, plus various settings).
 
3.- Collaring:
 
Collaring represents the ownership of the collaring character (the Master) over
the collared one (the slave).
Once a slave is collared, they can be leashed or anchored to a room by their
Master, or other Doms the slave's player gave the OK to.
 
For someone to collar a slave, they must be in the same room as their future
slave and issue a 'sm #collar <slave>' (or simply 'collar <slave>' for short).
The slave's player is then prompted OOCly for their consent and they may either
accept (with 'sm #accept') or refuse (with 'sm #refuse') to have their
character collared.
Unowned slaves must be collared too... The slave can collar themselves for this
purpose, by using 'collar me'.
 
When a slave is collared, a {tag} appears next to their name in the lists
issued by the 'who'/'ws'/'wd'/'3who', 'where' and 'wi*' commands. The tag,
presented between curly brackets, holds the name of the Master.
 
The Master of a slave may perform all the actions which 'sm' allows without
further OOC consent from the slave, but for the #punish action (see below),
and, depending on the slave's setting, for leashing them while they are asleep.
 
There are only two ways for the slave to get uncollared: either by getting the
Master to type 'sm #uncollar <slave>' (or 'uncollar <slave>' for short), or by
asking a wizard.
 
4.- Collar description:
 
The collar of a slave may (and should) be described by their Master. The Master
uses the 'sm #desc <slave>=<description>' command to do so. Once the collar is
described, anyone typing "lookat <slave>'s collar" will see its description,
and the slave will be notifed that this person looked at it.
 
Normal pronoun substitution is performed on the @desc, relatively to the slave,
and the special pattern '$n' is replaced by the name of the current Master.
 
The slave's player may also use the '{collar}' MPI macro in their character's
decription: this macro expands to their collar description but the slave is not
notified of its use (this is usually taken care of by the {look-notify:} macro
in the MPI @desc).
 
5.- Leashing:
 
To be leashed, a slave must first be collared. The slave may choose to allow
people to leash them while asleep (with 'sm #sleep') or not ('sm #!sleep'), the
latter being the default setting. Allowing yourself to be leashed while asleep
also means that the one leashing you will be able to move your sleeping
character around, of course.
 
But for the above #!sleep restriction, the Master may always leash their slave.
The slave may also choose to let other Doms leashing them by typing, for each
<dom>, the 'sm #ok <dom>' command (the authorization stays valid till the slave
types 'sm #!ok <dom>').
To be leashed, an unowned slave must collar themselves first with 'collar me',
then type 'sm #ok <dom>' for each <dom> they accept to be leashed by.
 
To leash a slave, the Master or Dom must be in the same room as the slave and
issue the 'sm #leash <slave>' command (or 'leash <slave>' for short).
 
Once leashed, the slave will follow them everywhere they go, regardless of the
locks on exits (i.e. if the Master can pass through an exit, their leashed
slave will pass through it as well, even if they were not able to pass through
by themselves).
NOTE: The "bouncer" of the MUCK is set so that any leashed player is unleashed
before being bounced away. MUCK restricted areas can't therefore be entered via
leashing if the slave is not allowed in them.
 
A leashed slave can't go away from their Master and any attempt to do so by any
mean will get them yanked back to where the Master is.
 
To unleash a slave, the Master must type the 'sm #unleash <slave>' command (or
'unleash <slave>' for short).
 
If the Master or Dom is asleep and still has the leash attached to the slave,
the slave may choose to snap the leash with 'sm #break' so to be free of their
movements again.
 
6.- Anchoring:
 
To be anchored, a slave must first be collared. The slave may be anchored while
awake or sleeping (there is no restriction about it).
 
The Master may always anchor their slave. The slave may also choose to let
other Doms anchoring them by typing, for each <dom> the 'sm #ok <dom>' command
(the authorization stays valid till the slave types 'sm #!ok <dom>').
To be anchored, an unowned slave must collar themselves first with 'collar me',
then type 'sm #ok <dom>' for each <dom> they accept to be anchored by.
 
To anchor a slave, the Master or Dom must issue the 'sm #anchor <slave>'
command (or 'anchor <slave>' for short). The Master must be in the same room as
the slave so to anchor them.
 
An anchored slave can't go away from the room they are anchored into and any
attempt to do so by any mean will get them yanked back in it.
 
To release a slave from their anchor, the Master or Dom who anchored them must
type 'sm #unanchor <slave>' (or 'unanchor <slave>' for short). Note that only
the one who anchored the slave is able to release them, even if they are not
the slave's Master. It is possible, when the slave is not a puppet, to unanchor
the slave from afar.
 
If the Master or Dom is asleep and the slave is still anchored, the slave may
choose to break the anchor with 'sm #break' so to be free of their movements
again.
 
7.- Punishing:
 
A Master or Dom may punish a slave they got on leash or is anchored in a room
(whoever anchored the slave). The OOC approval of the slave's player is always
needed, though.
 
To ask a slave's player for the authorization to punish their character, the
Master or Dom player must issue the 'sm #punish <slave>' command. The slave's
player then replies with either 'sm #accept' to accept the punishment, or
'sm #refuse' to refuse it. If accepted, the slave may then be forced to "do"
things others want them to do. The 'sm #force <slave>=<action>' command forces
the slave to do <action>, the result being a pose issued under the form:
  <slave>, forced by <dom>, <action>
Example, if John types:
  sm #force Paul=kneels down.
the following will be posed:
  Paul, forced by John, kneels down.
 
Note that only the one holding the leash may force the leashed slave while
anyone in the room can force an anchored slave. A slave can't be forced while
asleep.
 
The punishment lasts automatically after one hour or as soon as the slave's
collar is removed. If unleashed or unanchored during the punishment, the slave
can't be forced until they are leashed or anchored again.
 
8.- Capturing a character:
 
You may try and capture a character, even if they are not collared by you or if
they are not collared at all. The only conditions are that the character is not
already anchored or leashed, and that they accept to be captured. The capture
is achieved by issuing a 'sm #capture <character>' command, to which the
<character> will reply by either 'sm #accept' to accept or 'sm #refuse' to
refuse to be captured.
Once captured, the <character> is "chained" to you (which is the equivalent of
having them on leash, but doesn't require any collaring at all) and you may
walk them around. Unless the <character> allowed you to (with 'sm #ok <your_
character>'), you can't anchor or leash them. There is one exception to this
rule: a captured character can always be jailed (see next chapter).
To free a <character> you captured, just 'unleash <character>'.
 
9.- Jails:
 
Jails are rooms with a special, wizard property set on them. In a jail, any
captured character (or leashed slave) may be anchored regardless of the
permission they gave to the one having captured them, with the condition that
the one jailing them is the jail owner or got the proper key for that jail.
Once anchored in a jail, a character can't leave that room until they are
unanchored by someone with the proper permissions or key, and this even if the
one who anchored them falls asleep (i.e. 'sm #break' is ineffective in jails).
A few properties may be used to customize the anchor, unanchor an yanking back
messages for each jail. 
To free a prisonner, just hold the key (unless you are the jail owner) and
'unanchor <prisonner>'.
 
Here is how to setup a jail:
 
@set here=_SM/~jail:<jail name>  (this must be done by a wizard)
@set here=_SM/anchor:<message posed by the one jailing a prisonner>
@set here=_SM/unanchor:<message posed by the one freeing a prisonner>
@set here=_SM/yankback:<message posed when a prisoner attempts to escape>
 
Here is how to make a key:
 
@create <key name>
To activate the key, a wizard must set the matching <jail name> like this:
@set <key name>=~jail_key:<jail name>
 
10.- Locking for/against slaves:
 
Just use '@lock <object>=@SM/slave?:yes' to reserve <object> usage to slaves
and '@lock <object>=!(@SM/slave?:yes)' to prevent them using it (<object> may
be a thing, an exit/action, a vehicle, etc...).
 
11.- Issued messages:
 
Most of the messages posed when a Master/Dom or the slave use 'sm' are
configurable by the Master/Dom. 'sm #setup' entitles you to configure these
messages. Full pronoun substitution is performed on the messages, relatively to
the slave, and the special '$n' and '$l' patterns are replaced with, respecti-
vely, the Master's or Dom's name and the name of the location (room) where the
Master/Dom is. The messages are automatically prefixed with the Dom's or
slave's name, as appropriate.
 
Note that the #anchor and #unanchor messages may be overridden with messages
set on the room where the slave is anchored, allowing for specific messages to
be issued in prisons, dungeons, whipping posts, etc... The properties to set on
the room are "_SM/anchor" and "_SM/unanchor".
 
12.- Rules about slaves:
 
The SlaveMaster.muf program may be configured so to restrict what a slave can
perform with it on other slaves, allowing to cope with different MUCK themes
and hierarchies. The rules may be different in different areas of the MUCK:
 - level 0 = loose hierarchy : any slave may own and dominate other slaves.
 - level 1 = strong hierarchy: slaves can't collar other slaves but can still
                               leash/anchor/punish/force other slaves.
 - level 2 = strict hierachy : slaves can't own any slave nor perform any dom
                               action on the other slaves.
 
Voregotten Realm is currently set for level 0 outside of the "Slavers' Island",
and for level 2 inside the latter.

Back to the main page.