Shall we begin?

Dream Editor Overview

First things first; boot up the Dream Editor (DreamEd.exe), which you should be able to find in your main Furcadia directory. If you already have a dream open, select File > New in order to ‘clear’ the current dream from the editor’s memory. Note that the editor can only have one dream open at a time, and that dream is what is uploaded to Furcadia by pressing the Place Dream (Ctrl+T) button; though that being said you do not need to have the editor open in order to upload a dream.

By default, the editor opens up a 140×70 tile map, with a default ‘green grass’ background. Before we start, I’ll let you explore the editor a little bit (assuming this is your first time working with it). The main tools that you will be using are found to the left of the screen, under the minimap (which gives you a very small rendition of your overall dream).

The first thing is the object properties palette. In Furcadia, there are three types of object; floors, walls and, well, objects. As suspected, floors go on the ground. They are usually (but not always) walkable, and can have objects and furres sitting on top of them. Walls are generally impassible barriers… except when they contain doors. They stand on the ‘edges’ of floor tiles, and do not interfere with objects. Almost everything else in Furcadia is an object. Trees, tables and lamps are all objects, as are ‘gettable’ items like keys and weapons. Only one object may be in a square at a time. Objects are rendered (drawn) ‘underneath’ any furres occupying their square, behind any object/furre occupying a square in front of them, and in front of any object/furre in a square behind them. If a large object is occupying the same space as a wall, it may be clipped awkwardly by the wall segment in front of it.

The object properties palette shows information about the currently selected object/floor/wall, including its ID number, what it looks like, and whether it is sittable/gettable/walkable. If an object is walkable it means your furre can walk on top of it. A sittable object will force your furre to sit when they come into contact with it (such as chairs and pillows). And a gettable object can be carried around.

