PlayMaker 2 Events and Transitions

[00:00:00]Hello and welcome to the intro to events and transitions lesson. In this video, we're going to be going over the basics of events and transitions. What are they? What do they do? How can we use them within our project? To start off with, I'm going to make a new game object in here. We'll just call this basic events example. Okay, I'm going to add an FSM to it. One of the simplest ways that we can show how events are used is by putting in an action. So on our start state, I could put in an action. Say for example, bool is true.

[00:00:30]So all this action does is it sends an event based off of whether this bool is true or false. So if it's true, it can send an event and if it's false, it sends an event. We'll set a variable right now. We'll make a new bool variable called my bool test. Doesn't matter what it's called. Okay, so this bool variable, you can see that by default it's false, right? If we go over the variable tabs and we select it, it's false here. You can change this default value by setting the value here. So by default it's actually true. So you can see back in our state it's true and that value is going to be what sends these events. So we can name this state something like is it true question mark and the true event we'll make a new event called yes and then we'll make a false event make this false event called no.

[00:01:17]Okay because this answers our question right if the bull is true then we send yes if the bull is false then send no.

[00:01:22]So we can send off over here and over here. So this was we get renamed this state called it was true and this one is it was false.

[00:01:35]Okay. So by default right now you know we switched it to true. When I play this it should send off to this state. It was true. Okay. Perfect. It's there. And let's say I turn off this FSM. Right. If I come over to the variables tab and I change this value to false. When I turn this back on, it should send to the false state. So, I'm going to go ahead and turn this back on. And you can see, of course, it sends back to false. So, events and transitions are something that are used together. So, let's break it down. This true event is called yes.

[00:02:04]And it has a corresponding transition here, the yes transition. This event called no also has a corresponding transition called no. So, events are what fire off these transitions, right?

[00:02:17]So, if we're here in this is true state, there's an action in here that says it'll send either of these events. And on this state, the corresponding transitions will listen. To really just make this crystal clear, if I select this no transition, if I right click on it and say delete transition, we now only have a yes transition from here, right? So if our bull false event is waiting for us to send the no event and there's no corresponding transition here, you can see that there's no no transition here. Then this won't do anything. So I'm going to turn this off and I'm going to turn it back on and it should basically just get stuck here in the first state.

[00:02:54]You see it's still just here. It had no corresponding transition for that no event. Events and transitions are the same thing. They are kind of one and the same, but the way that they're represented in your interface is the only thing that's different. They're transitions when they are these little blocks that send off to another state.

[00:03:12]These little arrows that come out, that's what the transition is. The event is when the thing meets some conditions from your actions. Okay. So, over here in your events tab, you can see that we created this no and this yes. And in here, you could rightclick and say add event. And you can name them whatever you want. This is your does jump event or you can add another event called deal damage event. Right? So all of these can send off when some condition is met. On this one you might use it when you're using an action waiting for the player to press the space bar. And this deal damage one maybe gets sent off only when a physics check detects that a bullet hit an enemy or whatever. So, let's also go back to this state here, and we're going to open up the action browser again. And in here, I'm just going to type in the word send event. So, you could see all these event-based actions here. This one's just send event, and it just plain old sends an event. If we drag this in, you can see it just selects it. Let you put in a delay, but that's literally all it does. When this action fires off, it just sends a specific event that you tell it to. You could do this one that sends by name.

[00:04:18]So, you could literally type in the string yourself manually. You could send the event to children. So you could send some specific event to all of the game objects that are a child of some root game object. Sending it to a specific FSM component. You could literally drag and drop an FSM component into this part. Sending event to game objects to a specific game object FSM where you could literally say, okay, on this game object, there is a specific FSM that I'm targeting. Let's actually take a look at this one because this one's a pretty common one, right? So if I get rid of these really quick, I'm going to get rid of our two actions here. We're going to actually delete all this stuff here, right? And all we want to do on this FSM is send an event to a different game object. You can see down here you get this little warning. It says event must be a global event. When you're sending events outside of your FSM, they need to be marked as global. So what's a global event? What have we been using? What we've been doing is sending local events. That's the events that are sent within the FSM that you're on, within the FSM that the action is placed in.

