Media Semantics Character Builder

Version 3.0

Copyright © 2000-2007 Media Semantics, Inc. All rights reserved. Information contained in this document is subject to change without notice, and does not represent a commitment on the part of Media Semantics. The product described in this User’s Guide is provided under the terms of a license agreement. The license agreement specifies the terms and conditions for its lawful use. No part of this document may be reproduced or transmitted in any form, or by any means, without the express written permission of Media Semantics.

Contents
Getting Started ................................................................................................................................. 4 Overview...................................................................................................................................... 4 Requirements ............................................................................................................................... 4 Documentation............................................................................................................................. 4 Installation ................................................................................................................................... 5 A quick tour ................................................................................................................................. 5 Obtaining technical support ......................................................................................................... 6 Slideshow Tutorial........................................................................................................................... 7 Creating the scene........................................................................................................................ 7 Creating an opening slide ............................................................................................................ 9 Adding a presentation ................................................................................................................ 10 Understanding animation actions............................................................................................... 12 Adding a second slide ................................................................................................................ 13 Sequences and Dialogs Tutorial .................................................................................................... 15 Creating a sequence ................................................................................................................... 15 Understanding automatic actions............................................................................................... 16 Navigation with sequences ........................................................................................................ 17 Creating a dialog........................................................................................................................ 18 Quiz Tutorial.................................................................................................................................. 19 Building a multiple-choice slide ................................................................................................ 19 Prompts and reactions................................................................................................................ 19 A second interaction .................................................................................................................. 21 Web Greeter Tutorial ..................................................................................................................... 23 Adding a character to your web page ........................................................................................ 23 Triggering presentations from links........................................................................................... 23 Synchronizing events with your presentations .......................................................................... 24 When to consider dynamic flash generation.............................................................................. 25 Embedded Movie Tutorial ............................................................................................................. 26 Creating the Screen Capture ...................................................................................................... 26 Setting up your Scene ................................................................................................................ 26 Sequence considerations ............................................................................................................ 27 Movie control............................................................................................................................. 28 Flash Integration Tutorial .............................................................................................................. 29 Loading a movie into an empty clip .......................................................................................... 29 Controlling the movie from Flash.............................................................................................. 29 Monitoring the movie ................................................................................................................ 30 Database Generation Tutorial ........................................................................................................ 32 Calling the Server from WSH.................................................................................................... 32 Calling the Server from IIS........................................................................................................ 32 AIML Tutorial ............................................................................................................................... 33 Getting started............................................................................................................................ 33 Editing rules............................................................................................................................... 33 Testing your rules ...................................................................................................................... 34

2

Appendix A – XML Application Model........................................................................................ 35 Include expansion ...................................................................................................................... 35 Entity expansion ........................................................................................................................ 35 Template expansion ................................................................................................................... 36 Identifiers ................................................................................................................................... 38 File references............................................................................................................................ 38 Expressions ................................................................................................................................ 38 Constants.................................................................................................................................... 39 Operators.................................................................................................................................... 39 Functions.................................................................................................................................... 40 Variables .................................................................................................................................... 40 Visual primitives........................................................................................................................ 40 Interaction primitives................................................................................................................. 40 Coordinates and positioning ...................................................................................................... 41 Text frames ................................................................................................................................ 41 The Loader................................................................................................................................. 41 Scenes ........................................................................................................................................ 41 Slideshows ................................................................................................................................. 42 Grids .......................................................................................................................................... 42 Actions and scripts..................................................................................................................... 42 Character actions........................................................................................................................ 43 Layout actions............................................................................................................................ 43 Branching................................................................................................................................... 43 Presentations .............................................................................................................................. 43 Dialogs....................................................................................................................................... 44 Events Scripts ............................................................................................................................ 44 AIML ......................................................................................................................................... 44

3

Getting Started
Overview
The Character Builder lets you create animated characters that present information and interact with users, without requiring you to be a programmer or an animator. You can use the Builder to create Flash SWF files for standalone use, or for insertion into a growing number of applications that support the embedding of Flash movies. The Macromedia Flash SWF format is the de facto industry-standard for web-based animation. Flash files will run on most computers without the need for any additional downloads, due to the ubiquitous nature of Macromedia’s Flash plugin. You can also use the Builder to create video files for delivery to an even broader range of devices. AVI is the native Windows video format, and is readily imported into video editing and compression software, for deployment to DVDs and even cell-phones. At the heart of the Character Builder is an animation engine that can synthesize specially-prepared vector and bitmap art into a complete character presentation. A “character” is a library of images that the software can draw upon to produce high-level actions, such as “look”, “point”, or “say”. The Builder comes with a number of “stock” characters, and other characters can be downloaded from the Media Semantics site. You can specify content in a visual manner using the Builder’s Outline, Design, and Script Views. These Views are merely graphic representations of a rich underlying markup language, which can also be edited directly in an optional XML View. Markup tags are based on existing standards where possible, including HTML and SVG. The underlying XML tag set forms a high-level application model, and programmers can leverage this application model with the optional Character Server product to create solutions involving dynamic content. Many projects consist of the character itself, with few, if any, additional visuals. But the Character Builder is not just about Characters, but about Characters interacting with Content. Characters can control (and be controlled-by) a wide range of supporting objects, including images, movies, buttons, navigation bars, and more. Supporting visuals can be placed in Scenes and Slides. A navigation system allows end-users to navigate within the content. The Builder’s media library includes several stock objects, such as quiz buttons for use in online-learning applications, and entry panels for use in question-answering applications. Though you may begin by using the Builder purely as a means of creating character animation for use within another application, we also hope that you will grow to appreciate the rich standalone applications that can be built using these mechanisms.

Requirements
The Character Builder requires Windows 98/ME, Windows 2000, or Windows XP. The optional Character Server requires Windows 2000 (Pro), Windows XP (Pro), or Windows Server 2003. Some advanced tutorials in this guide provide information on using the Builder with Macromedia Flash and the Character Server. Neither product is required to use the Character Builder.

Documentation
This User’s Guide contains a series of tutorials designed to introduce you to the Character Builder, the Character Server, and the underlying application model. The product also contains the Builder Reference, with information on the Character Builder, the Syntax Reference, with information on the underlying XML syntax, and the Runtime Reference, with information on all runtime API. The Builder Reference is available as help files from the Builder’s Help menu. The remaining help files are located in the Character Builder/Doc directory.

4

Installation
To install the Character Builder, please run the associated installer program. Please visit http://www.mediasemantics.com/kb/kb100.htm periodically to check for updates. To install an updated version of the software, you must first uninstall the existing version, and then run the installer for the new version. The Builder will install by default under “C:\Program Files\Character Builder”. You will find tutorial files in the “Tutorials” sub-folders. Your project files can be located anywhere on your machine, but by default the File > New Project command will create projects in your “My Documents\Character Builder Projects” folder.

A quick tour
The Builder lets you work with content files, image files, and audio files.

The Builder is divided into four different areas, or panes: Editor Pane Project Pane The top-right pane lets you edit files. Several files can be open at a time, and you can switch between open files by clicking on the appropriate file tab. The top-left pane contains a list of the content files used by the project, and is closed by default. You can open it using the View > Show Project Pane command.

Property Pane The middle pane is used to view an object’s properties. Message Pane The bottom pane is used to display error and status messages. You can open it using View > Show Message Pane command.

The Editor Pane lets you view files in a number of different views. You can switch between views using the view buttons at the bottom of the Editor Pane. Outline View Design View Script View Preview View The Outline View lets you view and manipulate the hierarchical structure of your project. The Design View lets you directly place and size objects in scenes and slides. The Script View lets you edit a character’s words and actions, and access the Builder’s voice recording, lip-syncing, audio cleanup, and compression features. The Preview View lets you view your content as it would appear in a web browser.

5

XML View

The XML View lets you edit the markup tags that make up your project. All changes made through the Outline, Design, and Script views will result in changes to the markup, and you can always view and edit this markup directly in XML View. The XML View is turned off by default, but can be turned on through Project > Options (General tab). Query View is useful when building character applications involving AIML Question Answering, and is only available when the Character Server is installed. Query View is turned off by default, but can be turned from Project > Options (General tab).

Query View

You create a new project by invoking File > New Project. The New Project wizard will ask you a series of questions, and then create a new project consisting of a project (.mpr) file, and a content (.xml) file. The content file contains the actual markup for your project. The project file simply contains user-specific editing settings. You can open a project with the Character Builder by double-clicking on the project file from any Windows folder. By default, new projects are created in a “Character Builder Projects” folder beneath your “My Documents” folder. After opening a project, you can browse through the files using the Editor pane and the Property pane. A project consists of a hierarchy of “navigation” objects, such as Scenes, Slides, and Steps. Scenes can contain characters, navigation elements, “props” and other visual elements. Slides can be used to organize a sequence of visuals into a slideshow. Steps let you break a longer presentation into a series of smaller ones. Scenes and slides may contain visual objects, including characters, images, text, and more. Scenes and slides also contain Presentations, which are discrete sequences of actions that a character can perform. Presentations are edited in Script View. You can also use the Preview View to test your content. You can use the Project > Render to Macromedia Flash (SWF) option to create a Flash SWF implementation of your project. The generated files are located in the Output subdirectory of your project file. They will include an HTML file (.html), an SWF file (.swf) and, optionally, a directory (.dir) file as well as secondary SWF files for the scenes, slides, and presentations in your project. You can deploy these files to any web server or distribute them with your standalone application. You can also use the Project > Render to Video option to create a video representation of your project. Projects designed for video output should have the Project’s Output Type selector set to “Video”, and should consist of a single presentation with no navigation or interaction elements.

Obtaining technical support
Registered users of the Character Builder may access technical support by email at support@mediasemantics.com. Before contacting technical support, please be sure to visit our support area, at http://www.mediasemantics.com/support.htm. Here you will also find a link to our support board. When emailing, please be sure to include any sample project (.mpr) and content (.xml) files.

