Morphing

 

Morphing for the Non-Power-Ranger

Ginger’s Guide to Redesigning Your Face


Most characters will start out having just one description–“You see a small red fox.”–and stick with that one for weeks on end. Eventually, however, it dawns on one that it might be a good idea to change clothes, or perhaps bathe, or some ‘toon pours paint on you and you turn bright pink! Either way, thus appears the need to “morph”, or switch your character quickly between multiple descriptions. Characters who have more than one standard outfit, or who often switch to a nude or wet morph, will find morphing useful. Below are some of the easiest ways to set up a morphing program, organised at random:


The Basics of Descriptions

A “description”, as pertains to MUCKing, is whatever shows up when some other character looks at you. It can be anything from one line to six screens of text long, and it is stored in the _/de property on a character. It can be set and reset using the @description or @desc command:

     @desc me=<text>
Ex:  @desc me=You see a fluffy red fox.
     @desc me=A pretty golden stallion.

You can also change the _/de property directly with @set me=_/de:<text>, but it is easier, and neater, to use the @desc command. The description property behaves exactly like any other property on your character(1).

Generally, a description property can only be roughly 700 characters long. However, some lunatics have gotten together and written reams of programs, which allow you to put nifty little codes in your description so that you can make longer descriptions. You can also format text (make paragraphs or lists) and even insert ASCII pictures in your descriptions.

The use of morphing programs comes about because, in general, you can only describe something in one way at a time. If your description says, “You see a fox wearing a pith helmet.”, anyone who looks at you will see you wearing a pith helmet, even if you are 600 miles underwater, in a mini-mall, or standing on the moon. Morph programs will allow you to make many separate descriptions (you wearing a pith helmet; you wearing a swimsuit and scuba gear; you wearing a “Mallrats” T-shirt; you wearing a spacesuit), and switch between them quickly when you move around on the MUCK.

(1)A thorough tutorial on properties and their functions, limitations and usage may be found on the MUCK itself by typing “help properties”.


Morphing by Hand (or Paw)

The simplest mode of morphing is by hand: simply rearranging your description whenever you need to change. You can, of course, change your description at any time by typing:

     @desc me=<your new description>

Of course, if you change clothes a lot, this can get monotonous, because you’d have to type the full description out each time. This is where “propswitching” comes in. Just type the following line, exactly as you see it below, while on the MUCK:

     @desc me={index:clothing,this}(2)

Now you can make multiple morphs as follows: for each change of clothes you wish to wear, set a property on yourself. Then whenever you wish to change clothes, you can simply set the value of the property clothing on yourself to the name of the property to whose morph you wish to change. This sounds complicated, but watch this example:

     @desc me={index:clothing,this}
     @set me=blueshirt:You see a red fox wearing a blue shirt.
     @set me=redshirt:You see a red fox wearing a red shirt.
     @set me=clothing:blueshirt

In the first line, you’re setting up the description property. In the second and third lines, you’re setting up two different morphs by setting properties on yourself. The name of the property is the name of the morph; the text contained by the property is the description which will show when you switch to that morph. The morph in line two, for example, is named blueshirt, and the description which will show when you switch to that morph is:

     You see a red fox wearing a blue shirt.

In the fourth line, you are switching to the blueshirt morph, by setting the value of the property “clothing” to “blueshirt”. If you wanted to switch to the redshirt morph, you would type:

     @set me=clothing:redshirt

You can switch between the morphs as many times as you like, and it doesn’t matter what you call them. Property names can have spaces, too, so you could call them blue shirt and red shirt if you felt like it.(3)

ADVANTAGES: DISADVANTAGES:
  • You can have as many morphs as you can write properties.
  • You can switch between morphs with a one-line command.
  • Relatively simple method to learn (good for beginner MUCKers)
  • You’ll lose track of all the property/morph names if you have more than ten.
  • No real way to insert pictures or format text.
  • Descs still limited to roughly 700 characters.

(2)Information on {index} is available by typing “mpi index” while online.
(3)Or even kumquat, home on the range or We hold these truths to be self-evident, if that were the kind of thing that struck your fancy.


