Musical Chairs Tutorial for Massive v Amit Lakhani MSc Computer Animation

Transcription

1 Musical Chairs Tutorial for Massive v2.6.3 Amit Lakhani MSc Computer Animation NCCA Bournemouth University 2007

2 Table of Contents About this tutorial Organisation Design The rules of musical chair Motion tree Motion Capture Skeleton Design Import skeleton Adjust Skeleton/Body Import Motion Import Action Trim and Loop Actions Make Agent Curves Make IK, Rotation Constraint and Foot Hold curves Finish Motion tree Triggers Outputs Test with Sequencer Make Chair Build Brain Ground Turning Walk rate Music switch Music ON mode Walk when music is ON Walk around chairs Slow when other agent is ahead Music OFF mode Avoid each other Walk around the chairs Walk to sit Make guide Walk towards guides Turn ON and OFF chair/guide Set player sound emitter Loser leaves game Placement Bake the flow field Run Simulation Make brainless Divide agent Tweaks and Additions Render opengl images

3 About this tutorial This tutorial demonstrates how to make an agent that can play Music Chairs in Massive. The techniques and processes are explained in order for anyone to use in their own way. You must make your own skeleton and obtain your own motion capture data. The agents and scene has been provided for you to play around with and you are welcome to copy modules into your own agent. When making the brain the values I used are given but must be you may have to adjust and tweak the values to fit your mocap and skeleton Pre requisite: Basic knowledge of Massive and the concept of fuzzy logic, ideally the Massive documentation and learning material should have been read and understood. Objective: To use the tools Massive has to offer by completing a small project creating a new agent, importing motion, applying IK, building a brain and rendering out simulations to opengl images. The end agent will be able to play music chairs when placed in a correctly set up scene. Accompanying files:../tutorial/musical_chairs.mas../tutorial/cdl/player.cdl../tutorial/cdl/chair.cdl../tutorial/cdl/divide.cdl../tutorial/obj/terrain.obj../tutorial/maps/terrain_map.tif../tutorial/act/actions.actb../tutorial/tree/motion.tree../videos/walk.m2v../videos/sit.m2v../videos/walktosit.m2v../videos/sittowalk.m2v../videos/demo.m2v Tools needed: Massive, Maya or similar software, access to Mocap Studio or data Organisation Before beginning we must keep this project organised from the start. Let's begin by creating a file structure for the project. Massive has a good recommended file structure for project as explained in the documentation, so we might as well stick to it. We will add the tree folder as we will have to save a motion tree later in the project. Make folders as follows: 1

4 Design A key part to any project is to plan it well from the start and by no surprise it is a very important part of creating an agent. Firstly we must understand what exactly we want our agent to do and what actions are needed for him to do it. We aim to make an agent play musical chairs with other agents, so why not start by defining what happens in the real game. The rules of musical chair There must be at least 2 players and another person to switch on/off the music. The number of persons to play are counted. Two straight rows of chairs are arranged back to back. The number of chairs should equal one less than the number of players. One person, apart from the ones playing the game must play some music, then at some random time abruptly stop the music. When the music is playing the players must walk around the chairs one behind the other. The moment the music stops, all players must try to sit on the nearest chair. As there is one chair less than the amount of people one player will have no chair, therefore the player left standing is out of the game. The music begins again with one more chair removed and then the whole process it repeated. The person left sitting at the end of the game is the winner! Motion tree First we must list the actions needed and decide whether they are looping or non looping actions. This is easily done by reading through the description of the real scenario picking out any actions. The two actions that become apparently from the text is: WALK and SIT (highlighted in yellow). We must also 2

5 consider the transition between the poses. So the actions needed are: Walk Looping Walk to Sit Non Looping Sit Looping Sit to Walk Looping Now for the motion tree. Open Massive and go to the motion page (use selector on top right of window) Drag two transitions boxes on to the motion page from the left tool bar and give them the title of the two non transition actions, sit and walk. Next, drag four oval nodes from the tool bar then place and name them as below. These are the action nodes, Now we have the network nodes in place we must connect the nodes. If an agent is walking and no other action is being triggered then we want the walk cycle to repeat. Therefore the walk action must connect to walk transition in a cycle fashion. This is the same for sit as it is also a looping action. However, if the agent is already in the walk stage and is told to sit then we want the motion tree to tell the agent to do the walktosit motion and end in the sit stage. Therefore we must connect walk to walktosit and walktosit to sit. For the same reasons sit must connect to sittowalk and then to walk. To connect nodes hold ctrl and click on the source and then ctrl and click on the destination. 3