6

Slideshow Tutorial
This tutorial steps you through the creation of a simple slideshow presented by a character. Along the way we’ll introduce various aspects of the Character Builder. We’ll create the project in a series of steps. We encourage you to complete these steps yourself. You can also see the final results by examining the files in the “Tutorials\Slideshow” directory located in the Builder installation directory, normally “C:\Program Files\Character Builder”.

Creating the scene
To begin, select File > New Project and enter a name for your project (e.g. “Slideshow”). For this tutorial, please start with the “Empty Project” selection. The result will be an empty project in the “My Documents\Character Builder Projects\Slideshow” folder.

The “Slideshow” file should be open for editing in the Editor Pane. Multiple files can be open for editing, and you can switch between files using the tabs near the top of the pane. Each file can have one or more different views – you can switch between views by clicking on the tabs at the bottom of the pane. The Property Pane shows the properties for the currently-selected object, in this case the Project object. The Outline View shows three objects in a hierarchy: the Project contains a Stage, which contains a Scene. The Project object almost always contains a single visual element – the Stage. The Stage contains one or more Scenes, only one of which will be visible at any given time. The Stage always occupies the entire output surface. The Stage does not have any appearance of its own, as the current Scene takes up the entire Stage area. Switching between scenes is somewhat like switching between pages in an HTML browser. Let’s now add a visual element to our scene. Click on the Design tab to switch to Design View. Then click on the Add Library Art button ( ). Select “Lecture Hall Props” from the category dropdown, and then “Lecture Hall Background” from the list – a simple two-color background will appear. Repeat and add the object named “Platform” and the object named “Whiteboard”. You will find that some objects will be placed and sized automatically, while others require you to specify a position. If a position is required, then the Add button will remain down and the cursor will change to a crosshair shape. To place the object, just click where the upper-left corner of the object is to appear. Some objects needs both a size and a position: when you click to place such an object, keep the button down and drag out the rectangle corresponding to its size.

7

You can select an object directly, or by clicking on its entry in the Layer panel on the right-hand side of the view.

You can drag the selected object to reposition it, or, if the object is resizable, drag the handles to resize it. The properties of the selected object are shown in the Property Pane. There you can specify coordinates numerically, or alter other properties of an object, such as its name.

Objects are positioned on the scene by specifying the x and y positions of the upper-left corner of that object. The coordinates are always specified in pixels, with the origin being the upper-left corner of the Scene or Slide, and with positive y coordinates going downward. You can use the keyboard arrow keys to “nudge” an object, that is move it one pixel at a time. You can also hold down the Shift key to nudge an object in increments of 10 pixels at a time. Each object is conceptually on its own “layer” (layers work like a stack of transparencies, with one object on each transparency). You can use the Layers panel to hide or lock these layers, making them invisible, or inaccessible for selection, respectively. This can be important when you have a busy scene or slide, where many objects are initially hidden, but are revealed by the character as part of a presentation. The Hidden and Locked state of an object in the palette has no effect on how your slide or scene actually runs, and is not to be confused with the “Starts Hidden” checkbox available on the property panel for each object. You can reorder the layers (i.e. move a “transparency” forward or backward in the stack) using the Move Forward and Move Backward buttons. Another useful feature when dealing with complex slides is the ability to select multiple objects and drag them together as a unit. We still need to add a Slideshow object to act as a container for our slides. Like the Stage, the Slideshow object has no appearance of its own, since its entire area is covered by the current slide. Use the Add Slideshow button ( ) to add a slideshow. The slideshow will appear as a gray rectangle in Design View. The Slideshow and the whiteboard prop are completely independent objects – you can use one or the other, or both. Both the Slideshow and the whiteboard can be resized. To complete our scene, we’ll need a character. Click on Add Character ( ) and then choose “John” from the list of characters. Adjust his position so that he appears to stand on the platform, with the whiteboard to his right. If you now switch to the Preview Pane, your scene should look something like this:

8

Creating an opening slide
Next we’ll create a slide for John to present. Switch to Outline View, select the Slideshow object, and click the Add Slide button ( ).

Note that all objects are given a default name – you can change the name in the property pane. To edit the contents of this slide, return to Design View and, if necessary, select the first slide from the drop-down selector on the toolbar. Note that you can quickly view a given slide in Design View by doubleclicking on it in Outline View. Now add a title by clicking on the Add Text button ( ). You can either click-and-release at the location where the text should start, or you can click and drag out a rectangle that the text will flow into. In the first case you give the text frame no size, and it simply resizes to conform to the text. In the second case you give it a size, so it wraps the text over multiple lines to conform to this width. When you create a Text object you can immediately begin typing. When you are done typing, press Esc or click outside of the text object. You can return to “edit mode” on a text object by double-clicking on it. When a Text object is selected you will see the text formatting controls become active in the toolbar. You can use these controls to modify the selected text object. You can also double-click and edit the object to apply the formatting to specific ranges of text. Note that the Builder uses pixels and not points as a unit of font height. Next, let’s try adding a slide background. To do so, choose the Add Library Art button and select “Sample Backgrounds”, and then “Blue wash background”. With the blue background, you’ll want to change the color of the text to white. To do this, select the text object, and locate the Text Color button in the text formatting toolbar, then pick a white color from the Color dialog. In the Preview view, your whiteboard might look something like this:

9

Adding a presentation
Next we’ll add some voice and animation. Returning to Outline View, select the Slide object and press the Add Presentation button ( ). The Presentation object goes in your slide, but it doesn’t have any visual appearance of its own. Presentation objects won’t appear in Design View.

To edit a presentation, you switch to Script View. In the Script View toolbar you can select from a dropdown list of all the presentations in the file. Begin by pressing the “Insert Say Action” button ( ). The following property pane will appear down below – try typing “Welcome to my first slideshow”.

As you type, the Script View area will update to reflect your changes:

If you have installed the recommended Text-to-Speech voices Microsoft Mike and Microsoft Mary (available from the Download page), then you can use the Speak button ( ) to create an Audio file from this text. Alternatively you can use the Record button ( ) to record your own voice (push to talk). After recording an audio file you’ll need to Lip Sync it ( ). If you use Text-to-Speech then you can skip the LipSync step. In both cases you need to finish by Compressing your audio file ( ). Note that a button will appear with a red hilight when Script View thinks that it still needs to be pressed. When in doubt, press audio buttons that are highlighted, in left-to-right order. If you are using Text-to-Speech then you may need to use some creative spellings and insert extra punctuation to make your transcript come out right. If you are using a recorded voice, then having an

10

accurate transcript will help in synchronizing actions with your voice. You will also be able to print your transcript for handoff to a voice artist. Note that you can either use the audio buttons in the property panel or the buttons in the right margin of the main view – the two sets of buttons are identical. Next we’ll add an animation action. Click just before the “W’ in “Welcome” to place the insertion point at the beginning of the action. Insert a “Hands Up” action, by clicking on the Add Hands Action button and selecting the first icon from the drop-down list (Hands Up).

Your Script View will then look something like this.

You can click on an action icon to select the action. When an action is selected, its properties will appear in the Property Pane. Many actions have a Target property that allows a target for an action to be selected. The Say action is the only action that does not have its own icon, but you can select it by clicking the entire line, in the margin. Now click below this line: notice how the blue insertion mark in the margin indicates where your next insertion will occur. You can click between lines to insert a new line, or below the last line to add a line. Now press the Insert Pause Action button to create a line containing a Pause action. You will often want a Pause action between distinct Say actions. By default a pause will be ¾ of a second. A line will often consist of one or more action icons, and no text. These actions are not synchronized with any audio, and are simply played silently. Press the Insert Say Action button again to create a third line: “My name is John, and I will be your host today.”

You can synchronize an action with the voice by placing the action where you would like the action to begin – in this case it will begin at the same time as the audio. You will find that the resulting script reads much like a theatrical script. Now Record or Speak, Lip-sync, and Compress this line, and switch to the Preview view to see the result of your work. Note that you can place several actions in a row. In many cases two successive actions will actually run concurrently. For example a Look Left and a Gesture Left can be played concurrently since they involve different parts of the body. However a Look Left and a Look Right action cannot be played concurrently. If

11

a second action becomes ready for execution when the first action is still running, and the two cannot play together, then the second action will simply wait for the first to complete. All actions embedded in a Say action will get executed in order – if need be the Say action is extended with silence in order for this to happen. You can try moving the Hands Up action within the Say action. You can do this easily in Script View by clicking on the action and then dragging it to its new.

If you return to Preview view, you will notice that the hands start rising just after the character speaks “my”. You can insert, remove, and reposition actions without needing to re-record, lip-sync, or re-compress your audio. However as soon as you change your transcript, you will want to re-record your audio to keep it in sync with the transcript. How important is it to keep the transcript in sync with the audio? In the case of Text-to-Speech, the transcript is read to create the audio when you press the Speak button. In the case of recorded audio, the Builder uses the transcript to compute the timing of any actions you place within the text. When your project is running smoothly in Preview view, you can use the Render to Macromedia Flash ( ) button, or press F6. Next, click the Explore Output Files ( ) button. A File Explorer window should appear showing the contents of the Output subdirectory of your project.

You are now ready to copy these files to a standard web server. The Slideshow.html file serves as a test container page – you can cut and paste the OBJECT syntax from this HTML file to use in your own HTML page. Please see the comments in the HTML file for more specific directions.

Understanding animation actions
The Builder does not re-render John from 3D primitives, but chooses from a set of pre-rendered images that are carefully designed to let him perform a range of common actions. The process of creating a new character, or extending the range of motion of an existing character, requires a deeper understanding of the mechanism that drives the character’s animation, and access to the required 3d modeling and/or vector art tools. However you can use a “stock” character from the library, or download additional characters from the Media Semantics web site. Some characters can also be modified through properties in the property pane, by re-coloring artwork and specifying parameters or add-ons. Media Semantics defines a Standard Animation Model that characters are expected to conform to where possible. This model includes many of the actions that you would expect a “presenter” to use, including turning, looking, pointing, speaking, hand movements, etc. When a given action is not available, the character simply ignores the action. Actions can affect a character’s body, arms, head, mouth, or eyes. Some actions, such as “Palm Up”, put the body part into a particular state, or “pose”. Other actions, such as “Palm Wave” animate a body part and then return to the same state.