[00:05:14]But global events mean that they could be sent back and forth between other FSMs and other game objects. We're going to make a global event right now by coming in here and saying new global event. And you'll see that we get this window to actually create a new asset within our project cuz global events in Playmaker 2 are actual assets. You could save these wherever you'd like. But what I would recommend is that if you go to your root assets folder, if you don't already have this Playmaker folder, which is capital P, capital M, all one word playmaker, then you can make it yourself. But uh you might already have this folder in your project. I like to come in here and then make a new folder called my Playmaker 2 global events. And this is where I'm going to save mine. So I'm going to call this my global event test. Okay. So now it created that asset. And sure enough, if you go to the project and you go to playmaker my global events, you can see that the asset is right here. So it's actually a file within your project. Okay. Now back in the editor, we have it selected to send this event. this send event to game object FSM. We're going to make a new game object for this to send to. So this basic events example, that's what we've been putting this FSM on the whole time.

[00:06:23]But I'm going to make a new game object.

[00:06:24]I'm going to say some other game object in the scene. Right? So that's so we're using this game object here to send an event to an FSM on this game object here. Let's add an FSM to this one. And we'll call this my other FSM. Now, similarly to global and local events, you can use global and local transitions. If I right click on my start state and I say add transition, it's going to add a transition down here that sends only from this state. So, this transition can only be sent if we are in the state that has it. Now, if I create a new state and I right click on it and I say add global transition, you can see that it kind of puts this sort of separate node above it. The transition is almost living on its own as its own little island and then it sends down to a state, right? As opposed to being directly connected to the state. When it's living as its own little island like this, this is considered a global transition. And that means that this FSM could be in any state. Even if you had all these different states, let's say you had this and it goes to this, right? And you had this whole FSM. Let's say you had all this logic like this, right? This FSM is going to be looping through these states and all of these local transitions on them can only fire off when they're in that state. So for example, if we're in the start state, this finished transition could not send off. We would have to be in this state for it to send off. However, [snorts] a global transition can be [clears throat] sent at any point. So if we're right here in the start state, we might have our other FSM send a global event here that'll immediately take us to this state. We can even be in state two and then this will receive this global transition and it'll show up here etc etc. So let's see that in action. Okay so uh for example let's get rid of some of these. We're going to do the local version first.

[00:08:11]Okay. So on this start state we're just going to say that this transition that I'm clicking on here is going to be the event global events my global event test. Right? That's the one we just created. Okay. And I'm going to have that send down to a new state where we'll call it global event received.

[00:08:32]Okay. So there's no actions in here.

[00:08:34]That means it should just get stuck here as long as no event is being sent to it.

[00:08:38]So when I press play right now, right, it's just staying in this start state. There's no actions here telling it to do anything. And currently it's no, there's no other game object or FSM in the scene that's sending off this global event that we made. But if I came back to our first game object where we put this send event to game object FSM, I could drag and drop that other game object in here and I could tell it, hey, this FSM, I'm going to come here and select its name and I'm going to copy that. Come back over here and I'm going to paste it in. And so now it's going to be looking for the FSM with this name on this game object. And then it's going to send this my global event test event.

[00:09:18]Okay. So now when I click on this, we should see that this gets fired off when I press play. Okay. And sure enough, it gets fired off. It happens so fast cuz there's no delay. There's no wait or anything. It's just the first thing that happened right when the game started.

[00:09:31]But you can see that we are now here in the global event received state. Let's see what it looks like when we're using global transitions. So if I go ahead and delete this transition and let's just say that we put in a wait for seconds action in here. This basically waits one second and then it finishes and then it goes to a new state and then it and in here we also do a wait for seconds action.

[00:09:55]And when that's finished it comes back up here as well. Wait one second part one.

[00:10:03]Wait one second part two. Okay. So there's no global transitions in here that we put in. And this FSM will just go back and forth. When I press play, you'll see it just goes back and forth.

[00:10:15]It waits one second back and forth.

[00:10:17]Okay, we can interrupt this if we made a state right here and gave it a local transition of my global test event and we had it sent down here to global event received.

[00:10:31]You'll see that there's two little islands here basically, right? These two are not connected in any way. They cannot reach each other. And since this is the start state, which is signified right here by this little icon, that means it's only ever going to stay here.

[00:10:46]When I press play, it's looping back and forth, right? And you can see that our other FSM, it sent this event.