Triggur’s Morph Hammer

(Program by Triggur@FurryMUCK)
If it’s installed on your MUCK, help is available via morph #help. This is a very nifty menu-based critter–it’s a little crude to set up, but once it’s running, it’s the proverbial set-it-and-forget-it morph program. You’ll need to understand lsedit lists to get the basics, and it’s helpful if you know a little MPI (see my tutorial) as well, to get the most out of your morphs.

From the docs: (morph #help2)
To use this program, edit your current attributes (by hand or with PEDIT(4) to get exactly the form you want. Type morph #add and your current description, sex, species, scent, say and osay will be copied as a new morph. You will be expected to answer a few questions:

  • First, the ‘command’ associated with this morph. This should be one word like ‘2leg’ or ‘mwolf’ or somesuch.
  • Next the name of the morph. Only you will see this when you type morph #list.
  • Finally, the text it should print when you change to that new morph.

To add another morph, simply edit your current description again and morph #add again. Lather, rinse, repeat. ๐Ÿ™‚

WARNING: If your description is currently using @$desc (@6800 on Furry), the whole description will be _converted_ to a single MPI list. Also, be aware that when you change to a morph, your description will be overwritten. If you have multiple descriptions you want to make morphs for, be sure to MORPH #ADD them all *before* trying to test one of the new morphs. PLEASE DELETE YOUR OLD MORPHS!

….Basically, what happens in this is that you set yourself up completely, by hand, each time–no, no menus or anything like that; you set yourself up from scratch, exactly as you want your morph to appear. Then you type morph #add and Morph Hammer magically creates a morph for you. You then set yourself up by hand again and again, for each morph you wish, eventually, to have, and type morph #add for each one. Once you are done, you can just switch between the morphs you have created with morph or qmorph. You just have to set each morph up by paw first.

ADVANTAGES: DISADVANTAGES:
  • You can change your say, osay, and scent properties as well as your desc.
  • Sturdy, menu-driven interface for adding/deleting morphs.
  • Easy list of morphs with descriptions.
  • Very fast switching between set morphs–good for multiple-character setups where one player plays two or more totally different characters.
  • Difficult for beginners to set up. (Help file? What help file?)
  • Hard to edit morphs–you often have to start over completely.
  • Not very versatile.
  • Is only found on the largest MUCKs.

(4)PEDIT is one of the many player-editor programs available–others are editplayer and setup. These player editors vary from MUCK to MUCK–you might have to hunt to find one.


“@6800” $desc Program

(Program by Conrad Wong)
The $desc program is sometimes called @6800 because that is its database number on FurryMUCK, the original, and still the largest, furry-based MUCK. $desc is a complex MUF program which can be called in your description by prefacing your description with @6800 (on FurryMUCK or FurToonia) or @$desc:

     @desc me=@6800 <text>
     @desc me=@$desc You see a fox wearing a red shirt.
     @desc me=@6800 This young vixen is wearing a flea collar.

$desc’s value lies in its commands, which can be inserted into the text of your description to arrange the text in special ways or to aid in morphing. The example below copies the {index:clothing,this} description from above

:

     @desc me=@6800 %sub[%sub[clothing]]

You would morph using this setup the exact same way you did with the MPI description in the beginning: @set me=clothing:redshirt and whatnot.

$desc offers a little more precise formatting than simple properties, and a number of little technical toys that aren’t available in Morph Hammer(5). For example, the %rand[] tag will pick a line from an lsedit list at random. %time[] and %date[] will pick a line from a list according to the hour of day or the date, allowing you to have descriptions that vary with the time or the seasons. Complete docs for $desc are available with @view $desc. The following is the beginning, most useful part of the docs:

$desc is a program that you can use to make more complex messages on descriptions, success, fail, and drop messages. To do so, type this: @desc me=@$desc (description) The description is a normal text message, but may include special “tokens” which are translated by the $desc program to normal text.

For example, you might write this:

    @desc me = @$desc A cute little fox with %sub[color] eyes.
    @set me = color:green

Then when someone looked at you, they would see:
A cute little fox with green eyes.

All tokens are of the form %token-name[parameters] and you may nest tokens, so that you may have descriptions which look like this:
@desc me = @$desc %sub[%sub[morph] %sub[clothes]
This would take the property name that you had stored in the property “morph”, and substitute the contents of that property. It would also take whatever you had in “clothes” and add that into the description.

You should also bear in mind that lists, when mentioned below, are lsedit lists, which may be created by doing this:

    lsedit object = listname
    (first line of the list)
    (second line of the list)
        ....
    (last line of the list)
    .end

[Lsedit lists are just lists of properties spit out in order. This is useful for formatting, or inserting pictures into your descriptions. To get help, type lsedit me=temp, then type .h on a line by itself and hit enter.]

Common/useful $desc tags:

%sub[<match,>property]
Example: %sub[color]
         %sub[me,species]
         %sub[here,night]
         %sub[#321,small]

%sub[] is used to take the contents of a property. It normally takes the property from the object that is looked at, but can be set to use properties from other objects, as shown above.

%rand[<match,>listname]
Example: %rand[buttons]
         %rand[here,songs]

%rand[] takes one of the lines in a list at random. As with %sub[], it normally takes this from the object that is looked at, but can take properties from other objects. %rand[] differs in that it expects the name given to be the name of a list created with lsedit, not a property name.

%time[<match,>listname]
Table: one item in list -- full day
       two items in list -- midnight to noon, noon to midnight
       three items -- midnight to 8 AM, 8 AM to 4 PM, 4 PM to midnight
       four items -- midnight to 6 AM, 6 AM to noon, noon to 6 PM,
                      6 PM to midnight
       six items -- midnight to 4 AM, 4 AM to 8 AM, 8 AM to noon,
                      noon to 4 PM, 4 PM to 8 PM, 8 PM to midnight
%date[<match,>listname]
Table: one item in list -- full year
       two items in list -- January to July, August to December
       three items in list -- Jan. to Apr., May to Aug., Sept. to Dec.
       four items in list -- winter, spring, summer, fall
       twelve items in list -- monthly

%time[] selects one of the lines in a list, based on the time of the day. That is, the first line corresponds to just after midnight, the last line is before midnight, and all the lines in between are mapped over the day. %date[] is similar, but it does this over the year so that you can have descriptions which vary with the season.

 

%list[listname]
Example: %list[desc]

This prints out the first part of the description before the %list[], then prints each element of the list on its own line, then resumes printing the rest of the description. This can be useful when you want to print pictures or lists of items. Note that %list[] cannot be used as an argument so something like %sub[%list[]] will simply look for a property named “%list[]”.

ADVANTAGES: DISADVANTAGES:
  • Lots of nifty little toys, including descs that change by time of day, season or location.
  • Good formatting ability.
  • Can combine lots of different things into description (a list, a property, and a variable line that changes by hour)
  • Found on most of the bigger MUCKs.
  • Extensive documentation, found via @view @$desc.
  • Docs are very long–no “quick reference”.
  • You won’t use all the toys.
  • Program sometimes lags server.
  • Formatting less precise than with MPI.
  • Cannot be combined with MPI or Morph Hammer.

(5)Unless you know a great deal of MPI, that is. Morph Hammer can do a lot more when combined with MPI.


Whitefire’s gen-morph

(Program by Peter A. Torkelson)
This is the other of the original morphers, #17812 on FurryMUCK and #433 on FurToonia. It is a slightly more complex morpher than $desc or Muf-Morf. Its main advantage is not its ease of use but the fact that you can change any properties you like between morphs–including pinfo, whatis and page properties. The basic idea here is that each morph is called a “race”, even if all your morphs are of skunks. Your nude morph is a race, and so are each of your clothed morphs. You set a whole bunch of properties associated with each race, and when you switch to that particular race, all those properties are changed.

From the documentation:
To set yourself up add the following properties to your character:

   _race:<curent race>         This is the race you curently are.
   _race-<race>:yes            This tells the program this race is OK to
                                     switch to. Keeps you from becoming an
                                     "oxtaur" by mistake. One for each
                                     race.
   _morph-<race>-desc:<text>   The description to set for a particular
                                     race.

That’s the basics. Now create an @action attached to yourself, named anything, like “morph”, and then @link it to this program. To alter yourself, type morph [-][+]<race>[=<message>].
The prepended – requests the change be made silently.
The prepended + allows you to overide restrictions on morphing to/from certain races.
The optionally appended =<message> lets you overide the message gen-morph would normally print with one of your own.

FUN STUFF:
 Alternate prop locations:
   _morph_proploc:<dbref>        Tells the program to look at this dbref
                                 for morph properties. Useful to keep
                                 clutter down on your character.
   _proploc:<dbref>              Same as above.

 Transformation messages:
   _morph-<race1>-<race2>:<text> Prints a message when changing from
                                 race1 to race2. 'def' may be put in place
                                 of either. The message will be prepended
                                 with your name, and pronoun subs work [use
                                 %% to get subs on the new sex], as well as
                                 %oldrace and %newrace.
   _morph-def:<text>             If none of the above are from the text
                                 from here is used.
   _morph-<race>-name:<name>     Set the name for the %newrace and %oldrace
                                 substitutions.

 Sex changes:
   _morph-<race>-sex:<sex>       Change the character's sex: property
                                 when morphing.
   _morph-def-sex:<sex>          Default when morphing if there is not
                                 one for the race..

 Misc:
   _morph-<race>-prop-<n>:<prop>[=<value>]
                                 This list allows you to change a set of
                                 properties when changing to a race. If
                                 you do not provide a <value> the prop
                                 is removed.
   _morph-def-desc:<text>        Default description if there is no
                                 _morph-<race>-desc: for the race.
   _morph-<race>-<race>:no       Disallow changing from a certain race
                                 to another directly.
   _morph-<alias>-alias:<race>   Alias for a race, useful to make it typing
                                 it easier.

 Set by the program on you:
   _race-name:                   This is set to the 'full name' of the race
                                 you curently are.
   _race:                        Set to your new race when you morph.

This looks complex, and is. Here’s an illustration of creating a pair of morphs: a nude and a clothed, for a fox morph.

     @set me=_race:clothed     (puts you in the "clothed" morph)
     @set me=_race-clothed:yes
     @set me=_morph-clothed-desc:A fox in a Hawaiian shirt and loud plaid pants.
     @set me=_morph-clothed-name:clothed fox
     @set me=_race-nude:yes
     @set me=_morph-nude-desc:A naked fox.
     @set me=_morph-nude-name:nude fox
     @set me=_morph-clothed-nude:takes off %p clothes.
     @set me=_morph-nude-clothed:puts on %p clothes again.

To switch between the morphs, you would type morph nude to strip, morph clothed to put your clothes back on (naughty foxie!). The program will print out “Bob takes off his clothes.” when you strip, and “Bob puts on his clothes again.” when you get dressed–assuming your character name is Bob, that is. The desc properties can be up to 700 characters long, and can (yes!) contain MPI and program calls. The _morph-<race>-name properties are for the default morphing messages, which read something like “Bob changes from a <race name> to a <race name>”. The program replaces <race name> with the _morph-<race>-name: properties for each race, respectively.

The big disadvantage to this little wonder is that, when you type examine me=/, you are spammed to heck and back! That’s what that little proploc thing is for–you can put all these props on another object and not have to worry about them.

ADVANTAGES: DISADVANTAGES:
  • Works with MPI, $desc, and most other programs.
  • Changes any properties desired between morphs.
  • Easily customised morphing messages.
  • Can get very spammy when you examine yourself.
  • Convoluted, confusing first setup.
  • Hard to identify/separate/delete or edit morphs later.

Chetar’s Muf-Morf!

(Program by Chetar@FurryFaire)
This is #50603 on FurToonia, and #170673 on FurryMUCK. The following are the @view docs, written by Chetar and edited for HTML and in some cases for clarity.

Purpose:
An easy to use morph program, providing seperate messages depending on new form and previous form. Built-in editing and setup. Compatible with Warwick’s “Say” and Mystique’s “Talk” for changing of say messages.

Installation:

     @act morf;smorf;qmorf;eform;morfdefs;edesc;ldesc;sdesc=me
     @link morf=<#dbref of this program>
  • Begin with eform <two letter form code>
  • Set species, gender, change messages.
  • If using Mystique Talk, setup Talk, Exclaim and Query
  • If using Warwick Say, setup def say/osay.
  • Add your first description with edesc <two lettercode-descname>
  • Add more descriptions as needed, be sure nude descs are named <twolettercode-nude+moretext> if more than one nude

Command Summary:

    morf       <desc name> to change
    qmorf      <desc name> to change quietly
    smorf      to show current form
    edesc      <desc name> to edit a description
    ldesc      list all available descriptions and forms
    sdesc      <desc name> to display a desc
    eform      <twoletter form code> to edit form settings.
    morfdefs   setup default settings for the program.

Example of installing a single form, two descriptions:

    morfdefs            set defaults and install @desc
    eform fl            provide the program with the requested data
    edesc fl-clothed    puts you in editor, type description
    edesc fl-nude       type description

To put it a different way–@link an action to the program, and type morfdefs to set it up on yourself. The little two-letter codes are morph names, and can be any two letters you please. Typing eform <code> puts you into an editor, where you set up your say, osay, species, etc. The edesc command lets you make multiple descriptions to go with the say/osay/species properties you set up for the form…what this means is that you have a set of say/osay/species properties defined as a form:

     FORM: fl                        FORM: ni
     say:  wuff,                     say:  erf,
     osay: wuffs,                    osay: erfs,
     species: fluff                  species: wolf

In that form, you can change between descs–you keep the say, osay, and species props while you change between descriptions. Thus, fl-nude would have the fl-form’s say/osay and the nude description, fl-clothed would have the fl-form’s say/osay and clothed desc, and the ni-clothed morph, if you made one with edesc ni-clothed, would have the ni-form’s say/osay and a different clothed morph.

ADVANTAGES: DISADVANTAGES:
  • Changes say/osay/species/etc. between morphs.
  • Allows you to have multiple descs for each form (less trouble setting up descriptions than with Morph Hammer).
  • Good interactive setup.
  • Quick shifting, quick listing of available morphs.
  • Quick editing of descriptions–even while you’re wearing them.
  • Program isn’t available everywhere (talk to its owner to port it).
  • Doesn’t allow for MPI or other programs in the descriptions. (I.e., no toys.)

MPI Macros

MPI is Satan’s system to learn, but once you’ve mastered the basics, you can pull some incredible stunts with your description. In the example above, you saw {index:clothing,this}, an MPI macro, used in a description. If you know some basic MPI(6), you can set up a smart little morphing system this way:

  • Create an action called morph attached to yourself and linked to $nothing.
  • Type @set morph=H, no matter how silly that sounds. This lets the action accept MPI programming.
  • Type @succ morph={store:{&arg},morph,#<your dbref>}
  • Type @desc me={eval:{list:{prop:morph,#<your dbref>}}}
  • Create lsedit lists on yourself for each morph you’d like; for example, for a clothed morph called “clothed”, and a nude morph called “nude”, make two lists, one for each description, “clothed” and “nude”.
  • Type @set me=morph:clothed.
  • To switch between morphs, type morph <name of appropriate lsedit list>…for example, morph clothed and morph nude will switch between the “clothed” and “nude” lists on your character.

That is, of course, a very basic example, which doesn’t do anything more complex than, say, gen-morph. Once you get the hang of it, though, you can customise the MPI action however you please, adding @succs and @osuccs to the morph action to put out custom messages when you morph, making it possible for others to morph you, arranging your morphs so they are different depending on where you are and who you’re with.

That, and this is the more techno-geek solution, for us oldbies who were online for years before MPI was even invented. ๐Ÿ™‚

ADVANTAGES: DISADVANTAGES:
  • Integral with MUCK server. Doesn’t lag like $desc.
  • Very precise text formatting in desc.
  • System can be modified to exactly fit your needs.
  • Lots of toys like in $desc, but with online help (mpi <command>).
  • Can manipulate objects, store properties, keep and alter lists, force yourself to do things, and do other things not possible with other programs, dependent on your description.
  • Difficult to grasp for beginning MUCK users.
  • Very buggy and frustrating to program if you’re trying to do complex things–“nesting” command structure hard to visualise.
  • Only really useful if you’re going to do something terribly complex.

(6)What’s MPI? Read this tutorial before you try to puzzle this out!


Other Morphing Programs

A number of crazed individuals have created their own versions of morphing programs, including room and exit (????) morphers. If they’ve been kind enough to provide such a program, it is usually listed under “plib” or “programs” online.

pdc-morph.muf (by P. Damian Cugley): #3272 on FurToonia, #8813 on FurryMUCK
This program is designed to be useful for making an object {such as a player} with a description that can be easily changed with one short command. The idea is to set up your object to use one of the properties-based general-description programs to generate a description; then all that this program needs to do is change some properties and print appropriate messages.
gen-change (by Vulpis): #27531 on FurryMUCK
A general morphing program, used to change properties from one value to another relatively quickly. Can be used on objects as well as players, and can change any properties, like gen-morph, but, again, is a little hard to set up. More aimed at morphing objects than players.
improved_morph.pgm (by D. Maxwell): #11683 on FurryMUCK
Features: 

  • Ability to change descriptions at will {of course}
  • Customized messages for different ‘morphings’
  • Storage of forms onto a separate object, if desired.
  • Help screen for easy reference.

A quick note: This program works in conjunction with $desc.


Glossary

Desc
Also description. What others see when they look at you. Several lines of text, generally implying that you are a huge and muscular male or a lithe, demure female with extremely obvious secondary sexual characteristics. Your mileage in these areas, of course, may vary.
Lsedit
A program which allows you to precisely format text, keeping lists of properties and spitting them back out in order. (Good for ASCII pictures, descs with intricate formats or lists.) Help is obtainable by typing lsedit me=test, hitting enter, and then typing .h and hitting enter. To escape the editor, type .end on a line by itself and hit enter.
Morph
As a verb, to change between shapes, clothes, species, or whatnot. As a noun, one of those many shapes. For example, you can morph between being a fox and being an avocado, and if you change from your clothed desc to your nude desc you have morphed into a new description.
MPI
My Personal Insanity. There’s another translation for the acronym, but it’s not as appropriate. MPI is an in-server programming language that lets you insert commands directly into descriptions or other messages and do some pretty hefty things. Unfortunately, it’s just hell to learn. Try the tutorial.
Osay
The verb others see when you speak. The default is “says”. For example, in “Ginger wuffles, “Please stop poking me with that tomato.””, wuffles is the osay.
Plib (Program Library)
Simply an online listing of available programs. Can often be searched. Help is usually found with programs #help or plib #help. May not be installed on all MUCKs.
Pronoun Subs(titutions)
On a MUCK a lot of automated messages are spit out, from exits, rooms, and players. Some morph programs spit out automated messages when you switch from one form or another, too. These automated messages sometimes use pronouns, like him, her, or it, that change when you change gender between morphs. Pronoun substitution allows you to put little tokens (%s, %o) into the automated messages which will be read and replaced with the appropriate pronoun. For more help, get on the MUCK and type help subs.
Property
Basically, a place on your character to store a value. See the explanation on the MUCK under help properties.
Proploc (Property Location)
An object which you carry which stores properties for you. For example, gen-morph can get a little spammy when you examine yourself, because of all the properties you need to set to make it work. If you set up a proploc, you can keep those properties on some other object, and make your character less spammy.
Say
The verb you see when you speak. The default is “say”, thus the name. For example, in “You imply, “Would you like to rub my kumquat?””, the word imply is the say.
Spam (Spammy)
As a verb, to spam means to fill the screen with meaningless or exceedingly verbose text (much as I am doing here). As a noun, spam refers to that meaningless text. As an adjective, spammy means something that is behaving as a spam, filling your screen with stuff you don’t need or want to see.