12

Actions are designed to be largely independent of one another. For example you can have your character look at an object, point at it, begin speaking, then look back at the user while still pointing, then raise its eyebrows, etc. You can play many actions concurrently for greater effect. For example you could create a “shrug” action by combining a Hands Out, and an Eyes Wide action. Since the actions involve independent body parts, the system can play both actions concurrently, even though they are specified sequentially in the script. Media Semantics characters tend to have many small, independent actions that can be combined to produce fluid character animation. However independence of motion can come at a high cost to the animator. Consider the body position. The standard animation model says that a character can be a) turned to face the user (front), b) turned to face the content (full profile), or c) halfway in-between (half-profile). For each position, the animator might need to draw a complete new set of images for all arm actions. For this reason, some actions are limited to certain body positions. For example many hand actions are only implemented for the “front” position. The half-profile position is used primarily when the character is drawing the attention to some supporting visuals – he can still point at the content, and may glance back at the user. The full-profile position is used primarily for walking. Walking itself is not implemented on all characters. Most characters will implement the mouth and eye animations for all head positions, and “preserve” these expressions as the head turns. This allows a character to talk as it looks back and forth between the user and any supporting visuals.

Adding a second slide
You can use the Character Builder to create a standalone application that lets the end-user start, stop, and navigate within your content. To do this we’ll add a navigation bar to our scene. First switch to Design View, select the Scene, then choose the Add Library Object button ( ), select “Navigation Bars” from the drop-down, then “Standard Navigation Bar”. You’ll see a navigation bar appear at the bottom of the scene. To create a second slide, you might want to take advantage of the work you’ve already done. You can go to Outline View, the select the first slide, right-click Copy, then select the slideshow, and then right-click Paste. Next go to Design View and change the text of the second slide to, say “My Last Slide”. Next, go to Script View – you can select the first line by clicking in the margin, then shift-clicking before the last line to select all the lines, then hit the Delete key to remove them. Create a new Say action with the words “Goodbye!”. A character will always be running a presentation – when it is stopped, it is actually still running a presentation – an “idle” presentation, which is repeated continuously. An idle presentation will normally be created for you based on the character’s Default Idle property. When the project starts, the character will normally begin presenting the first presentation. You can change this behavior through the Initially Presenting and Initial Focus properties of the Project object. A character normally plays through a presentation until the end, then stops, i.e. goes idle. Presentation objects are “atomic units of presentation”: they can be interrupted, however they can only be restarted from the beginning. For this reason, longer presentations should normally broken into distinct steps using the Sequence and Step objects. A character can transition from one presentation to another, however to ensure that there is no jump in this transition, the system ensures that all presentations start and end with the character in the same “default” position, usually with the character facing the user and its hands at rest. If you test the current Slideshow project, you’ll find that the character presents the first slide, then stops. You can navigate to the second slide, and get John to present it by pushing Next, then Start. You can also have the character control the navigation. To do so, add a Next action as the last line in the first presentation.

13

If a Next action is reached at the end of a presentation, then the character will “move the focus” (i.e. the current slide or step), just like when the end-user presses the Next button. Since the character was presenting when it encountered the Next, it will continue presenting on the next slide. When the focus is moved, the new slide is normally shown immediately – then the character returns to its default position in order to make the transition to the next presentation. A nice effect is to end your slide with the following sequence:

This makes the character pause slightly for the last few words to sink in, then look at the slideshow and “will” the slide transition to occur. In subsequent tutorials you’ll also see how the character can cause all kinds of changes to occur in the slide, and also to react to the user’s actions.

14

Sequences and Dialogs Tutorial
In this tutorial we’ll build a slightly longer presentation that is broken down into a sequence of steps. Each step is associated with a visual change, and the user can navigate through the steps using the navigation bar. We’ll also show how a character can control objects on the screen, as well as discuss automatic character actions. You can see the final result in the “Tutorials/Sequence” subdirectory of the installation directory.

Creating a sequence
We’ll create a series of 3 text bullets that Dave will reveal in a step-by-step manner. We’ll have 4 presentations – one for each text bullet, and one to wrap up. In this case we’ll put the visuals on the scene itself, though you could equally well place them in a slide. Start by creating a new project using the Empty Project template. Switch to Design View, and add use Add Library Art, “Sample Backgrounds”, and “Blue Wash Background”, then use Add Character to add Dave to the scene. You will also want to add the standard navigation bar. Next, use Add Text to create a title and 3 bullets. You can use the Alt-0149 keystroke sequence to insert the bullet character – a complete list of special character can be found in the Accessories, System Tools, Character Map application.

Next, set the Initial Hidden property of the three bullet text objects to True. Note that you can control whether an object is hidden (or locked) from the layer panel to the right of the view, but these settings are completely independent from the Initial Hidden property. The layer panel simply lets you work with complex layouts in Design View by locking down or hiding those objects that you are not currently editing.

Now switch back to Outline View, and, with the Scene object selected, use the Add Sequence button ( ) to add a Sequence object. Select the Sequence object and choose Add Step ( ). Repeat so as to add 4 steps in total. Then select each Step and add a Presentation to it using Add Presentation. The resulting outline should appear as follows:

15

Next, we fill in the presentation for each step. For the first step:

We create a slight head-nod to go with the “Hello”, by moving the head down and then up again. Then, coinciding with “This is my first bullet item”, we make Dave look and gesture to his right, and then Show the (initially hidden) bullet 1. The Show action requires a Target property, which you can set in the property pane below. If you haven’t renamed your text objects, then this would be “Text 2”. When we are done, we move the focus to the next step using the Next Focus action. Here is the second presentation.

Here we have the character turn to half profile – from this position he can point to items, and also glance back at the user – useful when you want to get the user to focus on the content. Note that, in addition to Look Right and Point Right, you can use Look At and Point At, along with a target, to let the character determine the optimal head and arm position based on the position of the character relative to the target. These “targeted” actions are often only implemented from the “half-profile” position, as they appear more natural from this position. And the third presentation:

We end with a follow-up presentation.