[00:10:55]It successfully sent off to that game object to that FSM, the my global event test. However, in here, the my global event test never fired off. Neither of these states were ever entered. And you can see that we're just going back and forth between these two. That's because this is a local transition. Like I said, this can only be sent when the state is active, the owning state is active. But if we stop this and if I deleted this state and we just want this state to have a global transition, if I rightclick and say add global transition, now the transition itself is open to be received from anywhere. So I could say, okay, we're going to select this my global event test. And to really make this extra clear, what I'll do, I'm going to lock the editor so we could stay focused on this. All this does is it lets us click on other things while this stays what we're focused on. Don't forget to turn this off later. By the way, a lot of people will forget to turn this off and then they say they feel lost in their project. So just a heads up. Now I'm locking it so we could keep looking at it. But what I'll do is I'm going to turn off the FSM that sends the global event. So when we press play, you could see that our FSM is doing its business, right? It's going back and forth with the little weights. But when I select the FSM that sends the global event and I turn it on, which I'll do in just a couple seconds, we should observe that this gets sent off and these little this little state loop gets interrupted and we immediately go to the global event received state. Okay, so here we go. 3 2 1 and there we go. Sure enough, we landed here. This stopped going because our FSMs aka finite state machines can only be in one state at a time. So when this global transition was received, we arrived here. That's the basic idea of local versus global events and transitions. Now, one more pretty important thing about events and transitions after I unlock this really quick is that events can come with additional information. You can think of events as a phone call. Somebody dials the phone number and then the receiving end of that phone number has their phone ring, right? It's the alert. It it makes it do a thing. That's just what we've been doing, right? We've just been kind of going back and forth. We're just literally telling events and transitions like to go back and forth between states. That's kind of like just making the phone ring. It's just the part where you dial the number and then the phone rings somewhere else. Right now, to continue the metaphor, events and transitions are also like phones because once the phone rings and is picked up, then the two people get to have a conversation and you get to exchange information. Each person at the other end of the line can say something to the other. They can inform them about something. They can deliver some type of information between each other. We're going to delete these really quick.

[00:14:00]Okay, we're going to delete them. Now, I'm going to create an empty game object. I'm gonna call this one Joe. And I'm going to create another game object called Sally. And on Joe, we're going to make an FSM.

[00:14:14]And in here, all we're going to do is send an event to a game object FSM.

[00:14:21]Okay. So, we're going to have Joe send an event to Sally. The event that we want to send, we can create a new global event. And I'll call this one introduce myself.

[00:14:32]That's the name of this event. Okay.

[00:14:33]Hey, we're going to be sending it to Sally and we're going to be sending it to an FSM called phone. Okay, so we'll just make sure that we put an FSM on Sally called phone. Let's go over to Sally, right click, add FSM, and we're going to rename this FSM to phone. Okay, now in here, we're going to add a transition, a global transition using our new global event that we just made called introduce myself. Okay, and we're going to have it send off to a new state called who am I talking to? This start state, it just doesn't do anything.

[00:15:02]Okay, so she's just kind of waiting by the phone. Okay, and in this who am I talking to state, we're going to put an action called check string equals.

[00:15:14]Okay, so all this is going to do is it's going to look at an incoming string. A string is just a variable of text, which is, you know, letters, numbers, characters. So we could compare that incoming string variable to I'll just type it in here manually, Joe. Right?

[00:15:31]We're basically be saying, hey, is this string variable, which we can make a new one of. Let's make a new string variable called incoming name.

[00:15:39]Okay, so we could say, is the incoming name equal to Joe? And if that's true, then we can make a new event called talking to Joe. Okay, we'll add that.

[00:15:50]And this transition comes out here to a state that we'll call it's Joe.

[00:15:56]And then if it's false, we can make a new event called not talking to Joe.

[00:16:03]So we add that transition. Can also send to a state and say it's not Joe. How do we get the incoming name? How do we find what that is? Well, we're receiving this global event, right? It's Joe that is making the phone call to Sally here, and he's sending this event to the game object, and he's the one that's sending this event. Here's what's really cool about events. So, like I said, you could send data with the events.

[00:16:31]For example, if I go to events and I select this introduce myself event, a button down here shows edit global event. If I click that, it shows over here the inspector the actual global event asset. So, there's a bunch of stuff that you can do with this, but we're going to do something really simple and we're going to go over to this event data section here. So, under this section, there's an add data button. If I click that, it lets us select a type of data. So, I'm going to select this dropown menu, and I'm going to say that we want it to be a string.