Clicking on the preview of the object will bring up the full object palette. The interface is a little dated, but from this window you can pick which object/floor/wall you wish to place. Space bar will move to the next page of objects, until the selection has been exhausted and it comes back to the beginning. Left clicking an object will turn that into your ‘brush’ and you can then place it anywhere you like on the map. Left click to place the object. Objects ’stick’ to your brush, so in order to drop them you will either have to select another object, or to right-click in an empty square. Right-clicking onto of any object will also turn your brush into that object. Note that this will work depending on your brush type — as indicated by the three icons below and to the right of the object properties. If you’re currently working on walls, right-clicking on an object in a square with no wall will clear your wall brush rather than pick up the object. You can remove objects/floors/walls by either over-writing them with something else or by ‘drawing over’ them with an empty brush (object type #0). Note that floor #0 is grass; represent ‘dead space’ with black (#161) instead, though note that by default this is walkable.

The next thing to lookout for is the brush-type toolbar. Generally you want to be placing single objects (the pen), however to fill in a defined area you can use the selection. To fill in the whole area, use the bucket.

The final thing we’re going to look at is the Information palette. This will give you info some details about the square your brush is currently hovering over, as well as the general size of your dream. The Current X and Current Y values are especially useful, and we’ll be pulling them out later on when we start up with DragonSpeak.

Anyway, get the hang of the editor by laying down some random floors, walls and objects. The interface is pretty archaic (though as of the Kitterwing update you can actually resize the viewing window; gasp) and I find it takes a lot of getting used to. When you feel that you’re doing okay, ‘clear’ your existing dream by going to File > New. We’re ready to build our dream.

F!W’s Tutorial Dream: The Grotto

There are a lot of big dreams in Furc. In fact, oversized and empty dreams seem almost de rigueur. I hate these things with a passion, so we’re not going to make one of those. Instead, we’re going to make a small ‘grotto’ space where we can hang out and chat with a few friends. In keeping with this theme, we’re going to make a small forested area; not unlike the one that graces the current F!W header image. In this tutorial we’re also going to start up with some basic DragonSpeak, including commands and an animation. Sound good? I thought so.

Okay, first things first; before we even lay down a single floor tile, go to Patches > Dream Settings (Ctrl+L). This window is fairly self-explanatory, and you can pretty much fill it in however you want. Note that we aren’t using a custom patch. For now, the default stuff that comes with Furc is good enough for us. When you’re done, click OK. Before we continue, we should really save our dream. Stick it wherever you think you’ll be able to find it again; mine’s in My Documents/Furcadia/Dreams/fwtutorial.

With that saved, it’s time to start building our dream. This is the fun part. We’re going for a secluded forest grotto, so start out with a square of grass in the top left corner of your map. You’ll have to expand this out later, but for now this is a good starting point. Now it’s time to start adding the detail. I built up the map in the following way:

• First I added a ‘frame’ of large trees around the north-west and north-east borders.
• Next I started to lay down some mid-size shrubs and ferns. We want a real ‘enchanted forest’ kind of vibe, so keep everything tight and busy; but remember to leave it open in the middle.
• More details, including the long grasses. I originally added a border of shrubs around the south in order to give the place a ‘cross-section’ kind of view. However it looked way too regular. Hrm…
• More big trees! This time, we want to completely pad out the viewer’s windows (it’s that large square that appears around your cursor) so that no matter where they’re standing all they can see is green.
• I laid down grass floor underneath my ‘forest’. Small gaps were filled in with more smallish shrubs/trees.
• Once satisfied with the greenery, I threw in a few random rocks.
• Finally, I added a pond (#1070) to the northern corner.

The trick here is wabi-sabi; you’re trying to emulate a ‘natural’ scene, so don’t be too regular. There is enough default greenery in the basic Furcadia items list that you should be able to avoid have too many of the same object standing next to itself (except for the grass, since this is the look we’re going for). Essentially, you want to landscape like a bowl; high stuff around the outside, lower stuff in the centre. Use a few rocks as accents, but not too many since it will weigh down the scene. Remember; enchanted forest!

Once you’re happy with your initial landscape, go Walkthrough > Run Walkthrough (R). This will open up a kind of faux Furcadia session. Wander around a bit. Check your clipping. Check that you can’t walk off the map. Check that you can’t see any ‘black space’ devoid of trees. I should point out that the editor’s walkthrough renders objects a little differently to the real Furcadia, and it sometimes misses the corners of large objects that have their base off screen. Furcadia itself doesn’t do this, but if you’re worried about ‘holes’ around the edges, backfill underneath the outside trees with smaller shrubs.

Anyway, I found two errors in the walkthrough. One was a path were I could walk off the map; back in the editor I blocked this up with a larger, non-walkable bush. The second was the fact that my furre could walk under the pond. This is a classic example of bad clipping and something that should be cleaned up. The area was too open to add in more bushes, so instead I went and found object #254; the Unwalkable Object. Technically invisible, the Unwalkable Object does exactly what it claims; furres can’t walk onto any square it occupies. Since the ‘base’ for the pond is actually in the object’s bottom right corner, I filled in the rest of the tiles underneath it with Unwalkable Objects. I then re-ran the walkthrough a couple of times to make sure I was satisfied with the ‘neatness’ of my creation. Neatness is very important in ‘weaving, and easily separates out the great dreams from the mediocre ones. Yes, your visitors do notice, so make sure to take some time to clean up.

Okay, so now we’re reasonably happy with the look of our dream, but what about what it does? Well, right now it does nothing. Let’s fix that; go DragonSpeak > Run DS editor (D).

Basic DragonSpeak

There’s nothing scary about DragonSpeak. While you can do some crazy fun stuff with it, the basics are pretty basic and it doesn’t take much to make some impressive dream effects. The first thing you have to know about DS is that it’s pretty much written in English; commands do exactly what they sound like they do. The second thing is that the default DS editor neatly lists out all the DS commands, numerically by type, and clearly marks up what variables each line expects.

The first time you open up the DS editor in a new dream, you’ll see a few lines similar to the ones above. It’s not doing much; nothing really except for suggesting a start location for furres who warp into the dream. This location is probably wrong. To fix it, find the co-ordinates of a tile that is better using the Information window (see, I told you Current X & Y would come in handy). Change the brown numbers in the brackets on 5:15 to these co-ordinates. Test it with the walkthrough. That’s your start location. Easy.

Some more notes about the DS Editor. The layout is fairly intuitive; the main part of the screen is filled with the raw commands, while the bottom pane lists all possible commands broken down into Causes, Additional conditions, Areas, Filters and Effects. Have a flip through these tabs to get a bit of an understanding on what the difference is and how to use them. To add a command to your script, simply double-click it in the bottom pane and it will appear at the position of your text cursor, all neatly indented and everything. Variables are marked by the editor in brown; the brown text indicates that you should add in your own values.

One more thing before we start; hit the little + button just above the commands reference until it reads Expert (variables). This will open up all DS commands instead of just giving us a basic list.

Okay, let’s start coding. We’ve got something that plunks a new furre in the dream down at some starting location, but that’s it. We should probably be nice and give them some kind of direction when they get there. This is called the entrytext, and we set it using 5:210.

/* setting up the dream */
(0:0) When everything is starting up,
(5:212) set silent speech prefix (for spoken commands) to {*}
(5:210) set entrytext to {Welcome to <b>The Grotto</b>. Type <b>*help</b> for help.}

0:0 indicates to us that the following effects will be executed when the dream is first uploaded, and will continue to be in effect for the entire life of the dream. We’ve set two effects to occur; 5:212 and 5:210.

5:212 is a great effect that not nearly enough dreams use and I can’t for the life of me fathom why. You use it in conjunction with spoken dream commands to ’squelch’ (silence) the output. I’ve used an asterisk here, so anything anyone says anywhere in the dream, whether it is a command or not, starting with an asterisk will not be broadcast to other furres. Technically you can use any character — or string of characters — here, but be wary of anything used internally by Furcadia (such as `) or by common proxies (like Furnarchy’s use of @).

5:210, meanwhile, sets the dream’s entrytext. This will be shown to any furre upon entry into the dream. The ‘usual’ Furcadia HTML (<b>, <i>, <u> and <a>) works here; and in fact in any text DS sends to Furc’s chat buffer.

To test your DS, you can either upload your dream to Furcadia somewhere or run it in a dev environment like Dreamer. Actually, Dreamer is pretty awesome and y’all should download it anyway. Go do it now.

The next thing we’re going to do is the animation, mostly because it’s really easy and looks cool. The code for it is:

/* the animation */
(0:100) When 1 seconds have passed, offset by 0,
(3:1) everywhere on the whole map,
(5:400) Cycle the three object types in this sequence one step forward: 1070, 1071, 1072.

0:100 sets up what is called a ‘tick’. The first number (in this case 1) represents the number of seconds that you want each tick to ‘fire’. This particular cause ticks every one second. The second number is how many seconds ‘delay’ do you want before the tick starts. We want it to start immediately, so we put 0.

3:1 is a filter, but it’s a pretty all-inclusive one; it tells the cause to work everywhere on the whole map.

Finally, 5:400 does the actual animation. It takes three object IDs and simply cycles through them; so Object #1070 becomes Object #1071 and so on. The three objects we’ve specifies here are all versions of the pond with different surface ripples, the end effect looks animated.

The next set of commands are all variations on a theme, so I’m going to lump them together. They’re the different dream commands.

/* dream commands */
(0:31) When a furre says {*help},
(5:200) emit message {You may use the following commands within this dream:} to whoever set off the trigger.
(5:200) emit message {<b>*help</b>: You're looking at it.} to whoever set off the trigger.
(5:200) emit message {<b>*about</b>: Basic dream information.} to whoever set off the trigger.
(5:200) emit message {<b>*look <i>[object]</i></b>: Look around or at objects.} to whoever set off the trigger.

(0:31) When a furre says {*about},
(5:200) emit message {<b>The Grotto</b>, a tutorial dream developed by the nice folks at <a href="http://furc.void-star.net/wank">Furc!Wank</a>.} to whoever set off the trigger.

/* looking */
(0:31) When a furre says {*look},
(1:8) and they can see position (18,21),
(5:200) emit message {You have reached a small clearing in the forest. A small <i>pond</i> ripples gently to the north, and a small ring of <i>rocks</i> have been laid out in the south.} to whoever set off the trigger.

(0:31) When a furre says {*look pond},
(1:8) and they can see position (18,17),
(5:200) emit message {A small <i>pond</i> ripples gently in the breeze. You think you can see something glinting at the bottom...} to whoever set off the trigger.

(0:31) When a furre says {*look rocks},
(1:8) and they can see position (18,23),
(5:200) emit message {A small ring of stones has been arranged here. They look perfect for sitting and enjoying the scenery.} to whoever set off the trigger.

Dream commands! Note that we’ve prefixed them all with our squelch-character (*).

I suspect at this point it’s fairly obvious, but I’m a big fan of those old-style command-based adventure games; things like King’s Quest and Zork. To that end, here I’ve set up a system of ‘looking’ very similar to the one which used to appear in those old games. They all use the additional condition 1:8, which is pretty useful in this kind of situation since it checks what is drawn on a furre’s screen, and whether they can ’see’ a certain object (there are other conditions that you can use instead, including make sure a furre is standing in a particular spot, or within a certain area). Obviously it makes no sense to *look pond if there’s no pond to look at. Objects that can be looked at are marked with italic text in descriptions just as a little visual clue to the visitor.

And that’s about it. Save your DS and re-test your dream; congratulations, you’ve successfully made a neat little semi-private where you and some mates can hang out, enjoy the gentle ripples of your animated pond and relive 1989 with your text-based look commands. You’ll note that in my final product I re-arranged my previously semi-random rocks a bit into a sitting ring. Hopefully by now you’ve had enough of an introduction to the dream and DS editors that you can start compiling more extensive dreams. Remember; have fun and experiment!

As to the glinting object in the bottom of the pool? Well, you’ll have to wait for the next tutorial, won’t you?

More…

• Tutorial Files: fwtutorial00.zip.

The good news is that bots are not hard to make. In fact, by the end of this post you will not only have a bot that does all of the above, but will also hopefully become familiar enough with the interface to extend its functionality to suit your own dream. So let’s get started.

First off, you’re going to need to download FurBot. Originally developed by sanctimonious, it is probably the most popular bot client currently running in Furcadia. As a bonus to anyone experienced with dreamweaving, the command scripting interface is fairly similar to the DragonSpeak editor, which is always nice.

Okay, so go download FurBot and run the installer. I’ll wait here until you get back…

… okay great. Now it’s time to open the client. You should be presented with a window similar to the one above. We don’t currently have a bot open, so it’s a good idea to create one straight away (it’s highly likely that you will crash the client, so remember to save early and save often). The first thing we need to do is check some settings, so go File > Configuration. In the configuration window, make sure the following information is filled in:

Obviously make sure that the Furcadia client program points to your Furcadia.exe application. There’s also a caveat here with the Who Is Online Detection setting; I can never make this work by simply ticking the box (it always unticks itself). Instead, change the number in the Execute map Who every box and hit Save. You can tell if the WhoIs is working (and we will need it) because — once connected to Furcadia — the results will appear in the log message on the main FurBot screen. But we’re getting a bit ahead of ourselves.

Next we need to turn on the parts of our bot that we will be using. Bots can perform several different tasks:

• Actions are triggered when the bot ‘hears’ another furre. Whispers, speech and emits can all be triggers for actions.
• Filters don’t actually make the bot ‘do’ anything. Instead they govern what data is recorded in the logs and presented in the main bot window.
• Timers cause something to happen after a certain period of time has elapsed.
• Triggers are a bit like actions but are (a-har) triggered by non-speech events.
• Finally, who detection commands manipulate data returned by the bot’s `who tick.

We are going to be using actions, triggers and who detection, so make sure these three options are ticked.

Our next step is to actually make a character to use as our bot. Boot up the Furcadia client and make a character in the usual way. I’ve called mine F!W Test Bot. Get it into the game and park it somewhere reasonably private (preferably a private dream). Remember, that while bots are legal on Furcadia they are still governed by the same rules as normal players. It’s highly likely that at least once you’ll end up making your bot do something stupid (such as spam random text), so it’s best to put it somewhere it won’t bother other users (and they won’t bother it). Once you’re happy with your spot, log out of the client.

Back in FurBot, Click the Edit button under Current bot.

From this window, click Load from .INI… and select the .ini file for the bot character you just made. Make sure all the details are correct, and press Save.

Now we save the bot (File > Save bot). Make sure to put it somewhere you’ll easily find it again; I put mine inside My Documents/Furcadia/Bots. Now it’s time to connect the bot to the game, so from the main FurBot window press Connect. If all is well and good, the Furcadia client should open up and your bot should appear on the screen, standing wherever it was when you logged it out. Assuming you’ve set FurBot’s options correctly, after a few moment a message should appear in the client window telling you that you may close the client (that’s Furcadia, not FurBot). Do so. If you look back at the FurBot window, it should still appear connected. The easiest way to tell is to look at the icon in the system tray (next to the clock); if the traffic light is green, the bot is online. Also make sure that your bot is who’ing appropriately; you should see the output of the who appear in FurBot’s log every now and again. If it doesn’t, open back up the configuration window and change the time increment until it starts.

Okay, so we’ve got a bot but it doesn’t actually do anything at the moment. Time to fix that. First off, we’re going to make it auto-summon. Open up the Editing Triggers window and click Add. Fill in the details as shown. To get the Editing Effects pane open, click Add underneath the the ‘then’ textbox. To save the trigger, click Save, then Update, then Save Changes (and yes, it’s convoluted; I ‘drop’ rules all the time due to mis-clicks!).

Once you’ve clicked save (or Apply) in the triggers window, save your bot again. Now it’s time to test your rule. Boot up Furcadia again and open a different character. Request to join your bot; hopefully, you should be instantly whisked away to its location!

Now we’re going to make the log arrivals and departures rule. For this, we’re going to need open up Edit Who Detection. In a similar way that you created the auto-summon trigger, fill in the WhoIs window as above. This time we’re making two separate rules, so you’ll have to go through the process twice. You’ll notice we’ve got some words in square brackets. These represent variables in FurBot. A variable is a word that, when the script is executed, will be replaced with another value. There are quite a number of internal FurBot variables (full details can be found on the website), and you can define your own using WolfScript, but for now the ones we’ll be using are as follows:

• [DATE] will be replaced by the current date in US format (mm-dd-yyyy).
• [TIME] will be replaced by the current time (24-hours, no seconds).
• [PLAYER] will be replaced by the name of the furre that triggers the script (in this case, the furre entering or leaving the dream).
• [APPDIR] will be replaced by the path to the directory where the bot is run from; usually the FurBot install directory. You can replace this with a hard-coded path (i.e. to the folder where you saved your bot).

You’ll also notice that where it says If _______ comes to the map we have an asterisk (*) in place of a name. The asterisk is what’s known as a wildcard character, and in this case it will match anything. You can, of course, put an actual name in this space however that would mean the script was triggered only when that furre entered the dream. Since we want this to log everyone, we use the wildcard.

Save your two new detections and it’s time to test them out once more. To do this, simply leave and then re-enter the dream containing your bot (or, if you’re on a public or otherwise popular map, just let it run for a while). Note that FurBot gets its player information on each tick of the `who command, so it’s theoretically possible to jump in an out of a dream quickly enough to not be ‘detected’ by the bot. If you’re having a problem with ‘missing’ players in this fashion, you can simply set the who tick to a shorter duration. Anyway, when you think you’ve got a few records, open up your visitors.log file from wherever you decided to save it (it’s a plain text file, so opening it with Notepad is okay). If all is well, you should see some lines that look similar to:

"05-10-2007 12:04 IN Loki|Laufeyjarson"
"0"
"05-10-2007 12:06 OUT Loki|Laufeyjarson"
"0"

Don’t worry about the numbers in the quotation marks for now; these are markers for more complex log manipulations by FurBot.

We’re almost done. The final thing we want out bot to do is reply to anyone who whispers it, and to log their message in a file so we can read it later. Open up Editing Actions and create a new action as follows. This action has two parts to its Then clause instead of the one we’ve previously been using. The first one replies to the whisperer (note that to get the ‘large’ editing text box, simply double-click in the small text box normally provided). If you want to insert your own dream URL into the message as opposed to F!Ws (though of course we wouldn’t say no to the publicity), you can use [DREAMURL]. Note that this will take the last dream retrieved from `who, so it will only work if your bot is sitting in your own dream.

The next part of the rule we’re going to add will log the message that was whispered to our bot; this is similar to what we did for logging arrivals and departures, except this time our 0 Record Name line looks like:

[DATE] [TIME] [PLAYER]: [MESSAGE]

[MESSAGE] is another internal variable which returns the message from the triggering player (more technically, it’s everything after the first space character).

Save your new action (and your bot) and test it out by booting up Furcadia and whispering your bot. You should get a response back, and your whispers.log should record the message.

And that’s it! Congratulations, you’ve successfully made a very simple yet hugely useful dream bot.

More…

• Tutorial Files: fwtestbot00.zip.