Understanding automatic actions
Before we continue, let’s discuss some of the “automatic actions” that are taken by the character. In the previous presentations, we concerned ourselves with getting the character into its different poses, but not so much on returning the character’s head to look at the user, or lower its arms again. You can always return ), and lower the arms with the Hands By Side action the gaze to the user with the Look User action ( ( ). But in many cases this won’t be necessary because of the Automatic Actions feature.

16

To simplify the authoring process, most characters have some “automatic”, or “reflexive” actions. Generally you can expect a character to: 1. 2. 3. 4. 5. Return its hands to a resting (hands-by-side) position if left too long in an extended position, Return to look at the user when talking with the head turned away from the user for too long, Blink Use subtle head movements Use subtle arm or body movements.

Behaviors 1 and 2 mean that you just have to “push” the character in different ways, and the character returns to a default, “natural” state by itself, if you haven’t already instructed it to do so explicitly. Note that you can also specify that the character “hold” a certain position using the Hold action ( ), which “holds” the last specified body part in its current position until another action is explicitly taken on that body part. Behavior 3 through 5 will interleave additional subtle animation, such as blinking, to provide a sense of life to your character. You can selectively turn off different automatic behaviors in the Advanced Properties panel of your Character.

Navigation with sequences
When you render your project to Flash, you’ll find that Dave presents each bullet in turn, as we would expect him to. You can also stop Dave at any time using the Stop button on the navigation bar. When a presentation is stopped, Dave will go idle, but notice what happens when you press Start again. Since Presentation objects are “atomic units of presentation”, Dave restarts at the beginning of the current presentation, which is the beginning of the current step. This is one good reason to break a long presentation into several short ones using steps, as you don’t necessarily want Dave to restart right from the very beginning when interrupted – just at the last logical break. Another reason is to provide navigation within the sequence of steps, to let a user skip ahead or skip back. Navigation within a sequence of steps can be made to appear very natural to the end user, as long as you follow some simple principles. First, each step should ideally be associated with some visual change – in this case a bullet is revealed during each step. In most cases a “wrap-up” step, such as our fourth step is also recommended, in which all visuals are showing. Second, you should think about what assumptions each step should have in terms of the hidden/visible state of the supporting visuals at the beginning of each step. For example at the beginning of step 1 we are assuming that all 3 bullet items are hidden, since during the step we’ll be revealing the first item. At the beginning of step 2 we assume that the first item is visible, but that the remaining two are not. At the beginning of step 3 we assume that the first two items are visible and that the remaining one is not. Finally, in step 4, we assume that all the bullets are visible. Once you’ve determined the visual states at the beginning of each step, you’ll want to add an Event Script for each step ( ). An Event Script is like a presentation except that it is executed immediately (in no time) when a given event takes place. We will use the “On Take Focus” event to execute some hide/show actions immediately when a slide, scene, or step takes the focus, i.e. comes into view. Step 1’s On Take Focus should hide Text2, Text3, and Text4. Step 2’s On Take Focus should show Text2, and hide Text3 and Text4. Step 3’s On Take Focus should show Text2, Text3, and hide Text4. Step 4’s On Take Focus should show Text2, Text3, and Text4.

17

With these scripts, the standard loader can ensure that these assumptions are enforced, in the case where the user skips ahead or skips back through the presentation.

Creating a dialog
Many e-learning simulations work by showing the user an interaction between two characters, such as a salesperson and a potential customer. A third character, such as a coach, might provide analysis, or ask questions. A Presentation object is always associated with a given character. Most projects have only one character so you don’t need to worry about this linkage. If you add two characters to a scene, and then add two presentations, and if you further link each presentation to a different character through the Character property on the Advanced Property tab, then you’ll find that both presentations will actually play at the same time! While you might want to take advantage of this in certain cases, getting the synchronization just right can be frustrating. Instead of adding discrete presentations, you can add a single Dialog object, using the Outline View’s Add Dialog button ( ). The Dialog is edited in Script View just like a presentation, except that another column appears between the audio buttons and the transcript area, listing the name of the character that will execute the corresponding line, just like in a theatrical script.

Note that you can change the character associated with a line by double-clicking on the name – this will cycle through all the characters in the scene.

18

Quiz Tutorial
In this tutorial we’ll introduce the Character Builder’s interaction capabilities by building a simple quiz, hosted by a cartoon character.

Building a multiple-choice slide
Start by creating a new empty project. We called ours “Quiz” – you can see the final result in the “Tutorials/Quiz” subdirectory of the installation directory. Switching to Design View, we added a character (Dave), and a slideshow. There are no other props – the slideshow simply lets us swap-in different supporting visuals beside the character.

Next, switch back to Outline View, select the scene, and use the Add Slide button to create a slide. Doubleclick the slide to bring it up in Design View. Normally we recommend using the Add Slide wizard to select one of the Quiz slides, but for this tutorial we’d like to start from first principles and start with an empty slide. Create the following layout, using the Text object and the Button object. To choose the Button object, use Add Library Button, then select “Misc Quiz Buttons”, and “Radio Button”. Here is the question we created:

You can also use your own art for the buttons – if you do, each button should have the Stays Chosen and Resets Peers advanced properties set, along with images for the normal and “chosen” states.

Prompts and reactions
When you have completed the slide, switch back to Outline View, select the slide, and use the Add Presentation button ( ) to create a new presentation within that slide. Double-click on the presentation to bring it up in Script View.

19

An interaction normally consists of a “prompting” presentation and two or more “reacting” presentations. An example of a prompt would be to ask the user a question. After the prompt is played, the character goes idle waiting for the user to respond. Each time the user presses a button a “reaction” presentation is played. Here is the Prompt script we used.

We chose to create multiple reactions – one for each button. Use the same steps that you used to create your prompting presentation to create three more presentations. This time, be sure to give them names, such as “A”, “B”, and “C”.

Now return to Design View, select each button, and set the Action to “Goto and Start” the appropriate React presentation:

Finally, switch to Script View. For the first, and correct answer, we used the following reaction script.

Remember that the character is supposed to be reacting to a button push, so you want to first make it look at what the user selected, and then react, even though he technically already “knows” what the user has selected. Similarly, we have for B:

And for C:

20

You need to use the “Render to Flash” and “Run In Browser” buttons to experience the proper flow of your interaction. On a correct response, the character acknowledges the response and moves to the next question. On an incorrect response there is no Next action, so the character goes idle again waiting for the user to try again. That covers the first example. In the next example we’ll see a slightly different exercise, and a slightly different approach to reacting to the user’s input.

A second interaction
For our next presentation we’ll use the Checkbox buttons, also from the “Misc Quiz Buttons” category in Add Library Button. In this exercise we’ll be showing a number of tricks. For one thing we’ll add some follow-up information at the bottom of the slide – an image and a text object. You can copy the file “Dodecahedron.png” from the Tutorials\Quiz directory to your own project directory. These follow-up objects should have the “Starts Hidden” box checked. Here is how our slide looks:

Remember that the material at the bottom is marked as “Starts Hidden”. Next, switch to Outline View and add a Prompt presentation:

Now we’ll do something a little different. First, we’ll connect both checkboxes to a Variable. Go to the Outline View, and add a Variable to the project. Rename it from the default ‘Var1’ to ‘Answer2’, the answer to Question 2. Note that variable names, because they are available to outside systems, may not use spaces.

21

While in Outline View, go ahead and create a new presentation ‘React 2’. Then go to Design View, and select the first button. In the Property panel, select the ‘Answer2’ variable and set the value to ‘True’. In this case we are entering a “string”, so we must enclose it in single-quotes. Whenever this button is checked, the ‘Answer2’ variable should get the value ‘True’. Conversely, whenever the button is displayed and the ‘Answer2’ variable has the value ‘True’, the button will be in the checked, or “chosen” state – the button is “linked” to this variable and value. In addition to linking the button to a variable, set its Action to “Goto and Restart” React 2.

Do the same for the other button – it will have the same ‘Answer2’ variable and the same React 2 presentation, but use the value ‘False’ instead. Now on to the ‘React 2’ presentation. Remember that this presentation will run when either button has been selected.

Again we have the character look at the content and then back, as if checking the answer. But this time we use two “If” actions to select an appropriate comment. Selecting the opening icon, you can set the “test” in the property panel as follows:

Similarly you set the test for the second “If” as Answer2 = ‘True’. (You could also have used the Choose/When/Otherwise construct instead of two If blocks.) Finally, the Clear Chosen and Set Chosen actions allow the character to correct the answer for the user in case it was incorrect. The character then reveals the initially-hidden follow-up art. While not really necessary for this simple interaction, the use of Variables and branching allow you to build increasingly rich interactive behaviors. Consider, for example, that all interactive elements (buttons, edit controls, and fields) can be linked to variables. Consider also that variables can be written-to and restored from a web server, both to for server-side progress tracking, and to influence the content or the behavior of the character during subsequent sessions.

22

Web Greeter Tutorial
In this tutorial we’ll examine how to place a character on a web site and make it react to web page events. In this case, there will be no supporting visuals – the only object on the scene will be our character.

Adding a character to your web page
To begin, create a new Character Builder project using the Empty Project selection. We used the name “Greeter”, and the resulting files can be found in the “Tutorials/Greeter” subdirectory of the installation directory. Select the Scene object and set the Size property to 250 by 200. Next, switch to Design View and add a character using the Add Character button ( ) – we chose Mary for this tutorial. You can set Mary to the x,y position of 0,0. For some characters you may find that you need to place your character using negative coordinates in order for it to fit on your stage. The bounding rectangle for the character represents the full area available to the animator to create animations. In most cases the actual space required to render your character animation can be much smaller.

Now go back to Outline View, select the Scene, and then add a presentation object using the Add Presentation button ( ). Switching now to Script View, enter a short script, such as the following one:

Next, use the Render to Macromedia Flash ( ) button, and then take a look at the generated files with the Explore Output Files button. To deploy your character, you simply need to upload the files from the Output subdirectory to your web server. The Builder will create an HTML page that can be used to run the corresponding Flash file. You can also cut and paste the tags from this sample HTML page to your own HTML page – please see the comments within the generated HTML file for details on how to do this.

Triggering presentations from links
In the Slideshow tutorial we saw how the ‘focus” could be moved from one slide to another. In this case there is no slide to provide a visual feedback for the focus, but we can still move the focus from one presentation to another. To illustrate this, we’ll give our first presentation the name “Opening”, and add a second presentation called “Products”.

23

Your Outline should like like this:

Normally the Flash file returns to idle mode when a presentation completes. One way to provide a userinterface to a multiple-presentation project is through a series of button objects placed on the scene. You would set the button action to “Goto and Start”, and select a target presentation. However in this tutorial we’ll show you how to trigger a presentation from the surrounding web page. The state of the Builder-generated movie is controlled by two variables – ‘Focus’ and ‘Presenting’. These variables are set by navigation UI buttons, when present, but they can also be examined and set by an external controller, such as your web page. These two variables effectively form the API for the Flash movie. The initial state of the Presenting variable is set by the Initially Presenting property of the project, and you can use this to determine whether or not the first presentation will begin automatically. The following script can be added to a web page to provide a function that is equivalent to a “Goto and Start” button. Use Project Options, HTML tab, “Include sample external control Javascript”, to have the Builder automatically create similar external control code in the generated HTML file.
<script language="JavaScript"> // <!— var InternetExplorer = navigator.appName.indexOf("Microsoft") != -1; function Play(label) { var Movie1Obj = InternetExplorer ? Movie1 : document.Movie1; Movie1Obj.SetVariable("Focus", label); Movie1Obj.SetVariable("Presenting", "true"); } // --> </script>

Here is an example of the use of this Play() function.
<a href="javascript:Play('Products')">Play Products</a>

The Play() function works by setting the two variables ‘Focus’ and ‘Presenting’. You can stop a presentation at any time, and the character will smoothly interrupt its current presentation and return to its default position and go “idle”. Here is a second function that will stop the current presentation:
function Stop() { var Movie1Obj = InternetExplorer ? Movie1 : document.Movie1; Movie1Obj.SetVariable("Presenting", "false"); }

Presentations can be as short as you like, however they will always end with the character returning to this default position. They can be as long as you like, however bear in mind that they can only be restarted from the beginning.

Synchronizing events with your presentations
You can use the External Command action to raise an event to the containing web page. This allows you to control aspects of your page in a manner that is synchronized with your audio.

24

To do so, you will want to use the following script code within the script block established above. Again, use Project Options, HTML tab, “Include sample external event Javascript”, to have the Builder automatically create similar event handling code in the generated HTML file.
// Handle all the FSCommand messages in a Flash movie function Movie1_DoFSCommand(command, args) { alert("command=" + command + " args=" + args); } // Hook for Internet Explorer if (navigator.appName && navigator.appName.indexOf("Microsoft") != -1 && navigator.userAgent.indexOf("Windows") != -1 && navigator.userAgent.indexOf("Windows 3.1") == -1) { document.write('<SCRIPT LANGUAGE=VBScript\> \n'); document.write('on error resume next \n'); document.write('Sub Movie1_FSCommand(ByVal command, ByVal args)\n'); document.write(' call Movie1_DoFSCommand(command, args)\n'); document.write('end sub\n'); document.write('</SCRIPT\> \n'); }

This script assumes that your object and embed tags have a name and id “Movie1”. To demonstrate the operation of events, we added an External Command action at the end of the second presentation. Note that the Command and Args properties have no meaning to the Builder – they are simply passed through to the Movie1_DoFSCommand() function. The generated script will simply display an alert message, however you can take over with arbitrary javascript code, to hide or show an HTML ‘div’, for example.

When to consider dynamic flash generation
You may also want to have more control over what your character can do or say, on a per-user basis. For example you might want to greet the user by name upon login, or report the weather or a stock price. Since Flash does not work directly with Text to Speech engines, and since high quality engines will likely not be installed on the end-user’s machine anyway, this involves making a call to the optional Character Server product, located on your web server. When you install the Character Server, the Character Builder will gain additional New Project wizard options. The “Dynamic Speech Project” New Project type sets up a project similar to the one presented here, but with a Speak() API callable from HTML javascript. This API works by setting a variable in your project, and then setting the focus to a presentation marked as “external”. This presentation will go out to a server-side scripting page to fetch the actual Flash materials. In doing so, your movie passes the contents of all of its variables, allowing the server-side script to do context-specific processing. The result of this processing is an XML string that is fed to the Character Server for processing, and then the resulting Flash stream is returned to the client. In effect, the Character Server lets you replace any reference to a Flash SWF file with a reference to a server-side script file that generates that SWF file “on the fly”.

25

Embedded Movie Tutorial
We’ve seen how characters can control supporting visuals, such as text and images placed on scenes and slides. You can also include Flash movies, including those produced by a growing number of tools that support Flash SWF as an output format. You can think of the Flash movie as a “prop” that can be hidden or revealed like an image, but also started, stopped, or moved to a certain frame, using the Movie Action ( ). One popular type of Flash movie is a screen capture of an existing application or web site, as it is being used by an operator. An example of such a movie is located in the Library (see the Design View’s Add Library Movie, Sample Screen Capture.) This movie was created using Qarbon ViewletCam, though several other applications may also be used. This tutorial describes how you can turn a screen capture movie into an elegant tutorial in which a character appears to “operate” the original application, or web site. To get started, please use the New Project wizard with the Screen Capture setting. The result will be a sample project based on the Sample Screen Capture movie. We recommend using this template, along with these notes, as a starting point for developing your own set of best practices for this style of project.

Creating the Screen Capture
The following guidelines may be helpful when capturing the original application or web site: • • Your screen recording software should produce a simple linear list of frames – some of the fancier screen capture tools will produce Flash SWF movies that do not permit the standard start/stop or frame-seek actions. Begin with a written series of “steps” to take, in operating the application. A step may be very short, such as moving the mouse over a button and clicking it, or slightly longer, such as filling in a few fields dialog. The key is that each step represents some logical burst of activity that will be associated with some particular commentary from the character. Don’t bother recording any audio when you do your screen recording – just concentrate on performing the actions precisely and deliberately Leave a pause between each step in which you remove your hand from the mouse, so that you can catch your breath, and so that you can easily identify each burst of activity later on. These pauses will not add much to the size of your screen recording, and need not be part of your final production. If your screen-recording software includes a loader or navigation bar, then you should turn these off when producing your Flash movie Place your movie in the Movies subdirectory of your Character Builder project for easy insertion into a scene

• •

• •

The Sample Screen Capture movie contains only two logical bursts of activity.

Setting up your Scene
We recommend using a single scene that contains the movie, a character, and a navigation bar. Make sure the Stage is large enough to contain the movie and the character. The character may appear beside the movie or on top of the movie.

26

When placing your movie on the scene, we recommend leaving the External option checked, so that the movie is kept in a separate file. You should also leave the Auto Start option unchecked, so that the movie does not start playing automatically – we’d rather give the character more precise control over the movie. Finally, we recommend setting the Auto Stop option, found under the Advanced tab, to True. With this setting, pressing the Stop button on the navigation bar will cause all embedded movies to come to an immediate stop. As with any long presentation, we recommend that you use a sequence of steps to break your script into several smaller presentations. Each step represents a logical step in operating the original application or web site, as well as some character commentary. The navigation bar allows the user to stop the character at any time, restart the current step, or skip backward or forward through the steps.

Sequence considerations
The template sets up a simple, two-step sequence that matches the sample screen capture movie.

As described in the Sequence tutorial, you should use an On Take Focus script in each step to set up the initial state for that step. In this case there are no objects to hide or show – instead you will use the Movie action to Goto And Stop to a particular frame.

27

You can use the frame selector button to bring up the Choose Frame dialog:

You can use the Frame spinner control to rapidly locate a frame right before the burst of action that is associated with the current step.

Movie control
In the step’s Presentation you may want to have the character comment before, during, or after the burst of activity associate with the step. When the character is ready for the activity to begin, he will typically look at the portion where the action will occur, then execute a Play action. At this point there are a few options. You can use the Play Until action to have the execution continue until the end of the burst of activity for this step. You can use the frame selector dialog to select a frame shortly after the end of the burst of activity. The Play action executes immediately, so any subsequent actions, including any speech, will now occur at the same time as the movie is playing. While the effect can be pleasing, for simplicity we normally recommend that the character execute only one action while a movie is playing, namely the Watch Until action. While Watch Until appears as a Movie action, its effect is exclusively on the character. Until the given frame is reached, the character will remain in its current pose, normally looking at the movie, blinking occasionally. The most common combination is to 1) Look at the movie, 2) Play Until a certain frame, and 3) Watch Until that same frame. The frame used in the Play Until and Watch Until should be just past the end of the burst of activity.