[00:17:01]And we're going to name this data something special, too. It's going to be called my name. And so, you can see down here in our action when we send that event now, it's also given us this new parameter, the my name. And it has this little paperclip, right? And that's sort of like saying, hey, this is coming with this information, right? It's kind of like paper clipping a little piece of data to our event. And right now we only added this one, the my name value. But in here we could set it with whatever we want. So Joe's making the phone call. So Joe can write his name in like this.

[00:17:30]Joe. Okay. So when he sends that event, let's give that a little delay. Let's say it it takes 3 seconds.

[00:17:36]When Sally receives this, if I select this global transition, which is, you know, the corresponding event is introduce myself. When I select it in this transition tab, you could see that it also has an event data value. And here it is, my name. We can select this dropdown which lets us set our set our incoming name variable. So we could use whatever comes from here and put it into this value. So that means when we arrive at this state right here, it'll be able to check the value of incoming name against Joe and then decide whether it's Joe or it's not Joe. If I press play, we should be able to wait 3 seconds and then this should fire off and it should go to the it's Joe state.

[00:18:19]There you go. Because it was Joe. Now, if I turn this off and turn it back on again, so she's waiting by the phone again, and I come over to Joe and I say, "Uh, actually, it's Kristoff, right? I just wrote in Kristoff here." Uh, and we go back to the Sally game object. Now, what I'm going to do is just lock this FSM so we could be looking at the FSM.

[00:18:40]And I'm going to turn off Joe. And then I'm going to turn him back on so he makes the call again. But remember, this time he's going to say it's Kristoff.

[00:18:47]So, when I turn them on, we should see that this goes to the it's not Joe state. So, I'm going to go ahead and activate him. And 3 seconds. Boom. There we go. It's not Joe. So, you can even come over here and click on the state.

[00:18:59]And look, the incoming name you could see here is Kristoff, right? That's what he sent with it, you know. And this is us manually writing in the values. So, if I unlock this and let's stop playing the game. Uh, if I go over to Joe, you know, it's not super helpful to just manually type it in right here because in games things are things could be so much more dynamic. For example, this game object is already called Joe. So, what we could do is put in an action get game object get name. So over here, we're going to do this first. We're going to say, hey, get the name of this owner game object, which is Joe, by the way. and we're going to store it in a new variable, a new string variable called my name.

[00:19:45]And then in this my name data that we're sending, we're just going to we're just going to use our own variable. So it gets my name and then it sends that off to Sally. Let's also make the delay a little shorter. We'll just make it 1 second. Now, if I click on Sally and we press play, this should still work. It should still go to it's Joe because he should successfully get his name and send exactly that. There we go. Great.

[00:20:08]So, you know, if you came over here and renamed this game object Kristoff, we're not changing anything else other than what he the name of the game object is.

[00:20:16]And we press play again, it goes to it's not Joe. So, that's how event data is really powerful. Now, you could send all sorts of stuff over the over the pipeline. You could send, right? So, like when you select events and you say introduce myself, edit global event, it's not just strings. You could send ins, bs, vectors, game objects, transforms, sprites, camera, like all this stuff in here. All these values you could send over with events.

[00:20:42]That's really powerful. Okay. Now, the last thing that we're going to go over here is is something that you kind of get for free that's built into Playmaker and also built into Unity to begin with.

[00:20:51]So, even without Playmaker, it's just cool how Playmaker you could use this.

[00:20:54]The first thing I want to show you, so we're just going to create a new game object. I'm going to call this what is finished. Okay, I'm going to add an FSM in here and I'm going to put in a int add and string append. These are just some random actions. I'm literally just kind of putting anything in here. And I'm going to say, okay, we have our int variable called my int. And we're going to add one to it. And then we're going to make a string variable called my string. And we're just going to add to the end of it called new end.