6 The tree is fairly simple to read, but in the case of a large tree it can get complicated, therefore it is worth changing the colours of the nodes by clicking on it and selecting a colour from the palette at the bottom of the window. The tree is not complete yet, but for now we will save it and come back to it later once the motions are imported. Save by going to file > save tree and save it in the tree folder with.tree extension. Motion Capture Now that the actions have been decided they must be caught using motion capture or animated in maya. For this project we have simply retrieved some actions from our motion capture archives. The actions are not perfect for making a amazingly realistic game of musical chairs but they are good enough to get agents playing a simple game. The data has been cleaned up in Motion Builder and exported as Acclaim.amc files. The data can be viewed in the../video/mocap folder. Obtain, clean up and export motion capture data for each action Skeleton Design As the mocap is from archives the skeleton used is the one used for the motion capture. When the mocap is exported in Acclaim format it is accompanied by an.asf file. This holds the information about the skeleton and can be imported to Massive. Import skeleton To import using an Acclaim skeleton we simply use the command line to open Massive and create a new agent with the skeleton imported to the body page in the form of segments. Open a terminal and type Massive skeleton.asf 4

7 Go to the body page (pg up and pg dn toggles between pages) and you will see the skeleton as segments joined together to form a skeleton hierarchy. In the view port you will see the skeleton. You will notice that it is not quite right so we must fix this. For example the lower leg and foot do not match up. Before we start to fix this problem let's rearrange the segments in the body page to allow for easier navigation amongst the network. Do this by dragging the segments around the page. Adjust Skeleton/Body When editing the body of an agent it is a good idea to delete all instances first (ctrl d), as some options will not be available. 5

8 Looking at the skeleton that I have imported from.asf you can see that some segments do not match the bones. For example if we look at the lower leg we can see that it is rotated about x too much. We can fix this by using the body page and adjusting the values in the shape and rest tabs. The shape tab will change the size, shape, position and rotation of the segment. The rest tab will change the rotation, position and orientation of the bone. As in the above picture it is handy to open the bones window, select skeleton mode by click on the icon in the bottom left corner and then open a view port and turn of shading (alt s). Move the camera so that both agents are in the same pose and then adjust the segments. This makes it easier to check if the segments and bones match. In the case of the lower leg, by simply increasing the rx value until it is in line with the bone. Do the same for any other strange looking segments. At the moment the skeleton is made up of segment in the same shape of the bones but thicker. We can change the shapes of the segments to make the body parts proportional to that of a human. 6

9 I will demonstrate how to do this on a couple of segments and then you can finish it of for your skeleton. Lets begin with editing the root. At the moment is a small square box We can change the segments into different shapes by clicking on the selected segments icon. Click until the segment is the shape you desire, the choices are: sphere, tube, disc and box. We will use a tube for the root, and then increase its radius and length in the shape tab. When increasing its length it does so along the Y axis. We would rather it increased along X, so we can change this using the axis buttons below radius in shape. The root looks as in the picture below. Do this for each segment until the agent is of the desired proportions. This is important as agents vision will be determined by the visible segments. This will also aid the skinning stage, which is not covered in this tutorial. When all segments have been adjusted it should look something like the picture below. 7

10 Import Motion Import Action The next stage is to import the actions. Earlier we saved the mocap data as Acclaim.amc files, this allows for easy importing. Go to File > load actions Highlight all the actions you will to load and hit accept All the actions are now loaded and can be viewed in the Action Editor. Click on Edit > action from the top menu bar Select the Actions tab and rename them to appropriate names by selecting the action and changing the name in the top left text field Hit Close 8

11 Now we will save the actions as a binary action file. Click on File > save actions and save in act folder as a.actb file with the Binary button toggled on Saving the agent now will add a link to the actions data. Click on File > save agent and save in cdl folder as a.cdl file Trim and Loop Actions The actions must be trimmed, looped (or not) and agent curves must be made. This can all be done using the Action Editor. We will do this together for one action and then the same process can be repeated for the other actions. Click on File > action to open the Action Editor Select the walk action in the actions tab First we will trim the action. Delete all agent instances (ctrl d when main window or view port active) so that the agent is at the start position Press the solo button on the Action Editor, this makes the agent do the selected action 9