At this point the character can look back at the user and proceed with a follow-up comment, or move to the next step. If the character is consistently looking at the screen capture movie’s cursor when it is moving, it will feel as if the character is in fact controlling that cursor.

28

Flash Integration Tutorial
In this tutorial we’ll examine how to add a character to a traditional Macromedia Flash application. While many types of character-based applications can be rendered directly from the Character Builder, you can achieve even greater flexibility by using the Builder in conjunction with Macromedia’s own Flash Tool. This tutorial assumes that you have installed, and are familiar with, Macromedia Flash 7 or higher. The files can be found in the “Tutorials/Flash” subdirectory of the installation directory.

Loading a movie into an empty clip
If you import a Builder-generated SWF file into the Macromedia Flash Builder, you will find that only the character artwork and supporting visuals will be imported - all audio and action script statements are ignored. If you want to use the Builder’s output in a Flash project, consider loading the SWF file into a Flash movie clip instead. To provide a sample Character Builder movie to work with, we created a Character Builder project using Dave. We added two short presentations. Presentation 1:

and Presentation 2:

We render this out using the default settings – you can open the Tutorials\Flash\Presentations.mpr project and use Render to Flash to build your Presentations.swf file in the Output subdirectory. Next, open Flash and create a new Flash document. Use Insert > New Symbol and enter “dave_mc” as the name. The select the first and only frame on Layer 1 and enter the following script:
this.loadMovie("Output\Presentations.swf");

Then close the symbol, by clicking on the Scene 1 button, and press Ctrl-L to see your new symbol in the library panel. You can now drag an instance of this symbol to your scene. After placing it on your scene, give it an instance name, such as “dave”. At this point you should save your Flash file in the same directory as your project file. Again, we’ve created the file for you in the Tutorials\Flash directory. If you now run your Flash project, you will see that the clip will automatically load itself with the “Presentations.swf” movie, and since the movie was set up to present the first presentation and then stop, this is exactly what you’ll see.

Controlling the movie from Flash
You can control the clip through the same interface as with HTML (See the Web Greeter tutorial), except that you don’t need the javascript SetVariable() syntax. To see this, try adding two Buttons using the Components panel. With the first button selected, set a label, and enter the following in the Actions window:
on (click) {_parent.dave.Focus = "Presentation 1"; _parent.dave.Presenting = "true";}

29

Be careful to use the string “true” and not the boolean variable true. Similarly for the second button:
on (click) {_parent.dave.Focus = "Presentation 2"; _parent.dave.Presenting = "true";}

Let’s view the result:

You can trigger a second presentation even as the current presentation is playing – the character smoothly interrupts itself, returns to the default position, and then starts in on the new presentation. You can also set the ‘Presenting’ variable to the string “false” to force the character to go “idle”. The Focus variable can be set to either the Name or the Id of the presentation (the Id of the presentation is visible in the Builder’s XML View only). If your project will contain a lot of presentations, and those presentations are likely to be accessed in a random order, then you may want to set the Builder Project’s Output Type to Multiple File. The interface is the same, except that the Presentations.swf file will be a very small “loader” file that will load the various presentations as needed. This will let you have dozens of presentations and only pay the download cost when a given presentation is used.

Monitoring the movie
You can view the state of these two variable by setting up two Text objects (make sure they are of type Dynamic Text) and setting their Var field to ‘dave.Focus’ and ‘dave.Presenting’, respectively. Here is what you’ll see after pressing the Presentation 1 button, in our version.

When Dave is done presenting, you will see the ‘Presenting’ variable turn to “false”. You can use an onClipEvent(enterFrame) handler to monitor the value of Presenting, and trigger other events when the presentation is complete. For example we created another piece of text “Dave is done!” and converted it to a symbol named ‘done_mc’ by right-clicking and selecting “Convert to Symbol”. We then created an instance named ‘done’, and added a line to frame 1 of the movie to make the instance initially-hidden:
done._visible = false;

Then, selecting the ‘dave’ clip, we added an onClipEvent handler in the Action pane:
onClipEvent(enterFrame) { if (this.Presenting == "false") _parent.done._visible = true; else

30

_parent.done._visible = false; }

If you run the Tutorials/Flash/Flash.swf with these modifications, then you’ll see the “Dave is done!” text automatically appear when Dave is idle. If you have any variables in your Character Builder project, then those variables are also accessible to the surrounding Flash application. For example in your project had a variable ‘Var1’, then you could access this variable from Flash as
dave.Var1