[00:21:30]you have all these actions in your state, right? And they kind of do their things. If you want it to progress and go on to the next state, say you have like, okay, do this stuff and then you have the next state where it's like, and then do this, right? You have other things that you want it to do. Well, how do you get from here to here if these aren't sending any events, right? If you just wanted to do these basic things, but they don't have any events to send because they're just kind of, you know, doing some math and adding some letters to the end of a of a string. So, how do you do that? You may have seen me do it a little while ago, and it's pretty simple. On on states that you just want to go to the next state when they're finished, you can add literally a transition called finished. If I hold alt and then click on this state, you'll see that it adds this finished transition. And it's finished written in all caps. This is a transition that's a little different from the rest of the game. You don't make this one. Playmaker comes with the finished transition. So this when I direct the arrow here, the thing that's special about the finish transition is Playmaker comes with this and you can even see it has the little flag on it, right? For like the finish line, Playmaker comes with this transition as its own little logic that runs under the hood that waits for these things to be done. And when it sees that both of these are done or everything else in your state, whatever specific things that you might have in your state are done, whenever they are complete and they're no longer running, then it will send off to this next state. So, what you have to remember is if I press play, this will work just fine because it does these two things and then it sends off.

[00:23:06]Right? It happened so fast we couldn't even see it, right? It did these two things and then now we're here in this state. But if you have an action that is running every frame that doesn't really have a condition of being finished, for example, you could even put in a wait for seconds, right? And we're going to say it's going to wait 5 seconds. When I press play, right, it still has to wait 5 seconds and then it goes down to do this because the state wasn't finished. This wait for seconds action was still running. the finished transition didn't fire off until the very end until the very end of that five seconds. Another thing is that that kind of had five seconds as a finished end eventually, but but you have some things where it's like this look at target, right? So, let's say we want this game object to always be looking at Sally.

[00:23:55]And we're not really going to be able to observe this in the game because this is just literally moving the game objects direction or whatever. But I'm putting this in for a good example because this thing basically never finishes. This is just constantly doing this action of looking at the target. And you can see that it comes with that right here in the corner. It says runs every frame.

[00:24:16]Right? So if I click on this, the update mode is by default running every frame.

[00:24:21]So now when I press play, okay, we're just we're in this state indefinitely.

[00:24:27]There's no logic in this state that ever says to to continue on to the next state. And since we're using the finish transition, it's waiting for stuff to be finished.

[00:24:38]It even gives us this little exclamation mark right here. It tells us, hey, there's something this finished transition isn't going to do what you want it to do because you're kind of breaking one of the rules. And over here you can see it says finished event was never sent. The state never sends a finished event because it has actions that don't finish aka our little transform look at target. And you know you can see that it's still running because when actions are done running they get grayed out. You see how these two are just kind of grayed out. They're a little faded. But when actions are still running the little check mark will be green and you can fully see like all the clarity of all the values in it.

[00:25:12]It's still doing its thing. Now again if I click on the transition and it tells us this little list of options here. It says use a wait for whatever seconds action as the last action to force the state to finish or manually send the finish event to force the state to finish which is you know we could use a send event action or replace the finish event with another event. So some other event that is going to be sent off by something that we're doing. So for example in here if I leave this running right but I add in a wait for seconds action.

[00:25:42]Now that we are going to wait let's say 5 seconds again you'll see that the little warning went away and it's because this will do its job the whole time. It'll keep running that whole 5 seconds. But this wait for seconds action it is specifically built to make this state complete at the end of it. So by the end of 5 seconds it tells the state we're we're all done here.

[00:26:05]This is like a way of brute forcing the finished transition. So now when I press play, you can see that the transform look at target is still running and then it goes at the end of those 5 seconds.

[00:26:15]This can also be done if you're just checking for the values of things like before when we were using the string check equals right in here. Our string check equals it has a true event and a false event.

[00:26:28]You could make it so that it's running every frame. So now that it's running every frame, it could send an event after it meets some condition if it's equal to or whatever. Like if you if you're waiting for somebody's name to change or some incoming value, any number of things. There's so many actions that also send events that could be running every frame and that'll get us out of this state. Okay, so that's what the finished transition is. That's the one that comes with Playmaker automatically. You could go ahead and add a state in. And when you select it, if you go to events, finished will always be here for you to add in. So you could right click on the state and say add transition. And if you click this the event, you'll always see this option here, the finished transition. Even when I hover my mouse over it, you can see it says sent when all actions on the state have finished running. If you send this event manually, it is only sent to the current state. You are essentially telling the state to finish early. So the actions might not finish. this will always be here waiting for you even on a fresh new playmaker project. This this transition is given as one of the defaults. Okay, so you could always send off somewhere else using the finish transition. The last thing I want to show you, let's get rid of that. I'm going to create a new 3D object, a cube.