12 without any brain processing Start the simulation (spacebar) My motion capture data starts with the agent in a T pose, so when played he moves into the walk cycle then jumps back to the start position when complete. We can make the camera follow the agent (alt f) and turn on camera filtering (shift alt r) to make it easier to see the action in the view port without losing our agent. First we want to get rid of the T Pose at the beginning of the action. We will display some curves on the loop graph to help us visualise the movements. Click on the curves tab and select rx, ry and rz using shift click Click on the loop tab and using the rmb to scroll through the action graph, stop when you reach the point where the T Pose ends Click on the loop start button to hold this value Now move the time line to the point where the walk cycle has made one complete cycle Click on loop stop and press play to see if the loop is seamless When viewing the action it can be a bit too fast to see properly, we can change the rate and slow it down to make it easier to detect error Click on the rate field in the top right of the Action Editor and change it to about 0.3 If the cycle will not loop seamlessly we can use the crossfader to smooth the transition. We must first select the curves that we want to crossfade. You can either manually select them by enabling rx, ry, rz, tx, ty or tz. Alternatively you can use one of the recommended set ups: static, locomotive, turning or other. Enable the locomotive curves Change the crossfade value until the action looks smooth Click the accept button when happy 10

13 Make Agent Curves Now when viewing the action in the view port it seems that the action is complete, however the agent is not translating in world space. If we turn of camera follow (alt f) notice that the agent does not walk of the screen. For the agent to translate in world space we need to create agent curves. Click on the agent tab in the Action Editor Select the correct type of motion, in this case locomotive and then hit accept If you reset the agent back to the origin (alt r) you will see it now walks through world space. If you click on the curves tab you will see new curves, transition and latch. Make IK, Rotation Constraint and Foot Hold curves We will be using IK to give a more convincing movement of the feet when turning, more specifically we will apply foot holds so that when the agents foot is on the ground it is not allowed to slip excessively and then leg will keep a realistic pose. To create the curves we need go to each action in the action editor, highlight the appropriate bones and then generate the curve by using the buttons in the IK tab. Alternatively we can take advantage of some of the functions accessible though python scripts to do the initial part for us. The following script will create rotation constraint curves for the left and right ankle and IK curves and hold curve for the left and right feet. 11

14 agent = get_agents() a = agent.actions l_rc = agent.find_segment("leftankle") l_ik = agent.find_segment("lefttoe") r_rc = agent.find_segment("rightankle") r_ik = agent.find_segment("righttoe") while a: reset_all() print a.name a.create_rc_curves(l_rc) a.create_rc_curves(r_rc) a.create_ik_curves(l_ik) a.create_ik_curves(r_ik) a.create_hold_curve(l_ik) a.create_hold_curve(r_ik) a = a.next Click Options > Text Port to open a text port and type the following python code, it will print the action names as it iterates through the while loops and creates the curves Open the action editor, select an action and click on the curves tab, notice that there are new curves listed for the ankles and toes Finish Motion tree Triggers Going back to the motion tree we saved earlier we must now add triggers and outputs. The triggers can be activated in the brain using an output node to change between actions. The trigger is off unless the value is over 0.5. The two triggers we will use are walk and sit. Click Tree > triggers on the top menu bar This will open up the Tree triggers window. Click add and in the top text box write 'walk' and hit enter This will make a trigger called walk, do the same for sit. 12

15 Now we must state when the trigger will start a transition. If the agent is walking we want him to continue to walk if the walk trigger is active. Click on the walk action oval The parameters box at the bottom will change and on the right is a triggers parameter. Click the box next to triggers and select 'walk' from the drop down menu Do the same for the sit action but assign the sit trigger. With the actions that start as one pose and finish in another (walktosit and sittowalk) in most case you can use the end action as the trigger. So walktosit will use the sit trigger and sittowalk will use the walk trigger. Outputs When a particular action is active we can create a variable that will output a value to show it is active and when not active will be zero. These can be accessed using an input node of the same name in the brain. Let's make two for now and more as we need them as the brain develops. Click Tree > outputs Add a 'locomotive' output and a 'stationary' output in the same way as adding to the Tree trigger window Click on 'sit' and change the output parameter to 'stationary' and the 'walk' output to 'locomotive' Now the motion tree is in a working state we can activate it Click the background on the motion page to show its parameters Click the 'active trees' button to toggle it on 13