There is no simple way to raise events from the Character Builder to the surrounding Flash application. (The Builder’s Command and Get URL actions will go all the way out to the surrounding web page, bypassing the Flash application.) However you can use the Set Variable action to set the value of a variable, and then monitor that variable from Flash, in the same way that we monitored the special variable ‘Presenting’ above.

31

Database Generation Tutorial
If you have used the XML View to see the underlying tags created by the different views, then you will appreciate that you could also create this type of XML automatically, from a database, or from a web-based administration console. The Character Server provides an API for converting such an XML string into a Flash SWF or AVI file.

Calling the Server from WSH
The following javascript file contains a simple test of the Server’s dynamic Flash generation capability. To run it, just double-click on the .js file from a Windows folder. HelloWorld.js
xml = '<project>\n'; xml += ' <stage size="250,200">\n'; xml += ' <text>Hello world!</text>\n'; xml += ' </stage>\n'; xml += '</project>\n'; msserver = WScript.CreateObject("MSServer30.MSServer30"); msserver.Render(xml, "HelloWorld.swf"); WScript.Echo("Created file HelloWorld.swf");

The Character Server is a COM component that can be invoked from most scripting languages. In this case, the calling script creates an XML string, and then passes it along to a new instance of the Server object, along with a name for the resulting Flash SWF file.

Calling the Server from IIS
Most of the Character Server samples are designed for use under Microsoft Internet Information Server (IIS). The following is a basic test of the Character Server running under IIS: GenHelloWorld.asp
<%@ Language=JScript %> <% // Don't cache this Response.Expires = -1; // Create some xml xml = '<project>\n'; xml += ' <stage size="250,200">\n'; xml += ' <text>Hello world!</text>\n'; xml += ' </stage>\n'; xml += '</project>\n'; // Render it msserver = Server.CreateObject("MSServer30.MSServer30"); file = msserver.RenderAsResponse(xml); %>

This second version of HelloWorld is similar to the first one, except that it uses the RenderAsResponse method to render the flash file directly into the response returned to the caller. In this way, you can effectively replace any reference to an .swf file by a reference to an .asp file that generates the SWF stream. You can perform the generation on-the-fly, or you might perform it in response to an Update or Publish button, to allow multiple views of the resulting flash SWF file. It is also possible to create a hybrid system in which responses are generated dynamically, but then saved for reuse in case a similar request appears in the future.

32

AIML Tutorial
You can also use the Character Builder in conjunction with the Character Server to build open-ended question systems, in which users can type in their own questions, and even “chat” with a character, using AIML (Artificial Intelligence Markup Language) rules.

Getting started
To use this tutorial you will need to install at least the evaluation edition of the Character Server. Note that the Character Server is normally used with Microsoft Internet Information Server (IIS), available for development use in Windows XP Pro. The evaluation version of the Character Server is available for free download, but supports only a limited number of AIML rules. You can edit and test AIML rules with the Character Builder, however runtime support for question answering is only available in the Character Server. Rules can be edited in XML View and then tested in Query View. Note that the XML and Query views do not show up as view tabs by default – you can add them to the set of available views for a given project through the Project Options dialog. Editing for a commonly-used subset of the AIML rule syntax is also available through the Builder’s Outline View and Script View. This tutorial shows how you can use the Outline and Script views to create simple rules. For a more in-depth treatment of the supported AIML tags, please see Appendix A. The Character Server product is normally located on your web server, and is used to generate the actual SWF file for each response. The server is passed the text entered by the user. The server-side script then proceeds in two stages – first it loads your AIML files and uses the server’s Respond API to turn the user’s text input into a text response. Second, it packages this response into a complete XML message that is passed to the server’s Render API. This mechanism is very flexible. For example you might leave a special pattern in your text output that your server script can expand, perhaps using a database query, before sending the final text on to the Respond API. Start by creating a new project of type “AIML Project”. A Notes.txt file is generated by the AIML project template containing detailed instructions on how to install the Character Server. Your project file will include references to some AIML files. One of them is “Library\Rules\Substitutions.aiml”, a file containing some commonly used substitutions rules. These rules act on the text input to remove punctuation and expand contractions such as “it’s” to “it is”. The template also generates an initial Rules file with some sample rules. A project may contain dozens of different rule files. You can create a new rule file using the File > New File… command, and then attach it to your project by selecting your Project node in Outline View, and using the Add AIML File toolbar button.

Editing rules
The initial rule file contains 3 rules that demonstrate some commonly used techniques:

You can add a new rule by selecting the Rules node and using the Add Rule button. You edit the details of the rule by selecting it and working with the properties in the Edit pane.

33

The Pattern property indicates a pattern to be matched in the input. As a stylistic convention, all pattern text is often specified in capitals, but the case is completely ignored in achieving a match. The pattern for the first rule is “HELLO”. This will match “Hello” and “hello”. You can also use the wildcard character “*” in a template. For example “HELLO *” would match “Hello”, but also “Hello there”. The last rule (*) shown is effectively a catch-all that consists only of the wildcard operator. A rule’s Template property contains the text that is displayed as a response:

Rules that include a wildcard will only match when more precise rules fail to match. The portion that matched the “*” character is available for insertion in the Recurse and Template properties by repeating the “*” character. The first rule (HELLO) has a blank template, but instead it has a Presentation object attached to it that acts as the template. You can edit this presentation in Script View by double-clicking on it in Outline View.

By using a presentation as the template, you can easily add recorded speech and character actions to your output. The convention is that if a rule contains text in its Template property, then this text is converted to a character response in a default manner, typically by including it as the single Say action of a presentation. This default wrapping behavior is done by the server script, after calling Respond. This allows you to provide precise control over the character for some responses, and a reasonable default for others. The second rule (HI) shows an example of reformulation. The pattern is “HI”, but there is no Template or Presentation. Instead, the Recurse property is filled in with a new pattern “HELLO”, indicating that if “HI” is matched as the input, then the system should treat this as if the string “HELLO” were entered instead. Recursion can be used to reduce a more complex input to a simpler one, or to map several alternative formulations to a simpler, canonical formulation for which you have an answer. Note that several other XML tags are available as part of AIML, particularly in the Template portion. When editing AIML files using the views, you may enter these tags directly in the Template property, or use the Script View equivalents.

Testing your rules
Switching to Query View, you can now type test input and see the resulting output.

Note that you can use the up arrow key to retrieve previously-entered input. If your Character Server is properly configured, as described in the generated Notes file, then you will also be able to use Run in Browser to see these responses delivered by a character.

34

Appendix A – XML Application Model
This appendix presents the XML application model used by the Character Builder and the Character Server. This material is useful for advanced authors who may be creating library extensions, and for developers creating solutions based on the Character Server. The appendix is intended as an overview of the model – specific details are covered in the Syntax Reference help file, which can be found in the Doc subdirectory of the product.

Include expansion
You can include the contents of one file within another using the <include/> element. Consider the following example, in which the file ‘Main.xml’ includes the file ‘Include.xml’. Include.xml
<text> This is included content. </text>

Main.xml
<project> <stage> <include ref=”Include.xml”/> </stage> </project>

When the Builder loads the file ‘Main.xml’, it effectively sees a single file:
<project> <stage> <text> This is included content. </text> </stage> </project>

The included file can have multiple top-level elements, even though XML documents are normally required to have a single root element. The included XML file can in turn include other XML files. As with normal object references, all file references are relative to the path of the XML file containing the reference. File references beginning with “Library” are resolved to the ‘Library’ directory of the Builder’s installation directory.

Entity expansion
In XML, an “entity” is a tag that begins with the ‘&’ character and ends with the ‘;’ character, that expands to a given string. The Builder comes with a number of pre-defined entities: &amp; &lt; &gt; &quot; &apos; Expands to the ampersand character (‘&’) Expands to the less-than character (‘<’) Expands to the greater-than character (‘>’) Expands to the quote character (‘”’) Expands to the apostrophe character (‘’’)

Because the characters ‘&’, ‘”’, ‘<’, and ‘>’ are reserved characters in XML, if you need to use these characters in text, you need to use the corresponding entities instead. The Builder will automatically translate these characters for you when using the Views to edit your project. Custom entities are created using XML’s ENTITY syntax. Consider the following declaration:

35

<!ENTITY ms "Media Semantics, Inc.">

Any instance of ‘&ms;’ will expand to ‘Media Semantics, Inc.’. Entities can be used in both attributes and in body text. Entities can also be used to represent extended and international characters, as in the following example.
<!ENTITY acute "&#180;">

This entity, and entities for many other international characters and symbols are pre-defined with the Builder.

Template expansion
The Builder includes an integrated template system that lets you create new XML tags. The template declaration syntax is similar to that of XSLT, however it is somewhat simplified and more specialized-totask. Templates can be specified anywhere in a document, and will apply from the point where they are defined to the end of the document. Normally they are placed at the beginning of the document, or in a separate file included near the beginning of the document. Consider the following example.
<project> <template tag=”mybullet”> <image ref=”Images\MyBullet.png”/> </template> <stage> <text> <mybullet/> My Point </text> </stage> </project>

This is equivalent to the following XML:
<project> <stage> <text> <image ref=”Images\MyBullet.png”/> My Point </text> </stage> </project>

You can refer to the attributes and elements of the original tag in the expansion. The expression “@x” refers to the attribute named ‘x’, while the expression “x” refers to the child element named ‘x’. You can use these values in the body of a template using the <valueof/> tag. You can also use them in an attribute by enclosing the name in curly braces. For example:
<template tag=”person”> <text id=”{@id}Frame”> <table> <tr> <td>Name</td> <td><valueof tag=”name”/></td> </tr> <tr> <td>Age</td>

36

<td><valueof tag=”age”/></td> </tr> </table> </text> </template>

applied to:
<person id=”JohnDoe”/> <name>John Doe</name> <age>35</age> </person>

is equivalent to:
<text id=”JohnDoeFrame”> table> <tr> <td>Name</td> <td>John Doe</td> <td>Age</td> <td>35</td> </tr> </table> </text>