[00:27:44]Okay, and we're just going to move it down so we can see it in frame. Okay, there's our cube. I'm going to add a rigid body to it. Okay, now this is just a way so that when we press play, it's just going to fall. It's just a really basic physics cube, right? It just falls to the ground. The thing I want to show you is that if we add an FSM to it and we right click on this start state and we say add transition with this transition selected, if we go to the events, you can see that we have a system events category. So, if I select that, we have a few categories here. This is stuff based off of how somebody is like looking at their window. the actual, you know, the game when you say for example, alt tab or somebody somebody messages you on another application that you're currently running and you switch over to that and then you come back to the game, right? So that's like you want the application to pause or maybe you quit.

[00:28:34]These are events that will fire off transitions if these conditions are met.

[00:28:38]And usually it's like and you can see that they're all named very obviously as to like what they do. So if I put my mouse over this, it says on became visible means sent when the renderer became visible by any camera, right? So if any camera was pointed at it, pointed at this, then the the little mesh of the cube became visible, this would get sent off. Stuff like that. You also have stuff for mouse, and you could use these for UI elements. I'll show you that in just a sec. Particles and physics. So, so mouse events, you could just be waiting for the mouse to be doing anything if you clicked the mouse or the mouse is over an item or something like that. Then we have physics, and that's the one that we're going to use in just a second on this cube. UI events, and this is for stuff like all the elements on your screen, you can add in like a pointer click. So, that means that when you click on a specific item, this will get sent off. I'll show you those in just a sec, too. So, physics, uh, we're going to do something really easy. We're going to do this on collision. Enter. So it says sent when this collider or rigid body has begun touching another rigid body or collider. So we're just going to add that one. So literally this is just waiting to say, hey, when did we hit something on on collide with something?

[00:29:44]And we're just going to send to a new state called hit something, right? And it's basically like hit the ground cuz there's nothing else in the scene. So I'm going to turn our cube off by default so the game has a has a moment to kind of turn on and we don't miss it.

[00:29:58]And we're going to keep an eye on this down here, right? We're going to keep an eye on this FSM. When I turn this on, we should see the cube drop. And right when it hits the ground, this will get sent off. So, we're going to go and go.

[00:30:11]Right. Did you catch that? [laughter] Right. If I turn it off and we kind of move it up again and I turn it on, you could see it happen again. And I just turn it off so I could reset it and move it back up. Right? You see that when it hits the ground, it is sending off that transition.

[00:30:32]those events are in Unity to begin with.

[00:30:34]So, Playmaker just has a way of listening for those same moments within Unity's own event system. The UI element, like I mentioned, is as easy as coming over to whatever your canvas is.

[00:30:45]So, I already have So, I have this canvas here. We'll make a UI text mesh pro button, right? And I'm just going to keep it called button. And if I add an FSM to this button game object, right, you have the start state. It's just sitting here. But if I make a new state, uh we'll call this clicked me.

[00:31:04]And then if I right click on it, add a global transition.

[00:31:08]And then I'll say the event is system events UI events onpinter click. Okay.

[00:31:19]When I press play, we're here in our start state. But you'll see that when I come up here and I'll click it in just a few seconds, this onpoint click transition will fire off to the click me state. So I'm going to click it. And there we go. So now we're in click me.

[00:31:31]And you'll see that since we're using a global transition, it fires off as many times as I click this. So I'll just kind of keep my mouse over this. And then as I click, you'll see that each time I click, it's firing off.

[00:31:46]So you can do all sorts of wonderful stuff like that using the UI events that Unity already has. Just as a little bonus, I'll also mention that if I delete this global transition and say that the start state has a transition, and that is using the onpointer click, then when I press play, hopefully you can already guess what this does, but just in case I want to make this extra clear, is when I click on it, you can see that we're in the start state, right? But when I click, it's going to go to clicked me. So, I'll do that right now. Okay, we're in clicked me, but now I'm going to click again. And you'll see that nothing's happening. We're just staying here in the clicked me state. So that's just hopefully to really drive home how local transitions and global transitions are different, right? So you can add in logic if you want your player to only be able to click a button once or only click it once on some type of condition or something like that. All that being said, so hopefully you can see that events and transitions are very important to understand when building your project with Playmaker 2.