16 This will make this tree active, by pressing F2 the current and next actions will be highlighted. Test with Sequencer Now we have a working tree we can test the transitions by using the sequencer. The sequencer allows us to specify actions in the order we want them to happen to check if the actions smoothly go from one action to another. Click Run > Sequencer to open the sequencer window Add a few actions by highlighting them and clicking on 'append' Be sure that the actions are in a logical order, e.g. walk, walktosit, sit would be fine, but sit, walktosit, walk will not make sense as the agent will never be sitting and the do the motion of walk to sit. Make Chair The focus of the project is to make an agent the play musical chairs, to do this it must get information from it s environment. Therefore we must make a Chair agent that can communicate with the player agent. For now we will create the agent and build a simple body. 14

17 Build Brain What rules do we want the agents to obey? The following table shows the rules that we need to apply in the music on mode and music off mode. Music ON Music OFF Avoid collisions with one another Avoid collisions with one another Walk around the chair arrangement Walk around the chair arrangement Avoid intersecting with chairs Avoid intersecting with chairs Do not overtake other player Walk around chairs until available chair is found Sit on next nearest available chair Ground To make the agents walk on the ground we can simply use a module from one of the Massive agents. Turning The agents walk action is along the Z axis, however we want him to walk around the chair so we need to make him rotate about Y. To do this we must offset the agents ry channel. Drag an Output node onto the page and set the channel to [ry]:offset and the range from 200 to 200 Now start the simulation with walk on and adjust the output value of [ry]:offset, notice the agent turns to the angle specified in the output. Now we need to control the ry offset. We will make a macro that fuzz values can be attached to. Drag two OR nodes and call one 'left' and one 'right'. This will be where fuzz values are connected for rules that involve turning Now we need to defuzz the values that come in. 15

18 Connect each OR node to a Defuzz node. Then connect the Defuzz nodes to the ry offset output Set the left Defuzz value to 200 as the agents left is minus, and set the right defuzz node to 200 Create an additional defuzz node and call it 'straight', leave the value at 0 and enable else This will change according to the value of left and right defuzz nodes. If left and right are both zero then straight will be true. Now highlight all of the nodes and put them into a macro by pressing alt g. Click on it and give it an appropriate name, say, 'Turning (RY)' Go into the macro by hovering the mouse over it and pressing Enter. Highlight the OR nodes and the Output node and press alt x, this will make these nodes visible on the macro box allowing us to easily connect to and monitor what's going on Press Backspace to come out of the macro. Hover over the macro to see names of the visible nodes Walk rate Next we must make a macro that controls the agents walking speed. This can be used to slow agents down when too close to other agents. We will make this in the same way as in the Massive tutorial, but as with the turning macro we will just handle the defuzz for now. In order to change the speed of the agent we need to change the rate that the 'walk' action is simulated at. Drag an Output node on to the brain page and enter the channel as walk:rate 16

19 Start the simualtion with the agent in the walk action and change the value of the walk rate Output node, notice how the speed of the cycle changes We want the agent to be walking at the specified rate unless told to slow down. Drag an OR node and name it slow down Drag two Defuzz nodes and name one slow and one normal. Connect the OR node to the slow Defuzz node Next connect the Defuzz nodes to the Output node and give the 'slow' Defuzz the value of 0 and the 'normal' Defuzz a value of, say, 0.5 and enable else The agent will walk at the normal rate unless slow receives an input. To keep things organised make this into a macro as before and make the OR node and walk rate Output node externally visible. Music switch As we have to modes when we want to different sets of actions to be used we must make a switch. The two modes are music on and music off, so the first thing we need to do is make a variable. Drag an Output node and call it Music This creates a new brain variable called Music, we will use the value of 0 to mean off and 1 to mean on. To check on the value of Music we can make an Input node and call it Music, it will hold the value of the Music variable as defined by the output. For now manually change the value of the 'music' output to change turn off the music. Later on it will be a good exercise to use a timer to toggle between music on/off. 17

20 Music ON mode Walk when music is ON Whenever the music is on we want the agents to walk. The walk action is set to default in the motion tree, therefore if no other triggers have made the agent change to another state then the agent will be walking. However, if the agent has been told change state to sit, then we want the agent to return to walk. The only case when this would happen is if the music went off, the agent sat down and now the music has started again. To achieve this we simply need to tell the agent to go to the walk action when the music is on. Drag an Input onto the page and name it music, then drag an Output and call it walk. Connect music to walk using an black NOT connector (hold alt when connecting instead of ctrl) Now whenever the music Input is 1 then 'walk' will be 1 thus triggering the motion tree to go to the walk action and repeat until told otherwise. Walk around chairs The player agents must walk around the chairs. The simplest and most appropriate way to do this is to use a flow field. Again, the Massive tutorial has been followed on how to follow a flow field. Drag an Input node onto the page and enter ground.flow as the channel and the range from 180 and 180. This will read in the direction of the flow field in relation to the agent Connect the Input to two Fuzz nodes and name one 'left' and one 'right' Starting with the 'left' Fuzz node select the Z membership curve and enter the point values as 10 and 0, respectively Now select the 'right' Fuzz node and select an S membership curve and enter the point values as 0 and 10, respectively This means if the ground.flow value is less than 10 then the flow is on the left and if it is above 10 the flow is on the right with in between values being a smaller degree in each direction. The low threshold value of 10 in either direction means that the agent will react quickly and sharply to a 18