The entire contents of the original tag can be inserted using the <contents/> tag. You can also add attributes in a more explicit manner using the <attribute/> element. For example:
<template tag=”myframe”> <text> <attribute name=”id”><valueof tag=”@id”/></attribute> <contents/> </text> </template>

is equivalent to:
<template tag=”myframe”> <text id=”{@id}”> <contents/> </text> </template>

This capability can be used in conjunction with the <ifpresent/> and <ifabsent/> elements to provide conditional expansion. For example, to copy an existing attribute “id”, but only if one was specified, you can use:
<template tag=”myframe”> <text> <ifpresent tag=”@id”> <attribute name=”id”><valueof tag=”@id”></attribute> </ifpresent> <contents/> </text> </template>

A similar technique can be used to provide default values for an attribute if the attribute is not specified in the original tag, as in the following example.
<template tag=”myframe”> <text> <ifabsent tag=”@position”><attribute name=”position”>10,10</attribute></ifabsent> </text>

37

</template>

Templates are used extensively for creating library extensions and Character Server solutions.

Identifiers
Most XML elements, such as <stage/>, <presentation/>, and <text/>, map directly to objects in the application model. Some elements, such as <b/> (boldface), are not objects, but simply tags that are understood by a containing object, such as <text/>. Objects have a unique identifier, or id. You can assign an identifier to an object using the ‘id’ attribute:
<stage id=”Stage”/>

Identifiers must start with a letter, and must contain only letters, digits, or the underscore ( _ ) character. You can often refer to an object in another element. For example the ‘position’ attribute in the XML below contains two references to the object named ‘Stage’.
<project> <stage id="Stage" size=”640,480”> <rectangle position=”0,0” size="Width(Stage),Height(Stage)"/> </stage> </project>

Note that objects have identifiers even if they are not named explicitly with ‘id’. Normally XML documents require that each object id in a document be unique. The application model also include a ‘name’ attribute, which can be any string, and is largely ignored by the system excepts as a way to present a more friendly naming interface for content authors. The name attribute can include spaces, and need not be unique. For example the following is valid syntax:
<rectangle id=”rect1” name=”My Rectangle” position=”0,0” size="10,10"/> <rectangle id=”rect2” name=”My Rectangle” position=”10,10” size="10,10"/>

File references
File paths are always specified relative to the directory of the XML file containing the reference. For example, an image “MyImage.jpg” located in the subdirectory “Images” of your XML file directory would be referred to as “Images/MyImage.jpg”. Note that the UNIX-style forward slash (‘/’) and the DOS-style backward slash (‘\’) are both supported as a separator character. All file references beginning with the string “Library”, such as “Library\StdProps.xml”, will get resolved to the Builder’s library directory as if the library directory were a subdirectory of your project directory, even though the library directory is located in the product’s installation directory. When you deploy your project with a runtime such as the Server, you will also need to deploy the library files used by your project. If you’ve installed the Builder on the server, then library remapping will work as it does on your development machine. If not, then you can create a ‘Library’ directory under your project directory, so that the library references are resolved correctly without any redirection. You can also specify a location for the library using the Server’s SetLibrary() method.

Expressions
Many attributes will accept an expression consisting of constants, operators, and functions. Expressions may be used for the ‘position’ and ‘size’ attributes of a visual object, as well as the target attribute for animation actions such as Point. However when rendering to Flash, these expressions are evaluated at the time of the render, and not at runtime.

38

<text width=”Width(VisualContainer(this))/2”> Text </text>

In this example, the operator ‘this’ refers to the object containing the expression, in this case the text frame itself. Expressions are especially useful in conjunction with template processing.

Constants
The following types of constants can be used in expressions: Type Boolean Integer String Object Reference Example true, false 3 ‘a string’ Span1

Note that string constants always take single-quotes. This can be confusing in XML View, since expressions are already contained in attribute values. For example the <externalcommand/> action takes a string expression, so the proper syntax is:
<externalcommand args=”’test’”/>

Operators
The expression syntax is similar to that of JavaScript, but includes some of the '$' operator aliases found in XSLT, as these avoid the XML control characters and are easier to use within XML documents. The operators are as follows. Operator Parentheses Conditional Logical Or Logical And Logical Not Equality Inequality Less Than Less Than Or Equal Greater Than Greater Than Or Equal Addition Subtraction Multiplication Division Unary Minus This Operator Syntax () test ? a : b ||, $or$ &&, $and$ !, $not$ =, $eq$ !=, $ne$ <, $lt$ <=, $le$ >, $ge$ >=, $ge$ + * / this Arguments Expression Test is Boolean, a, b are any type Boolean Boolean Boolean Integer, string, or boolean Integer, string, or boolean Integer, string, or boolean Integer, string, or boolean Integer, string, or boolean Integer, string, or boolean Integer, Real Integer, Real Integer, Real Integer, Real Integer, Real

The following table shows the operators in highest-to-lowest precedence order. Operators in the same row are evaluated in left-to-right order. An operator with higher precedence is evaluated before one with lower precedence. Logical operators use shortcut-boolean evaluation. Parentheses Conditional Unary minus, Logical Not Multiplication, division Addition, subtraction

39

Equality operators Logical And Logical Or

Functions
A complete list of functions is available in the Syntax Reference. Some of the functions commonly used in Library objects include: Width(object) Height(object) Top(object) Left(object) Right(object) Bottom(object) Other functions are used to identify different objects in the hierarchy: ContainingScene(object)

Variables
Variables are placeholders for values. For example you might define a variable “Happy” with an initial state of “false”, as follows:
<variable id=”var1” name=”Happy” value=”false”/>

Variables can be used directly in expressions, as in:
<if test=”Happy”><smile/></if>

Variables can be altered using the <set/> action:
<set target=”Happy” value=”true”/>

Variables are not typed – you can assign any type of value to a variable at any time. Variables must be declared as children of the Project node. Variables are considered “global”, that is they can be accessed from any point in the XML file.

Visual primitives
The Builder supports a number of visual primitives for use in scenes and slides. Images Text Frames Rectangles, Lines Images can be SVG, JPEG or PNG images. Text frames allow you to flow text in a specified region, and support simple HTML layout. These are commonly-used primitive shapes.

Interaction primitives
The Builder currently supports the following interaction elements. Buttons Buttons can be used alone or in groups, and can take on virtually any appearance. Buttons can be used to initiate a number of predefined actions. You

40

can also link a group of buttons to a variable, such that each button assigns a different value to the variable. Edit fields Edit fields let the user enter text. Edit fields are always linked to a variable: a change to the edit field is reflected in the variable, and a change to the variable is reflected in the edit field.

Coordinates and positioning
All objects in the visual containment hierarchy have a bounding rectangle, which is the smallest rectangle that contains the entire object. The object itself can be of any shape. Objects such as scenes, slides, and grids let you place contained objects at any point using the ‘position’ attribute. Coordinates are specified in pixels, with the origin being at the top-left corner of the containing object, and positive y coordinates running downward. The following places a rectangle at coordinate 100,100 on the stage.
<project> <stage size=”640,480”> <rectangle position=”100,100” size=”100,100” rgb=”255,0,0”/> </stage> </project>

Objects are drawn on the screen in the order that they are encountered in the file, so that objects specified later in the file will appear in front of objects specified earlier in the file.

Text frames
Text elements typically contain text and formatting tags, but they can also contain visual objects, such as <image/>. Visual objects are laid out in a text frame as if they were characters.
<project> <stage> <rectangle position=”100,100” size=”100,100” rgb=”255,0,0”/> <text position=”100,100” size=”100,100”/> This is <b>a test</b>. </text> </stage> </project>

The <text/> element supports a subset of HTML, including simple tables. For a complete set of layout tags, please see the Syntax Reference. The contents of text frames are laid out as part of the Render to Flash process.

The Loader
The Character Builder will generate one SWF file for each scene, slide, and presentation in the project, as well as a directory (.dir) file that describes how the various SWF files are related. It also copies a small Flash MX-based “loader” file from the library, for use as the root SWF file. Advanced users can also use Flash MX to create their own custom loaders, using the provided source FLA file, however this is not recommended for most users. You will see these files in the Preview subdirectory and also the Output subdirectory when you leave the Project’s Single-File property set to False. With this property set to True the .dir file and all the Flash files are combined into a single swf file in the Output directory.

Scenes
The stage object can contain multiple scenes:
<project> <stage> <scene id=”Scene1”>

41

… </scene> <scene id=”Scene2”> … </scene> </stage> </project>

Objects are absolutely positioned on a scene using the ‘position’ attribute. A stage always has at least one scene. If no <scene/> element is declared, then there still is a single, implied scene. The stage must be the top-level visual object of the project, and always occupies the entire display surface. Only one scene will be displayed at a time, and this scene takes up the entire stage. Switching between scenes on a stage is much like switching between pages in a web browser. You can navigate between scenes using the <movefocus/> action.

Slideshows
The slideshow and slide objects behave just like the stage and scene objects, except that you can place a slideshow in a scene, leaving room for a navigation interface and a character.
<project> <stage> <slideshow> <slide> ... </slide> <slide> ... </slide> </slideshow> <character .../> </stage> </project>

You can navigate between scenes using the <movefocus/> action.

Grids
Several objects can be wrapped with a Grid object to create a composite object. Grids are not exposed directly in the Builder, but are often used in creating library extensions.
<grid size=”200,100”> <rectangle position=”0,0” size=”200,100” rgb=”255,0,0”/> <text position=”5,5”>Alert!</text> </grid>

All position attributes for objects within a grid are relative to the grid object. The size of a grid can be specified explicitly, or it can simply assume a size based on its contents. Grids and the grid contents can be placed using expressions. These expressions are evaluated at render time, however no check is made for circular references. When a grid is laid out, first the size and position of each contained element is determined, in the order in which the child elements are encountered, and then the size of the grid is determined, if this size was not already specified.