21 change in the flow field and will follow it closely. Usually we would connect the Fuzz nodes to Defuzz nodes, however, we have already made the Defuzzification part in the Turning(RY) macro. Therefore we need to connect the Fuzzed values to the Turning(RY) macro. We could just connect the Fuzz nodes directly to the OR nodes in the Turning(RY) macro but it is neater and beneficial later if we connect the Fuzz nodes to some AND nodes as in the diagram. Drag two AND nodes and name one flow left and one flow right. Connect the left Fuzz node to the flow left AND node and likewise with the right Fuzz node Make this into a macro with the INPUT and AND nodes externally visible, name the macro Navigation We now have an agent that will follow a flow field. Before we go any further let's test to see if it actually works! Go to File > Load Terrain and load in plane.obj Go to edit on the top menu bar and select Flow Field from the drop down menu Draw a flow field, apply it to bake it into the terrain map's alpha channel and then open the place tool from the edit menu Place an agent on the flow field and run the simulation. The agent should follow the flow around Slow when other agent is ahead The next rule is to stop agents from colliding with one another and stop them from overtaking each other. We will be using a combination of vision channels to implement this rule. First we will use vision.x 19

22 to check that the agent is in front. Then we will use vision.z to see how close/far the other agent is and then we will use vision.h to check what they see is a player agent as it will be a unique colour compared to anything that is visible. Let's pick a colour for the agent that we will not use for anything else in the scene. The are a couple of ways to do this. One way is to go to the scene page, select the Player Agent node and can the colour in the bottom tool set to 0.1, which is red All body segments are set to inherit this value by default. If you delete all instances of the agent (ctrl d) and place (ctrl p) it you will see its colour has changed. Drag 3 Input nodes and enter the channels root:vision.x, root:vision.h and root:vision.z, one channel per Input This will use the vision from the root segment of the agent, the head segment is not used because the head moves so much that it doesn't provide a good awareness of the agents environment. Connect each Input node to a Fuzz node Select the Fuzz node connected to the root:vision.h Input, notice how the fuzz background has changed to a spectrum. We want to know when red (0.1) is seen, select a lambda membership curve and enter the point values 0.075, 0.1 and , respectively. This gives a bit of tolerance around red so will return a value if an agent can see red Select the Fuzz node connected to the root:vision.z Input and select an S membership curve. Enter the points values as 0.55 and 0.9, respectively This is saying if the other agent is closer than 0.55 then gradually increase the fuzz value, if it's closer than 0.9 then the fuzz value is 1. Select the root:vision.x Input node and change the range to 1 to 1 The minus region is left and the positive is right. Select its Fuzz node then select a lambda membership curve. Enter the point values 4 and 4, respectively 20

23 This returns a value when the other agent is slightly to the left, centre or slightly to the right. The curve is so wide so that the agent doesn't overtake the agent in front even if he is to either the left or right as well. Now we are happy with the fuzz values we must combine all the rules together so that the agent is told to slow down only if all rules are true. Drag an AND node and name it 'slow down,' connect all the Fuzz nodes to it Make all of it a macro and name it 'Collision', then externalise the AND node We can connect it to our walk rate macro now. Go back to the uppermost level of the brain page and connect the 'Collision' 'slow down' node to the 'slow down' node in 'Walk Rate' Now test it to check it all works to plan. Place a few agents on the flow field one behind the other and fairly close together. Run the simulation and watch as the agents slow down when too close to each other The music on mode is pretty much complete except for one thing, we need to make sure that none of these rules occur when the music is off. This is quite simple, all we need to do is introduce a new criteria to each rule. We must check to see if the existing rules and music on is true. Drag an Input node and call it 'music' so that the current value of music is received Connect it to the AND nodes of the 'Collision' and 'Navigation' macros Now whenever the music is off the AND node will be false and hold no value, thus passing on no value to the defuzz/output macros. 21