Actions and scripts
Elements such as <slide/> and <text/> act like nouns, while other elements, such as <look/> and <show/> act more like verbs. Their attributes are often references to object instances, as in:
<show target=”img1”/>

Groups of actions, or “scripts”, can be placed in presentations and buttons. While the Builder’s Script View supports a common set of actions, there are several other actions that are available in XML View. The term “script” is used in the theatrical sense – there are some important difference between Media Semantics

42

scripts and programming languages. For example in most systems, a script is meant to execute as quickly as possible and then return control to the system. A Media Semantics script contains commands such as <say/> that must be executed asynchronously.

Character actions
Actions such as <say>, <lookleft/>, etc. are used to control a character’s behavior at a high level. The say action is special in that it allows other actions to be embedded within it. Embedded actions become eligible for execution as they are encountered in the text of the say element. If an action becomes eligible, but the character is already executing another action, then it is queued up for execution when the current action is complete. The say action will be complete when its associated audio is finished and when all embedded actions have completed.

Layout actions
In addition to ‘size’ and ‘position’, visual objects have the properties ‘hidden’, and ‘opacity’. An object with the attribute hidden=”true” will initially be hidden, and can be made to appear with the <show/> action. A visible object can be hidden with the <hide/> action. Visual objects can also specify an opacity value from 0 (full transparent) to 100 (fully opaque), using the ‘opacity’ attribute. The opacity can be controlled with the <fadein/> and <fadeout/> actions.

Branching
Control flow within a script can be affected using branching elements. The syntax for branching is similar to that of XSL:
<if test=”2+2=4”> <say>I seem to be functioning normally.</say> </if> <choose> <when test=”2+2=4”> <say>I seem to be functioning normally.</say> </when> <otherwise> <say>I don’t feel so well, Dave.</say> </otherwise> </choose>

Presentations
Presentation elements let you connect visual content with voice and action. While the voice is often associated with a character, you can also use presentations to create a background narrative that accompanies visual content. Presentations are atomic units of presentation. You can interrupt a presentation, but you can only restart it from the beginning. In some cases you will have a long presentation that builds up a complex piece of visual content in the same scene or slide. In this case you may want to let the user navigate within the presentation by breaking the presentation down into smaller presentations, each within its own step. Presentations are specific to a character. You can have two characters, each with its own presentation, and the two presentations can execute asynchronously. You can start a presentation using the <startpresenting/> action. Once started, a presentation runs through until the end, and then stops. You can also end a presentation with the <nextfocus/> action, to chain multiple presentations together in a single, uninterrupted monolog.

43

Presentations always assume that the character is in its initial, or default state, when they begin. Presentations also end by returning the character to this same default state. A presentation can be stopped prematurely using the <stoppresenting/> action. If a presentation is ended prematurely, then it will cause the character to first complete its action, and then return smoothly to the default state. Presentations can be marked as being “idle” presentations. The Loader keeps track of whether a character is “presenting” or “idle”. When a non-idle presentation completes, the Loader normally chooses an idle presentation. This presentation is played repeatedly until the character enters presentation mode again.

Dialogs
Dialogs are a special kind of presentation involving multiple characters. Only one character at a time is active in a dialog. Dialogs use the <setactivecharacter/> action to indicate which character is active. All non-active characters are in a special mode in which they may perform certain automatic actions, but otherwise perform no action.

Events Scripts
The <script/> element contains actions to perform in response to a given event. The only event currently defined is the “ontakefocus” event, which is triggered when a scene or a slide comes into view (takes the focus).

AIML
AIML files can end in the extension “.xml” or “.aiml”. A typical project will contain several AIML files. You attach an AIML file to a project by adding an AIML Reference (<aimlref/>) to the project element:
<project> <aimlref name=”General.aiml”/> <aimlref name=”Products.aiml”/> </project>

AIML rules are only executed by the Character Server. However a query containing AIML References can also be tested in the Character Builder, using the Query View. A <stage/> object, if present, will be ignored by the Character Server for the purposes of responding to user input with the Respond API. Likewise, the AIML file references are ignored for the purposes of generating Flash SWF files. The “AIML” template in the File > New Project dialog, creates a typical project that combines a Flash frontend with a Character Server back-end. An AIML file normally consists of the <aiml/> element, which contains any number of rules, or “categories”.
<aiml> <category id=”Rule1”> <pattern>HELLO</pattern> <template>Greetings, human.</template> </category> </aiml>

The pattern portion of the rule is matched against the user’s input. If a match is found, then the template portion is emitted as the response. The pattern portion is case-insensitive, and can include the “wildcard” characters. As a matter of style, pattern expressions are often expressed in uppercase. The template (output) portion can include control tags, including tags that allow the system to reprocess the template portion as if it were entered by the user. This recursive ability allows for the creation of rules that simplify a complex input through one or more intermediate stages.

44

All tags that don’t have specific meaning to the AIML parser are simply passed through in the response. By convention, Media Semantics projects use the <presentation/> tag directly within the <template/> tag to indicate that the response consists of a series of character actions:
<aiml> <category id=”Rule1”> <pattern>HELLO</pattern> <template> <presentation> <say>Greetings, human.</say> </presentation> </template> </category> </aiml>

The Character Builder’s Outline and Script Views can be used to create rules in this format. The convention used in Media Semantics’ AIML engine is that responses that are not already wrapped in a <presentation/> tag will need to be wrapped with a default presentation, such as the one used above, before being sent to the Character Server’s Render API. This convention allows you to combine new rules that are specifically character-aware, with existing rules that might provide background knowledge or general chat capability. The Character Builder tends to add ‘id’ attributes to rules – while not required by the AIML standard, the ‘id’ attribute is required when editing AIML files using the Outline and Script views. Rules can be spread over many AIML files. Different files might provide answers to different types of questions – you might think of them as lobes of a brain. The <aimlref/> tag can also be used to link a project to one or more control files. The substitution file (for example Library/Rules/Substitutions.aiml) provides substitutions on the input string, such as transforming “he’s” to “he is”, and removing most punctuation.
<substitutions> <input> ... <substitute find="," replace=" "/> <substitute find=" he's " replace=" he is "/> </input> <substitutions>

The template portion of a rule can contain 0, 1, or 2 instances of the wildcard character ‘*’, which will match any input. The contents of the matched input can be referred to in the template portion using the <star/> tag.
<category> <pattern>CAN YOU *</ pattern> <template>I don’t if I can <star/> - can you?</ template> </category>

(Note that the ‘_’ character is an alternative to the ‘*’ character, but has a subtly different meaning – ‘_’ is searched before any other character, while ‘*’ is searched after any other character.) You should include a “catch-all” rule that will match when nothing else matches.
<category> <pattern>*</pattern> <template> <random> <li>I’m sorry, I don’t understand.</li> <li>Could you reformulate please?</li> </random> </template>

45

</category>

This example also shows the use of the <random/> element, which can be used to vary the resulting response in a pseudo-random manner. In addition to using <pattern/> to match the user’s last sentence, a rule can use <that/> to match the character’s last sentence.
<category> <pattern>*</pattern> <that>WHAT IS YOUR NAME</that> <template>Well hello <star/>.</template> </category>

A series of rules can also be wrapped with a <topic/> tag.
<topic id="Topic1" name="WOMBAT"> <category id="Rule1"> <pattern>DO THEY BITE</pattern> <template>Wombat’s are nocturnal and rarely bite people.</template> </category> </topic>

As a conversation unfolds, several ‘variables’ can be gathered to help guide the subsequent rules. In a stateless system, as often found in web-server systems, the state of all variables can be queried after a call to Respond, stored in a conversation log, and then restored before a later invocation of Respond. We have already seen one such variable, namely ‘that’, the text of the previous Respond output. The current topic is another such variable, but one that you, as the rule writer, have control over. The order in which rules are expressed, and the manner in which they are organized into files, is not particularly relevant to the search process. What is relevant is whether or not an input pattern is ‘atomic’, i.e. contains no wild cards, or ‘default’, i.e. contains wildcards. Rules are matched from more specific to more general: 1. ATOMIC with a TOPIC and a THAT 2. ATOMIC with a TOPIC 3. DEFAULT with a TOPIC and a THAT 4. DEFAULT with a TOPIC 5. ATOMIC with a THAT 6. ATOMIC 7. DEFAULT with a THAT 8. DEFAULT In the Wombat example, you’ll want at least one atomic rule outside the topic that will focus the conversation to this topic:
<category> <pattern>WHAT IS A WOMBAT</pattern> <template> Glad you asked! A wombat is a cave-dwelling creature that lives in South America. <think><set name="topic">WOMBAT</set></think> </template> </category>

You set the current topic using the <set/> tag, which sets the contents of a variable to the text contained in that tag. The contents of this tag are normally inserted in the output stream as well. You can suppress any value from being inserted in the output stream by wrapping it in the <think/> tag.

46

You can use <set/> to gather your own variables. For example we might want to remember the user’s name once we’ve asked it:
<category> <pattern>*</pattern> <that>WHAT IS YOUR NAME</that> <template>Well hello <get name=”username”><star/></get>.</template> </category>

You can subsequently reinsert this variable in a template with <get name=”username”/>. The <srai/> element (for symbol reduction), causes its contents to be re-interpreted as if they were regular user input. You can use this to map several input patterns to the same output template.
<category> <pattern>HOW MUCH DOES IT COST</pattern> <template>The WonderWidget is $25.</template> </category> <category> <pattern>HOW MUCH IS IT</pattern> <template><srai>HOW MUCH DOES IT COST</srai></template> </category>

Or you can use it to reduce a more complex sentence to a simpler one.
<category> <pattern>I WANT TO KNOW *</pattern> <template><srai/><star/></srai></template> </category>

The <sr/> element is short for <srai/><star/></srai>, and could also be used here. A good collection of resources for AIML can be found at www.alicebot.org.

47

Sign up to vote on this title
UsefulNot useful