24 Music OFF mode Avoid each other To make this rule we need to extend the 'Collision' macro defined in the music on mode. Instead of using the same macro we will make a copy to work on as this rule should only happen when the music is off. Select the 'Collision' macro and copy (alt c) and paste (alt v) it on the brain page Enter the macro When the music is on the agents are allowed to overtake one another, therefore we must give them the ability to turn in the opposite direction that the see the other agent in. We can do this using root:vision.x and getting some more fuzz values from it. Drag two Fuzz nodes, connect the root:vision.x Input to them, and name one 'left' and one 'right' Select the 'left' Fuzz and select a Z membership curve, enter the point values as 4.0 and 0 Select the 'right' Fuzz and select an S membership curve, enter the point values as 0 and 4.0 Drag two AND nodes and label them 'turn right' and 'turn left' If the other agent is on the left, near and red we want to turn right. Connect 'left' Fuzz, 'near' Fuzz and 'red' Fuzz nodes to 'turn right' AND node If the other agent is on the right, near and red we want to turn left. Connect 'right' Fuzz, 'near' Fuzz and 'red' Fuzz nodes to 'turn left' AND node Externalise the new AND nodes and then we can connect it to the 'Turning(RY)' macro Before we connect it to the turning defuzz macro we must change it a bit. At the moment if we connect it then the flow field and collision rules will both influence the agents RY offset. However, if an agent is going to collide with another then it is more important that this situation is resolved rather than the agent sticking to the flow field. We need to introduce a priority system to the rules. 22

25 We can do this by saying if 'Collision' has an input to the 'Turning(RY)' macro then ignore the flow field input. Enter the 'Turning(RY)' macro and add two OR nodes, call them 'LEFT' and 'RIGHT', the caps signify priority Connect them to the appropriate Defuzz nodes Append two AND nodes in between the other 'left' and 'right' OR nodes and the Defuzz nodes Make a NOT connection from 'LEFT' OR node to 'right' AND node Make a NOT connection from 'RIGHT' OR node to 'left' AND node Externalise the new OR nodes Connect the 'Collision' 'turn right' AND node to the 'Turning(RY)' 'RIGHT' OR node Connect the 'Collision' 'turn left' AND node to the 'Turning(RY)' 'LEFT' OR node Now we must make this rule only happen when the music is off. NOT connect (alt click) the 'music' input to the AND nodes on the 'Collision' macro By using the alt connector instead of the normal connector we are saying that music must not be true as well as the other rules being true for the AND to work. Walk around the chairs This rule is the same as the Navigation macro in 'music on mode' with the 'music' input node 23

26 connected with the NOT connectors instead. Copy (alt c) and paste (alt v) the Navigation macro and disconnect the 'music' input (ctrl alt click) and reconnect it using the NOT connector When pasting the macro sometimes the connection to other macro get messed up, make sure they are properly connected to the other macros Walk to sit This is the most complex part of the brain, the agent must be within a particular area to be able to successfully transition into the sitting action and actually be sitting on the chair. The agent must be within a certain distance, at a particular angle and on a particular side to sit on the chair. We will use sound to detect whether the agent meets all this criteria so that it can trigger the walktosit action. The chair will emit a sound for the agent to receive and use it to check if it meets the criteria. The following diagrams allow us to visualise the rough position the agent can be in and we can do some simple trial and error testing and tweaking to get the agent sitting in a satisfactory way. 24

27 Select the Chair agent by scrolling through the agent with alt o or go to the scene page and select the Chair agent node Go to the brain page and drag two Output nodes, call one sound.a and one sound.f This creates a sound channel of the specified amplitude and frequency. Select sound.a and change the range to 0 to 100, and the value to about 65 Select the sound.f Output, change its range to 0 to and change its value to 200 Press shift to view the Chair agents sound emissions The frequency can be any value you wish but must be the same as the frequency the Player agent uses to distinguish the chairs sound. Now lets go back to the Player agent and implement the rules that we discussed. 25

28 Use alt o until the Player agent is selected Drag four Input nodes, connect them to fuzz nodes and edit the parameters as in the following table Input Channel Range Fuzz Membership Curve Values sound.d 0 to 1 Pi 0.75, 0.76, 0.82, 0.83 sound.ox 180 to 180 Pi 100, 100, sound.x 180 to 180 Pi 7.5, 11.5, 21.5, 29.5 sound.f 0 to 1000 Singleton 0.8 Combine the Fuzz nodes by connecting them to an AND node and name it 'sit' We need to send the fuzz inputs to be defuzzed. Connect the AND node to a Defuzz node and make the defuzz value 1.0 Connect the Defuzz node to an Output node with channel name 'sit' This translates to: when in the specified area and facing the right direction then begin sit action. At the moment this will occur at any time during the simulation. So we need to make sure it only happens when the music is off. Make a macro of the rule and externalise the AND node Connect the 'music' input to the AND node using the NOT connector A problem with this implementation is that the agent must be in a small restricted area to be able to sit, the odds of this are not that great for the simulation to be believable. Therefore we must cheat a little to increase the odds of agent being in the right space at the right time by guiding it into the right position when the music is off. Make guide We will create a guide pole that the agent can move towards leaving it in roughly the right area to sit. Go to the body page of the Chair agent 26

29 Add another box segment, make about the same height as the chair seat and big enough for an agent to seem Change its rest tx value so it is positioned before the chair just before the rough area that allows the player agent to sit Set colour to yellow Walk towards guides Now we have the guide we need to make the agent walk towards the guide when the music is off and when within a certain distance of it. Once it is close enough we want him to carry on obeying the other rules. We will use vision to do this Drag a three Input nodes, connect one to three Fuzz nodes and the other Inputs to one Fuzz node each. Configure them as in the below table Input Channel Range Fuzz Name Membership Curve Values root:vision.h 0 to 1 yellow lambda 0.175, 0.2, root:vision.x 180 to 180 left centre right Z lambda S 4.0,0 4.0,0,4.0 0,4.0 root:vision.z 0 to 1 near S 0.06, 0.25 Turn ON and OFF chair/guide In the Chair agent brain we need to change the guide and chair colour back to default when the agent 27

30 is close enough to the chair to assume he is going to sit on it. We will also change the sound frequency emitted by the chair so that agents will not sit on an unavailable chair. We will use sound for this, when a chair can detect a sound being emitted from a player agent is close then it will change the guide colour. Drag and name nodes as illustrated in the picture below, I'm sure the settings will be self explanatory from the names Using a S curve change the sound.d Fuzz node so that fuzz values are false when an agent is close Change the sound.f value to the same as the frequency emitted by the player agent using a singleton curve In the Defuzz nodes make 'green' and 'available' else nodes so that they are the default if the other connected defuzz is false Give the Defuzz nodes the appropriate value as the name suggests You may have noticed that we are changing the chair colour to green by default and grey when unavailable. The reason for this will become apparent when making the rule for agents losing the game later. 28

31 Set player sound emitter Now the rule is in place for the Chair agent we need to emit a sound from the Player agent. Go to the Player's brain Drag two Input nodes, name one sound.f and give it a frequency of 100 as this frequency is not in use Give the other Input node the channel name sound.a and an amplitude of 75 This should be large enough for the chair to realise that it is available as when an agent is this close he is probably committing as sit down. Loser leaves game When all the chairs are unavailable the remaining player must realise this and leave the game. Sadly there is no way of making global variables that all agents can access so we can not simply make a counter and decrement it every time a chair is taken. Instead agents will assume that all chairs are taken if they have not seen an available chair within a certain time frame. Although not the best way of implementing the rule, it seems to work! We will use vision and a timer to implement this rule. Drag a Timer node on to the Player agents brain page Set the parameters to always and endless The timer will always be on at this point. We need the timer to reset every time the agent sees an available chair. Drag an Input node and name the channel root:vision.h Connect it to a Fuzz node, name it green and select a lambda curve and enter the point values as 0.275, 0.3 and Connect it to an AND node and then to the Timer node This will make the timer reset every time it sees green, however at the moment there is no green. Earlier we made the Chair agent green when available and grey when not available. 29

32 Back to the Player agent and the rule we started. When the timer reaches one we want it to tell the agent to leave the game. We will make a new variable to hold the value of whether the agent should leave or not. Drag a Fuzz node and connect the Timer to it, name it 'times up' and select an S membership curve Enter the point values and This basically means when the timer is less than 1 remain zero, if the timer is above 1 then return the value one. Drag an Output node and create a new variable called 'Leave' Connect the 'times up' Fuzz node to an AND node and then to the 'Leave' Output We also want to make sure the agent is locomotive and not sitting when told to leave as it will mean has hasn't found a seat. Drag an Input node and enter the channel as locomotive, this is one of the outputs specified by the motion tree to say that the agent is walking. Connect it to a Fuzz node and call it true, select an S curve Enter the point values and and connect it to the AND node This is telling the agent that as soon as the agent is locomotive then become true. This is so that the instance he begins goes from sittowalk the fuzz will output 1. When the agent is told to leave we want him to walk away from the game. A simple way to do this is to use vision and tell him to walk away from any visible furniture or agents. Drag two Inputs and join one to a Fuzz node and the other to three Fuzz nodes Enter the parameters as per the following table Input channel Range Fuzz Name Membership Curve Values root:vision.z 0 to 1 near S , 0.9

33 root:vision.x 180 to 180 left centre right Z lambda S 4, 0 4, 0, 4 0, 4 Drag three AND nodes and name them: turn right, turn left and slow down As we only want this to happen when the agent is told to leave we need to add this rule to avoidance rules. Drag an Input node and call the channel 'Leave' Connect it to each of the AND nodes Make a macro of these rules, name it 'Leave' and externalise the AND nodes Connect it to the 'turning(ry)' macro as a high priority turn and connect the slow down node to the 'walk rate' macro to defuzz and output the values Placement Now the basic brain rules are ready let's test it in a small scene and hope it works! Using the place tool position 3 chairs in a row and then another 3 behind them in an offset position as in the picture below. Queue up 7 Player agents (one more than the amount of chairs) around the chairs, make them a reasonable distance apart from each other. 31

34 You can which ever method to position the agents that you prefer. For the Chair agent I have used a locator and then adjusted the columns, for the chairs behind I used the same method but changed the angle by 180. This will give perfectly straight lines. Bake the flow field Now that the agents are in place we need to bake a flow field for the agents to follow around. Go Edit > Flow field to open the Flow field window Click to Add a Flow field and draw a few points so that the path follows around the chairs circuit as in the picture below Change the edge angle to 40 so that it stop agents from leaving the flow field and increase the width to 0.8 When you are happy with the flow field press apply Run Simulation Delete all instances of agents (ctrl d), then place the agents (ctrl p) and the run the simulation (space bar). It has problems. Initially the agents walk around the chairs as expected and don't over take or collide with one another while the music is on. However when the music goes off the agents seem to be all over the place, some sit down but some walk through chairs, cut across the middle and follow strange paths. If we select a Player agent in the view port and then display his brain we begin to understand what the agent is thinking. Shift click on a Player in the view port who cuts from one side of the circuit to the other when the 32

35 music is off and navigate to the brain page Click View > vision to turn on vision in the bottom left corner of the view port Now we will play the Simulation until the music goes off and then play the sim frame by frame while monitoring the agents brain values. Reset the simulation to frame 0 (alt r) and start it again When the 'music' variable is 0 then use the '.' key to play the sim frame by frame By looking at the OR nodes of the 'Turning(RY)' macro we can see when the agent is being told to turn and in which direction, then we can trace it back to which rule is telling it to turn. By doing this you should notice that the agent is getting confused when following the yellow guide, the problem is that he can see the yellow guide on the other side of the circuit and it attempting to follow them at times. We need to stop the Player agent from seeing across to the guides on the other side. A quick and easy way to do this is to make a divide in the middle, this will block the guides from the agents field of view. Make brainless Divide agent Create an agent in the scene page and name it divide Go to the body page and change the tube node to a box by clicking on the nodes icon in the bottom tool bar until it displays a box Adjust the shape so that it makes a divide between the chairs so agent cannot see the guides Adjust the rest ty so that the box is above the terrain Place a Divide agent between the chairs and adjust the segment shape so that it is the length of the chairs put together and a little higher than the guides so agents on the other side cannot see them. Tweaks and Additions It seems that we have successfully made agents play musical chairs. However it is a very boring unrealistic game of musical chairs where everyone is doing the each same thing almost in a 33

36 synchronised way. We need to introduce some realism to make the Player agents behaviour more believable. By watching people play musical chairs or reminiscing to the last time you play it there are an endless amount of behavioural changes we can introduce. We will make a few additions as follows: Make Player agents head turn in the direction they are turning so they can see where they are going. When the music turns off the Player agents should act with more haste to try and find a chair Render opengl images Click Run > Sim to open the Sim dialog Enable the Pic toggle and state the name of the target folder (folder must already exist) and the file name with # at the end The # will be replaced with padded frame numbers. Make sure the Brain button is toggled on to activate brain processing and adjust the frame start and end rate 34

37 When ready press go to write.tif images to specified location Go to the folder specified and check the tiff sequence using your prefer tool, e.g. Fcheck This concludes this part of the tutorial, if anything is unclear you can simply open the accompanying.mas file and explore the set up. For any more question me at 35