Transcripts
1. Class Introduction: Welcome to UnreelEngine
five Rapid prototyping, turn based rock
paper scissors game. If you want to dive straight
into game development by building fun hands on projects, you are
in the right place. In this course, we'll create a turn based rock
paper scissors game from scratch using Unreal
Engine Five's blueprint system. This project actually
is part three of my rapid prototyping series
here on Skill Share, where we dive into
real world projects while learning our core
game development skills. As we build this project, you'll learn essential skills such as blueprint communication, creating random logic
for game choices, and setting up win
and failure states, which are all foundational
concepts within prototype. This class was assigned
for all skill levels, but if you are completely
new to Unreal engine, I recommend starting with my Unreal Engine five Blueprint
Fundamentals course. That course covers
all the basics, so you'll be well prepared to dive straight into this project. While you at it, maybe check out other projects within my
Rapid prototyping series. By the end of this
course, you'll have a fully functioning rock paper scissors game that
you can expand on and you'll understand
way more about rapid prototyping
with an unreal engine than you will at the start. So if you're excited to
create your own games like me and get hands on experience when we're
on Unreal Engine five, let's get started, enroll today, and I'll see you in class.
2. TurnBased: Project Setup: Welcome back to
the last prototype we're going to be doing at
least three prototypes. Yeah, hopefully, we've
learned quite a bit so far, but this is one of my
favorite prototypes to make and it's
normally one I do in the end of a first year
module as a way to allow students to extend
and what they want to do. But today, we're
going to be making rock paper scissors and
then hopefully giving you some ideas on how we could improve this rocks
game into something else. What do I want to
do? Let's start up the way we normally do. Let's make a new game project. Again, we're using a blank. We're making sure
it's blueprint, desktop minimum, maximum. It doesn't really matter really. But starter content
racing has turned off. I'm going to pour this
rock paper scissors, I'm going to pull because
that means I know. It's nice to name
things correctly, and I'm going to create. It should take a long time. This is hopefully the last
time we're going to say that, but give it a minute or two, and you
should be good to go. Okay, it's loading up.
Again, it's loading up the default level. We'll make a new level
straight away just to hit me at that so we don't have to
deal with that again. Okay, yeah. So let's just
make a level straight away. So content drawer on left
last time. In the content. In our content folder,
we're just going to make a new folder called levels. And then it's create
a brand new level. And we'll just call this
we'll just call this H. I'll open up. Saving, save down. While we're at it because
we're setting up this project. In our content folder, we'll
make a new folder called Blueprint called
And within this, we're going to make
a Blueprint class, and that's going to be
of type game mode base. That is going to be a
what shall we call it? A B PRPs Game Mode. Nice and easy? Wow,
we're at this. Let's just go into project sings and then set our maps and modes. So we got our RPS game mode, and then we got our
Editor stardom maps. And now we should
be ready to go.
3. TurnBased: Base Logic and UI: Okay, welcome back.
Let's start adding some logic to make a rock
paper scis typing game. We're just going to make a really simple rock
paper scissors game, which just outputs in
the log at a moment. Then later on we'll add
some UI and then add some extra features to make it a little bit
more fleshed out. So the way we're going to do this and what
I'm going to introduce you to is I'm going to make a brand new content
folder called data. Within our data, we're going to make something called an Enum. So you right click and
normally under Blueprint, you'll find somebody
calling an enumeration. And we're going to call this
attack voices's call Enum. You sometimes see them
as E attack choices. Actually, yeah, let's just do E attack choices because that refers to an
Eum at the start. So E attack choices. Now, what an enum is a
special type of data type, which you normally
find in engines and languages used around
C. So what an Enum realistically is is it takes a one um realistically
is integer values, which have been renamed to whatever you
want to call them. It bundles up in a
really nice system. So we have free attack
choices in rock rib scissors, and I'm going to click
free numerations. And I'm going to have
let's have it Rock. Help. Scissors. Be and spell scissors? You got rock paper scissors. Now, what these
actually really are is just the integer zero, one, two, but for
us, we get a nice, easy to understand variable type or number type or data type, which we can understand which of the three different stages for. You will see Eenums
used quite a lot, especially within anything which is facing towards the editor. So if you're making
something which has to be set in an editor, you can they will be filled with enums with descriptions
to explain what they are. But they're normally nice
and self explanatory. So we have these one called
the E attack choices. Now we're going to
make a second one. So let's make a second one.
So blueprint E nu gonna call E win states. Okay. Let's call it win stats. I think there's probably
a better name for it. And this time, you
have three states or three states with rock
rips you either Whim, lose, draw or tie. Again, I think it as
a zero, one, two. Nice and easy. These
enums are fantastic. And when you can,
anything which, again, is facing towards
me editor or facing that another designer or
yourself might use it later on. Instead of using
integers or having, you know, one means this thing, two means this thing, three
means or even a Bolling, have a think about using enums. So we're going to do a lot of our logic within the game mode. Because the game mode holds a lot of stuff, we're
going to use it. And also, we can access the
game mode quite easily. So we're going to
open up the game mode and do a lot of logic in this. So make sure you open
up the game mode. We're not going to add
any components to this. We're just going to go
straight to a Bank. And we'll tell you all this. And what we're going
to do is we're going to make a few variables. I'm going to first things
first is make two variables. F one is going to be
called CPU choice. And this is going to be of This is going to be a
variable type E attacks. We can now have variables
which are of that data type, and you can see it will allow us to select one of
these three things. Our second one is
going to be win state. Instead of being
E attack choices, it's going to be E win date. And, yeah, it doesn't really matter what
we default out to. And we're going to make a brand new customer
event so let's make event and Let's make
one called Pick winner. And we're going to
drag out, and we're going to use a node, which
we haven't used before. Another execution and flow nodes going to be called switch. And this time it's going to ask you what do you
want to switch on? And you'll notice
it's going to switch, and a lot of these have
E at the start of it, which means these
are really, really great to use of Enums. Now, what we're going
to do is switch on attack Choices.
Come up with that. And I'll ask you what
is the selection. And what we're gonna
do here is we're gonna put the selection
straight into here. What that leads us now to is
whatever that selection is, it's going to change some logic. So whenever we call event, it's going to ask for an enum, and then it's going to move
do one of these free things. Now, with rock paper scissors, the reason why I love making rock paper scissors
is that there is only realistically
nine outcomes in the rock paper scissors. You either you play rock and in the era play rock
paper or scissors. I place paper, and
they either do rock paper or scissors
or I do scissors, and the opponent does
rock paper or scissors. There are nine
different outcomes, and each of those
outcomes can be tied to three
different wend states. So we're going to manually do
that, and this is a really, really good way to
learn about kind of game flow realistically how things work is by
doing this manually. And because there's only
nine different outcomes, it's quite easy to do. Let's say, if we
had five of these, you can kind of figure
out how many outcomes it is, but it's by timesing it. So we have nine outcomes, and that's free choices
times free, which is nine. If you had five, it'd be five
times five, which is 25. If you had ten, that'd
be 100 different styles. When you start to get a
point when you're having to manually do more than 15, if that, maybe ten, it would be worth looking at a different system
to figure this out. But at the moment, we're
just because it's only nine, can I do this manually,
which is quite nice. So I'm gonna drag out CPU
choice, get CPU choice. I'm gonna switch one
set of choices again. I'm going to move
this into here. Because once we've
got our choice, we've go in and figure out what happens with the CPU choice. I'm just going to copy this. Copy it one more time, because we're going to do
this three times. One for each of
these. Nice and easy. And now we want to win
it, attach our win state. So that's our win state
in each of these. And it's got L. If
I just do this, then I'll be a bit quicker. I need one more. Went to sleep. While I'm here, I'm going
to use this time just to comment each of these, just so you can understand
the flow better. And we can always
look back at this. I would like to eat to
look a little bit nicer. I won't lie. I am very much a little
bit of a snob when it comes to how my
blueprints are lined up. I don't like spaghetti
as much as I can. A lot of times when
you're working quite quick, spaghetti happens. It's just the light weight of this works, and
I'm just gonna o. Okay, yeah. Now let's start
adding some comments here. So I'm going to
add first common. This is going to be day goes. Step One, which requires. And not what I wanted.
Let's move out. Do decide outcome on let's decide outcome
on CPU or CPU. And now we're going to
kind of go for chill. So if I chose rock and the CPU chose rock,
I'm going to draw. If I chose rock and CPU
use paper, I loose. And in rock versus
scissors, win. Now, paper versus rock
win paper versus paper, draw, paper versus
scissors, lose. And there is some numerical
version you could do here. For example, you
could easily get out the draws quite
quickly by saying, Is this choice the same
as the CPU choice? And if it is, instantly
say it's a draw. And then you could Idytic
do if you change that, you got to figure out
which one's going to win. So you could do if
it's not the number, uh you got to figure
out to offer it. Yeah, it starts to get a
little bit more complicated, but that's not what we got
to worry about right now. So scissors versus rock, lose, scissors versus paper, win and scissors
versus scissors jaw. So right now, we actually have the entire logic all
built up right here. All built up right here. Nice and easy. And we could even test this out if you really
wanted to right now, but we're going to actually
go away and make first off, make some UI towards this. Actually, no. We could
test out right now, but remember, we don't
have any CPU choice, so we're actually
going to go away and make a function which decides
for CPU choice for us, which is going to be quite easy because it's what you've just got to get a random
choice, haven't we? So what I'm gonna do is
make a new function, so I'm gonna call this
F, underscore, get CPU. And all it's going to do is
it's going to set CPU choice. And how we're going to set this? We're gonna use something
called a select node. I love select nodes. Select notes are fantastic.
I use select nodes in my job all the
time in prototyping. And what it does is it takes
something called a wildcard. Now what a wildcard it
is is an ability for a functional method to accept any class or object
type which should work. So this allows us to put
a lot of stuff in here. For example, you can
change us round. And I'm going to leave I'm going to leave integer as that. And then we can add
as many as you want. So we've got three
different choices here. So rock, paper, and scissors. And now what we want to do is kind of get a random
number between zero, one or two to kind of choose which one
of these numbers is. And we can easily do this. Using a node called Rand, It farm ranch get a
maximum max and the mint, this is exclusive, meaning that zero and zero are still
going to be used. But if we set this to two, this is actually inclusive, which means that
the ending numbers are actually included
in the range, where if it was exclusive, it would actually only
ever come back one because it's not including zero and
two, which means it's one. But yeah, because
this is inclusive, it means that it will choose a number between option zero, option one or option two. Because we've got three choices we always have to remember that we're actually using base ten, and we're counting from zero, which means that zero
equals one, one equals two. That's why we do zero, one, two, instead of one, two, three. If you wanted two, we
could do one, two, three, but it would mean
that option zero would never, never get caught. So now we have
this little bit of a function where all this does is whenever
this gets called, it sets CPU choices as
one of these free things. And now we can actually
move this out a little bit. Set CPU choice. Oh, sorry, one, two F t CPU choice. Pop this in here, and
we're actually going to rename somebody's comments. Step one. Gonna turn to step two and then step two
is going to turn to step. Three because step one is to. One set CPU. ***. We're setting that right after. And we're going to come into that a little bit
later why are we going to do that. But
it's nice and easy. Wat happens now is whenever
this event gets called, the CPU will choose a new one. Basically, this
variable gets changed, and then we go through the
logic on who's going to win. So now we need to make sure
or we need to get a situation where we are able to choose one of these
free things here. So we're going to do that
by making some nice UI. So let's go into Content. Let's make a new
content folder called UI and let's make a UI. And we're just going
to make one this time, so it's gonna be called. BP underscore base
UI. Open up for me. What we need to do is
add a lovely panel, which is the Canvas panel. And we're going to organize it a little bit for ourselves now. So we're going to get a
let's get another panel. Let's use a Let's
get a vertical box, which I and the toggle it
right to the bottom corner. We're gonna toggle to
the bottom corneer, and we're gonna
have three buttons in it. Gonna drag one button. Two buttons. Three
buttons. Nice and easy. Each of these buttons are
going to have some texting, so we're going to drag
text into that one, drag a text into this one and then drag a text into that one. And while we're here
in our vertical box, click size the content, it will come up for us. While we're also here, we
could actually play around a little bit with
how these work. So first things first, we need to make sure all of these buttons are
set to bearable. We also don't need
to name these butts, so let's name the top
one, rock and score. Nothing. Set the second
one to rock paper. The scot. Button. And the last will be
scissors sco button. We should actually add
some text in here as well. So let's just go into this
it's called this rock. Paper. Theiss. Nice and easy. We've got
these little bits here. And now you can see these
buttons are kind of together. So the way we can actually do
that is within our button, you'll come up with
something called padding. Because we're in a box such as a vertical or horizontal box,
it'll come up with padding. So what I'm going to
do is I'm going to click all three
of these buttons, and I'm going to set the
padding for the top to be five and the bottom
also to be five. So now you get this
little bit of separation, which is nice and easy, which is fairly quite nice.
I quite like that. The last thing we
do need before we add some logic is
a big text block. We're going to set this
to the top middle. I'm going to set the
positions back to zero. I'm going to set this
to be a variable? We're going to call this
results underscore. Let's set our alignment to 0.5, and let's set our
alignment to minus three. Let's go minus four. So it's
at the top at the moment. Well, we should make this
a little bit bigger. So what we're going
to do is I'm going to go onto font set this to 64, and I'm going to make sure my trustification
is in the center, so it's nice in the
middle of the screen. I'm also, right now,
for our own use, I'm going to delete this because when we start
doing the logic, we're going to set a text after the winner has been selected, which means that when the
first time we play this game, it's going to say, enter text at the top,
which we don't want. So let's go on to our graph, and we're going to delete this. Oh I'm going to do is I'm going to grab one I
button. Let's go rock. And we're going
to do on clicked. Now, these are some
events nClicked is when it's called
pressed is when it's pressed down and
release is when it's released when the button
is released afterwards. Hovd and unharvd means
that you can add some logic if our
mouse hovs over it. I'm going to use the word
clicked because that is just when the button
is officially clicked. What we do is get gain mode. The reason is because we
actually added our logic of the game deciding who's
winning in the game mode, we can get the game mode
of wherever we want. And what we're going to do
is cast to RPS game mode. BP's RPS game. And what we want to do is
call our event we just made. Hi winner. And because
we're on the rock button, we want to make sure that
selection is set to rock. And then afterwards, we
want to get our resorts text set text under
a brackets text. And then we want to accept the results of the
result of a text. So what we can do is do
what we can do, sorry. What we can do is
then get win state. We can then because
you'll see it says, enum is not compatible
multiple text. What we can do is we can
do a num two string. We don't want to do two string
byte because what would that to turn is actually
the numbers zero, one, two instead of the
actual name of the uh Until have the actual name
of it E number display it. So what we're going to
do is um to string. So it turns user friendly
name of enumerator, and then it's going to
pop straight to string. Now, we want to do
this three more times, sorry, we want to do
this two more times. So I'm just gonna drag
that copy, paste twice. And what we can do for each
of these now is paper. Let's just click
clicks, pop it in. This time, it's gonna be
paper. And then scissors. Oh, so silly meat. Scissors. Pop in here. Make make sure that's scissors. Let's add some comments in here. So button, logic. And then I'm going to make
it a little bit taller because then I'm gonna
dominate each of these. So this one's gonna be cold. All the comments always get me a little bit. There you go. Brock. Paper. And then my last. Have I been spelling? No, DN so we now know a living more. So, yeah, now all we need to
do is add the UI pops up. So open up BP RPS game
mode one more time, and I'm going to do
event begin play. And on event begin play, we're going to drag
out create Widget. That widget is going
to be BP BUI and then I'm going to you put. Now, with it Unreal,
whenever you click plate, it will normally remove your mouse cursor because a lot of times when you're
playing it unreal, it thinks, you know, the
mouse is going to be a look, orals gonna be an axis. It doesn't automatically expect you to need to use
your mouse cursor. So what we're
actually going to do is we're going to get
our player controller. And we're gonna drag
out from that and use we're going to do
show mouse cursor. And he's gonna say set
show mouse cursor. I'm going to set up to how. So it will show
the mouse cursor. Now we can click Compile. And if you play it, it'll call up a game that
says, paper scissors. And let's say I choose rock. Yeah, mostly chose rock as well. It's choose scissors.
Ah, we've lost. And if we choose paper,
we lost again. We won. Can we actually win one?
Every time I click Rock. Hey, you're our
family one month. But now in the next lessons,
we're going to go overhand. We can refine this and we can flesh out this game to be
a little bit more than just free buttons and some screen and a
text on the screen.
4. TurnBased: Further UI And Streaks: So we've got this game where I kind of just
says who we are. What's happened. Let's
add a little bit more UI. Let's add a couple more
features to kind of flash out this idea before we go into trying to make the
CPU's choice a little bit more dynamic
based on past choices. So what we want to do is
let's open up our UI. What? So we've got our UI open. And what we want to do
actually, add some more text around our resort texts. And the way we're gonna
do it is instead of just adding it on there and
hoping that it'll stay, we're gonna grab a vertical
box and pop up the middle, pop up top center. Let's position that zero, zero, and alignment 0.5 down, but a sized content because
it's not in at the moment. We're just going to drag
our resort text into that. That'll look nice. And then let's add two more text boxes. We're going to add one for
what the actual choices were, if it was rock paper scissors, rock or scissors or whatever. And we're going to
add a second one for your counting of streak. I always really like
adding stuff like like street counters to kind of incentivize the players to
try to get a higher number. We're going from making some rock paper scissors to maybe making a game
where people can go, Oh, I got this many in a row right or I got this
many in a row wrong. So it's going to be quite nice. And what I'm going to do is a little bit of formatting here. I really like to have
my streak counter. I'm going to have it justification on the
right this time. I'm also going to set
it to maybe a light, and I'm going to have
this I'm just going streak let's call it
win counter win streak. There you go. We'll
actually add a second. We're going to add
even a third one here. We're gonna do one
right at the top. And that's going to be again. Light, we're going
to call this one. Let's call this one best Greek. Text. It's a variable,
justification that side. I'm going to set the
text to this to be, I don't know, 12, so
it's quite small. I'm going to set the
text this one to be 16. And let's set this one have. Let's just have regular and we'll even set
this one to be bigger. Let's go for one,
two, eight big. We can set this to be to. This is all up to kind of
you to deal with right now. This will also be
aligned in the center. So we're going to have the
important information aligned, and then we could
have this stuff, which is probably arguably not a massive part right there. So I'm going to set
this texts to be called space, the space. You can see it's
this versus this. And it's going to be called
Choices. It's called text. We've set this to be a variable, and we'll make sure
our Windstreak texts also wine underscore test. I've set this test just so
I can know where it is. And then best. Test. Okay. So we got this
nice little bit. So let's start adding some actually information
to this, I guess. So, let's go. Let's go and so
the choices first. I think the choices
are probably the easiest one to do first. So let's go and let's
make a new function. We can make functions within UI. They're much like a
bluefin class just to have some fancy stuff
attached to it. So let's make a new function, and we're going to call this F. That's Okay. And what this is going
to do is this is going to get the choices, and it's going to kind of
output this off of some sort. So I'm going to set
two new inputs, and I'm going to do both
of them are the same, will be E attack races. And we'll do that
side. And the first one's going to be
called players. And in the second one
will be called CPU. Yeah. Because
what's gonna happen is what we're going to do is
when we call this function, it's just going to
grab our choice text. It's going to set the text. And it's going to make us
a little look a lot nicer. What we do is I'm going to grab. Put this, do a two text. They're going to
use a string note. Because I'm going to
their news a pen. Sometimes working backwards
is a little bit easier, so I know that I need to
use this apple conversion. A lot of times, if you just grab your append and put
it straight in there, it will do the
automatic conversion. It's always good
to start learning about the different conversions. I'm going to drag
this into that. Because the E umdaString
returns a phony name, we can just drag it straight in. But the slight issue is here, it's just going to now
give us two names. So I'm going to
actually the tus part, make an extra pin and
then put space S space. So we have that formatting, so that's what this is space, space, whatever this is. Compile and save. Let's go
back to our bent graph. And let's pop this. Should we pop this
this bit further. We can actually bring
this right after the text because it doesn't
really matter. Where about it is, as long as it's kind of after the pick winner because that's
where the CPU choices set. So I'm going to
do F set choices. And we can select
the player's choice. I'm going to pop each
of these on the end. So, yeah, we could
just make this into an event and then have these selections have the
player selection as an input, which automatically sets these. And that would be easier. Definitely, if we were having
more than free choices, that is what I would do in
this quite linear game. But it's nice and easy in a disc version just to kind
of do this three times. You know, it helps us with our
blue frene helps us learn. And it kind of helps us guide
ourselves knowing how to, how to how this
game logic works. So, let's finish this pop bit. So we're going to set
the player's choice. So this should be scissors. This should be paper,
and this should be rock. And then we need to
get the CPU choice. Luckily, we've already
got the CPU so we can get CPU choice. Just pop that
straight into that. I'm going to do that
three times in a boat. And we can instantly test this because we don't need
to add it back onto it. We can just click Save, compile. I've got it bring
up as a new window. So if I click now,
and let's do rock, it tells me I lost because
it was Rock Cross paper. Obviously, paper beats rock. If I did rock again, oh, no, it's got Rock
Cross paper again. Keeps doing Rock Cross paper. Ah. Now, this is something we're going to solve in the next
session when we start changing and modifying the likelihoods of
things popping up. But right now, this is
what works perfectly fine. So let's get back on to doing
Winstrex and Best tricks. And the way I actually
need to do this is by going back into
the game mode for this. So let's open up our game mode, and let's go into
our bent graph. And you'll see we've
got all this bit here. All I want to do now is
make two new variables. First one is gonna be
called current streak, which is going to be a integer because you can't have a
point in one of a streak. There's no point to use a float, and we're going to
have best streak. And every time we
see this set to win, I'm going to go on
to Comment streak. I'm just going to do
roughness. Nice and easy. Every time shut you couldn't even copy this.
Every time this wins. Let's go add this on the end. We could just add them
all up to the same part, but we're not going to do that. And every time this
streak changes, we're going to get best streak, and we're going to compare this. This is greater than
our best streak. Then we're going to do a branch. Actually, let's
do a little acta. If this so a selector
node is really good. We're using the
selector node again. This time we're going to
use it with a boolin. So if current streak is
better than our best streak, I'm just going to What
we're going to do is we're going to attach
this value today. It's a bit Crisscross
and that value today, which means afterwards, we're
gonna set our best trick. This means that there's
no split execution here. I'm just gonna grab this.
We're gonna copy it and paste. So let's just kind of
look at this again, explain what's going off here. This select node, we'll grab
one of these two values. So that goes into the true. Meaning that, so we'll select one of these
two values based on this statement or
condition here, and then set the best
streak accordingly. Meaning that if this
current streak, once it's been added one is bigger than what
our best streak is, then set best streak
to be the true value, which is the new streak. If it isn't, so
it's a false value, which is still the best streak. And now we need to go on
to here and then set this. So we could do a bind here, but there's no point of doing a bind because this value is this value is only going to change when
we press a button. So instead of
getting this checks every frame or every
time binding refreshes, we're just going to add it
onto Vet logic at the end. Again, we're only making this
actually a little bit more. We're only adding to the idea of making this into one event. We're going to add a little
bit more logic by the end. So we're going to call this
F underscore up late streak. And what all this is going
to do is we're going to get this game
mode. Let's cast. Cast to cheat leads. Lets us cast to game mode. Nice and cast. And
then we're going to get that streak, we're
going to get current streak. And then we use these
to propagate the texts. So current streak, whereas Wen streak was
called Win streak. Get Text. And we're going
to do a pen node. So and then we're
going to put a string, it pops up and it will say W streak and back to that a
lot of conversions going on. A lot of a lot of UI. It's always probably best to news the correct
formats when you can. And then we'll do it
again this time with our streak text. Streak text. But in here. We can
even grab this again. Both is Wop that in there. And then what did
the best streak say? Best streak. Pop
that into there. They've compile, and then we can just back in
our event graph, add this update street
text right at the end. And then with that,
we should have added a little bit
more Information, Rock drew may not getting that. We lost. This Rock, Paper. We've got one. We won again. That's
actually kind of impressive. We won three times in a row. We won four times in a row. We won five times in a row. We drew. We lost. But our win streak
is not going down. That's because we
have not reset it, which means that
anytime we lose, we probably should get
our current streak and just set it to zero again. Do that every time.
We can be nice here, and when you draw, we're gonna class that
as a null state, which means that we're not
gonna wipe the streak there. I think it would be
a bit unfair. If you play rock papers
as the sides of, and you draw, you
just play again. And now we have Rock
papers this game. Yes, I've got one.
Oh I'm on two. Free. Was. And now you see how win streak is
zero, our best streak is free. Okay. Next time, I'll see you to start modifying chances.
I'll see you next one.
5. TurnBased: Changing Weights: Well, now, let's do some fun with the weighting
of the CPU choice. Cause at the moment,
it's basically I wouldn't say a flip of a coin, but a flip of a freeway
coin each time, which kind of normally means that every time it clicks off, it's gonna be a different time. But what it does
lead to be sometimes is it means that if you
click the button five times, there is a complete
chance that that happens. You know, it's a 33.3%
split each time. So I click paper again.
I might be scissors. But in our minds, because we've had paper we've
had scissors and paper, it should be rock next, right? It is. That's crazy. But
it goes back to scissors, rock, paper, paper
twice in a row. Rock, rock twice in a row, you know, scissors twice in
a row, paper twice in a row. And eventually, if I just
kept clicking this button, we would get to a
stage where, you know, a chance comes over, you know, we've just kept
clicking this button and our best streak is six. So we want to kind of maybe modify how the CPU
makes us choice. We can do some really simple
stuff by just changing the percentage or the splits
within the selections. And now this is where
kind of where like some game design competition
comes in because we're going to maybe add some stuff which you might not agree with, and we might add some stuff
which you like the idea of. This is kind of up to you
to start thinking about how you want to make the CPU. So let's go into our CPU, and let's go into Funk
get CPU joys function. Now this is 33.3. If I had another pin, each
one is then split to 25%. Then it's 20%, then
it's like 16%. Yeah keeps getting
higher and higher. You know, I've got nine now it's 10% each time. Gets
lower and lower. You can always
remove Ds, as well, but How do I remove a pin? It's a variable.
Remove Option pin, yeah. Right click on this. Remove option pin.
So upset it to Dow set it to have nine
different options. Now, if we just did Yeah. So because we now got
nine different options, each one needs
equivalent to 1.1, one, one, one percentage. But if we set it up
this way, though, it says rock papers t's set
the first free to rock, that's the next free
to scissors paper or so and then let's set the
last one to scissors. What actually happens is what we again have is actually
a 3% split each time. But if we change one of them, or let's say we
added a third one, which was a dynamic choice, we didn't start to kind
of modify the choices, maybe ever so slightly, but enough to maybe
make some difference or enough to maybe remove some weird anomalies that might happen with just
pure random choice. So let's add. Again, because we now
got an option numb nine, we need to make sure
this is number nine. And let's add a
select note here. So we're going into a sillouette we add this to our
turn pin here, it'll automatically propagate
with these fruit choices. So let's press that
paper scissors. Now, let's try and stop the player bomb but let's try and make sure the CPU doesn't make the same
choice twice in a row. Now, it's perfectly logical
to do that if a person has if a person if a
CPU makes a choice, it might want to make
that choice again, but it might be a little bit more wary to do it
the second time round. So here's what I'm gonna
do. I'm going to grab CPU choice because if we go
back to our event graph, we get CPU choice and
set the CPU choice here. When we grab CPU choice now, it will actually be
the prior choice, whatever it is before
we set it again, which means that if you
plug this into here, it's making a decision
based on the last round. If we set this after this set, then it's making a decision
on the round which we've just done or the current round, which we don't want to do. But we are now making decision
based on this choice. Let's say that the CPU has
a slight higher chance to pick the counter to the
choice it made last time. So rock would then
counted by paper. Paper is counted by
scissors, and that's rock. Which now means that we
have a 30% chance rock, 30% chance for paper, 30% chance for scissors, and an extra 10% chance to any to the counter of
the last choice, okay? You could probably see this now. So if I click Rock,
they use rock. There's a higher chance
now they will use paper. There is a There is a 40%
chance they'll use paper Neck. So if I use scissors,
I won. I know that. I know that's the chance. They used paper last time today. Probably you're going
to use scissors. I'm going to use rock.
They use paper again. Yeah, so players are
now more likely to know the system is going to try
and manipulate that idea. But the player doesn't
know how the system work. This game works, and if no one tells them, it's
not going to find out. That's let's be honest about it. But we can start adding
layers onto this. And the more layers
we get onto it, the more complex decisions
and choices CPU X. But the more complex season, the more elements we add that
influence the BCP's choice. Realistically, the
more more complex. The more complex
it's going to be. So, let's add another one. Let's go for it's going
to make another choice. That's gonna add a ten here. Let's go with the idea
that it's not going. It's going to try and counter
the player's last choice. So let's grab one of these, pop it in here. And now we've got to figure out a way to know what a
player's last choices. Now, a really easy way to find what a player's
last choices is to, I don't know, have a bearable. So let's promote this
to the variable. We're going to do cords. Players last choices. And we're going to set this
to be done after the CPU. I'm going to give you a
second to think about why this is going to be
set after the CPU choice. The reason we're going
to set this after CPU is if we said it before, it means that the CPU already knows what you're
going to do it and has a higher chance to
counter your choice. Now, that is cheating, in a way. If you know what the
player was going to pick before you picked it, you're always going
to counter that. Now, obviously, this doesn't mean that every time
you're going to lose, but it does mean now there is a higher chance the
player would lose. So if we said it afterwards, the players CPU doesn't know about what your
current choices. I only remembers what
your last choice is. So now we have
players last choice. Pop listen here. So again, if it's going to use
rock, it's going to go, Oh, use rock last time, maybe I should use paper. Maybe I should do scss.
Maybe I should use rock. So again, now this
adds an extra 10%. So now we've got actually,
this is not a 10%. It adds an extra It adds a 0.9, so like a 9% something very
similar or is it a 9% chance, if that may be a little
bit more, meaning that. 9.0 0.00 901, I want to say, or suing something like
that. Recurring number. But yeah, it means that
each one is a 0.9. If a player if the thing
true is rock last time, it's going to have a you're going to have a 9%
higher chance to do paper. But if you chose
paper last time, it's going to have a 9%
more chance to do scissors, mean that the thing it's probably not going
to do is rock again. But this is how we
had some complexity, and now we're getting
something called. We're getting
something called Oh. We're getting something
called average averages on multiple probabilities, which means that we really don't know what we're going to get. I think I think if you use the
averages of probabilities, you're actually going to
find out this is a rating of 20%, 33.3, 33.3 maybe. I think that is for
chance. Maybe a little bit less.
I might be wrong. But these are really
some long math, and right now we just
know that two of Ds have a higher chance or one of these or two of Ds have a higher chance to be choosing. So, again, if I choose Rock, that's now got a little bit higher a chance
to choose paper. But it's also got a little bit of a higher chance
to use scissors, which means I know this, which means that h, actually, I don't know
which I should use. That's go for scissors. Hey, you got scissors
Where is paper? Paper. Oh, we got two in
a moment. Ah, we lost. And it now does mean
that it's probably more likely or less
likely we're going to get that six streak by
just pressing it because there is some there
is some chance here. What I like to do is then add an even higher chance to and this is going to
be the last one we're gonna do today is a higher
chance to have, sorry. What I like to do is then
add some, I don't know, some fail safe that if I'm
just constantly clicking, it's got a higher chance just go against what I'm doing.
So I'm gonna call this. I'm gonna add, yeah,
a new variable. It's gonna cad same counter. Let's go fail. Hello. What should we call it? Let's call it? Uh repeat check. I'm gonna call it an Int.
I'm gonna have an int here. What it's gonna do
is when it sets for CPU choice, I'm gonna get this. I'm gonna get players as choice. Uh oh, no, yeah. I'm gonna get players last tous. Now, before it does this, Yeah. So I'm gonna get
players last choice. And before it's got
players last choice, it's going to get
players last choice, and it is equal to this. Oh, no. No. Yeah, sorry. You have to make sure
you're using the enum. So what we're gonna do is
get plays last choice. Equal. Make sure it's enum,
and then the same here. Now, if it is, I'm going
to just do a branch. Let's do a branch here. If it's false,
we'll just move on. But if it is, we're just
going to do a repeat check. Plus one. You threw
it incrementally. And if it isn't, we're going
to set repeat check zero. Let's spread this out so
it looks a little bit nicer now. So we're
going to get that. We're gonna pop this
back in to there. But basically, if There again. If if the player keeps
making the same choice, this is going to get higher
and higher each time, right? Meaning that we now
have some sort of way to actually start changing this way more dynamically. So what
am I going to do? I'm going to grab players last choice. We're
gonna do this Weg. Actually, no, we
don't even need to do this again. We can just pop. Let's pop this add pin
a couple of times. Let's just pop this in here. 'cause this is countering the player's last choice, right? Meaning that we have option ten, and we're going
to have that ten. So it's automatically going
to have a little bit of bias towards what the
players last choice. But if I get the repeat check
and I do bush, that means. And we're gonna also let's
just cap, what's it called? Clamp in putre to 16 because we don't
want to get any higher. But that means that if I use the same thing five times in
a row, six times in a row, I then have the CPU has such a higher chance
to counter me, which then is gonna
force me to do something different.
You're gonna see this. If I click Play, I just
keep going Rock, lose, eventually it's just going to constantly kind of lose with me because it knows that
I'm going to do it. But if I see this. You know, every few times, it resets that check, and it goes back to that number. We can even see this in action. I'm going to show
you some really, really cool way of
debugging in engine. So if I open up while playing, I can click this
little button here. Bond. Let's go back to here. Let's watch this value
here, so watch this value. So we're watching repeat check. Every time let's reset it. Every time I click
Rock, it's going up. Which then leads to
a higher chance. And here, repeat check is
16 plus ten equals 26, and it caps at 16, which means that all of these chances here
have a higher chance. And once I reset it, it goes back down
to the normal ten. Now, that is just some really, really quick ways I've added waiting added a little bit more of failsafes
into this game. With that, we have hit a stage
where I think we can now move on and start
making this game look a little bit nicer
and flesh it out, so it looks a little
bit different. Okay, so I'll see
you in the next one.
6. TurnBased: Adding Characters and Animation: Okay, so, welcome back. This is going to be an interesting
one because we're not actually adding much
more functionality to the game when it
comes to gameplay. We're actually going to start
making this game look a little bit nicer in that way. So, first off, let's
make a new arena. This is the first time
I'm gonna probably make anything to do with, like, actual maps, which
isn't just a black screen. So it's a bit nice bit. But the way I'm
going to do it is I first want to make a skybox, and I'm going to make
a really, really quick skybox by just basically
adding two different things. Now, when the Visual
Effects panel of your Place Actors panel, if you don't have that,
please just click on. This little one
here, Place actors. What we're going to
do is we're going to go on Visual effect. I'm going to add something
called sky atmosphere and exponential Fog. Now, at the moment,
these were look too different. But that's fine. This is a really nice,
easy, fast way of doing it. And I'm going to add a
few different lights. They're going to be the
two directional lights go. So when I drag a
directional light in, you're going to
see instantly sky and atmosphere, which is
going to be really good. I'm going then to
add a second one. So I'm going to do this by realistically. Just rotating it. So you see this is looking
downwards at the moment. I'm then also going
to add a second one, which is clicking rotate. We holding the key
rotating this way. But I'm going to set this
intensity to be half. Let's set up to five. I'm
also going to go into do forward shaded priority. Just go to set to one. So we get kind of a
pretty lit up area, which is universally lit, but Doc stronger than one way to kind of showcase
the sun, in a way. We could, in a way,
have it set to it. His sun is lined up to it, but it's not really
our issue right now. We not caring too much. And we're going to then add
an arena. I'm going to. Let's add a geometry. Let's add a box to it. Let's go zero, zero, zero. I'm gonna set it to
transform of zero, zero, zero brush settings. We're going to set this to be 1,500 on BX and 1,500 the Y. Good job. Nice and easy. So now we have a little
environment to make a fight in. So, let's now start adding some characters
to have a fight in. So we made a rock
quipersuzs game. We actually we're going to change this from a
rock quiperz game to maybe like a slight
dueling game of some sort. We want a character to fight while we play
rock quipus sisters. So we need to make a few things. We're going to need
to make an actor. And again you also need to
import some animations. Now, if you want to know where I got
these animations from, there'll be a lesson in the introduction panel
or the auxiliary panel, which goes over something called Miximo which is a adobe product, which is completely free to use. And you have
basically a resource of humanoid skeletons with some base animation you can use. If you don't want to go
into that, you can actually just download the zip file, which I've got below
the lesson right now, which is going to
have all the stuff we have in this folder. All the stuff we have in this folder, which
is what we need. So, what I'm going to do, right click, I'm going to make a new folder called assets. And in this new
folder, I'm going to have I'm going to
import our stuff. So the first thing I
want to import from this folder is the bot. This is the actual character
mesh with read up skeleton. There's no animations attached to this. I'm gonna drag this in. It's going to come up with
this lovely little bit here. We're going to make sure it's
skeleton mesh, Import mesh. Skeletons set to
nothing because it's currently got an
nothing on there. We don't need to import any
animations at the moment. I'm going to click input.
Click and put all this. I'm gonna make any
difference. It's going to sound say there's
no smoothing groups. Don't worry about
that right now. And it's going to
come up with this. I'm actually going
to make this into folder and call this C mesh, and attach all this in. So it's going to have some
two different materials, which if you wanted to, we could make instance to these
and change them. Or I think they're actually
just some base colors. So yeah, base colors here, so we could change
them if you want. And it's going to go up a
skeleton mesh, a physics asset. So if we wanted to add some
rag dolling to it, we could. If we click Play a Ragdoll, which simulate goes down. We could, if we want to do
what we're not going to do. And we got a skeleton, which is actually where
Albi animation data is going to be
using the skeleton. So now let's add our animations. So in our C mesh, I'm
going to add a new one called the mesh nim.
And what we can do? Because we've now imported
that mesh and skeleton, we can now drag all of
these in at the same time. We just go to make
sure our skeleton is attached to the one
we just found and then import. It
will do sometime. Draw will go down,
and now you'll see we have some animations
here with Diskelton. We now just want
to actually make a character actor to do
these and to complete. So let's go on to
make a new blueprint. This is going to be the
next Blueprint new made. Sorry, right click
Blueprint class actor. It's gonna be called
BP underscore. He, let's do Carrot
underscore, Actor. Nice and easy. This is the class we're going to
showcase our character. And what we're going
to do, we're going to instantly add a skeleton mesh. And we're going to need
to add a skeletons act, which means that we
need to click on this button here and
click at our pot. Nice and big. Don't worry about it. We
should probably rotate it characters in this game should always be
attached to 90 degrees. They should always
be looking this way. And we shouldn't worry. We can also while we're at it, if you click on here, you'll have some animation
data already in there. So if you click
on skeleton Mesh, you'll see animation, we're going to set this
to animation asset. We could make an entire new
blueprint to control this, but we're actually
going to control these meshes just within this. We could go really far into this and instead of
using these assets, we could make an animation
blueprint to figure it out. But we're just going to
use animation assets for this nice and simple
introduction to Unreal. So beam to play, I'm going to automatically
add fight Idol because I want my characters to be just idling at the start. I'm going to add a camera. So let's add a camera to this. We want to make sure it's
attached to our skeleton mesh. We're gonna kind of drag
this out a little bit. So I'm gonna set this to
probably around about -100. Going to sell it probably -200. And then probably around 140. So we've got this over the
shoulder camera look the moment it was set to 90
degrees over the shoulder. And then we're going to go into our variables and right
click on this call layer. Question mark. We go to set the description
of this set through if this is a layer. This is basically because we're not actually
controlling this character. We're controlling
the game mode or this UI, which tells
the game mode, and the game mode is gonna
tell this character that, Hey, you go to play character. Because we're gonna have
two of these on the screen. If you don't have this ticks, it's gonna automatically
think this is the CPU. We want to make sure
this is exposed and spawn, instant set. Nice and easy. You can add
some other stuff to it, but you don't have to
worry. Compile and save. What we should do is
in the event graph, once this begins play. And what we're
going to do is grab my play character
and do a branch. If you just press P, you know, come up with a branch,
doing a branch. Now, if it's the
play controller, we want to set the camera
of the world to this one. So I'm going to do yet
player controller. And we're going to drag out
here and do up and god set, you target it with blank. Now, this is a powerful node which gets the play controller, which will be a default
play controller, and then changes the camera to whatever camera
it wants to be. So we can't actually
put this in here. It needs to be an actor object. So we're going to do
set, let's do south. Because a camera
can only have one, we're going to just
grab this one. Bam, bam, nice and easy. This now means if I put the character into the world and set this to be
play character, we click Play, you see,
now we get this far. So while we're at it, actually, let's set up a fight scene. So let's set one here. That's one now, and let's
get in the second one. I'm going to Alt, drag it out. I'm going to make sure this
play character set to false. Let's drag this out. Actually, we don't really need to know what it looks like. We just need to know what it
looks like on our screen. So this one here, I'm
going to click the pin. An it's gonna bring
that one out. We're gonna bring this
forward, bring this forward. We could be really close here. Because of the way FOV works,
we can be quite close. We could even rotate. We
could rotate if we needed. Let's rotate this one. Rotate this guy. I
think that works. I think we get this a
little bit look here. We could reduce
the field of view. But right now, we
have some space. It's really important
that we leave space up top and at the right because that's where
our buttons are, and that's where our
text information is. But we have this nice
square bit here. So let's start adding
some logic to this. So let's go in and make
a new event called. Events going to be
called Setlay animation. The reason why I'm
going to call it second play is
actually there was an event or function called
play animation already. What we're going to
do is this is going to have two different inputs. It's going to. The
first one is going to be called attack. Choice. And the second one
is going to be called win. And obviously, this is
going to be attack Choice. Win dates and which
is gonna handy. We're going to use
this to decide which animation
we're going to use. So we're going to
drag out from here, we're gonna do play animation. It's gonna say play
animation, skeleton mesh. It's gonna ask what
animation to set. And what we're gonna do is
we're going to drag out from here actually select. We're using a lot of select
nodes in this prototype. Obviously, when all these
prototypes are taken from actual projects done in the schools I
used to work in, uh so this entire
project was about using select nodes and logic and if statements and
selection of information. So we now need to put
our attack choice in, and we're going to set
what player animation should do when we use an attack. So if we're using rock, I feel like rock is a punch, so I'm going to use punch. I feel like paper is
like a magic attack, and then scissors
is like a kick. We're not here. And
then we're not going to loop because we just
want it to do at once. What we should
really do is see how long our animations are. There is a way we could use something called play montages, but that would require
a lot more setup because it would require
a blueprint to do, where it would actually
allow us to do it at the end of it will allow us to know when the end
of the animation is. But if we just go into
Standing two H magic, we see this is we
can even ft FPS. We can even we see that is all of these are
let's have many frames. This is 43 frames, which would be just
over a second. This is 129 frames, which is what would
actually be about two. If we do it at 35 second, that's 3 seconds long. 4 seconds long, actually, and
this one is about a second. So realistically, we could
probably do 2 seconds here. Let's try and average that
out. So we go in here. We're going to do a delay
node afterwards, delay, and then do 2 seconds. And
then we're going to decide. Then we need to figure
out, are we to play a character, are we not
to play a character. And we could do this for
two different methods here. We could either do a branch or we could do a two
different selects. And I'm going to
do a branch here. Let's No, no, no, no,
no, let's do a select. Let's do a select. I like to change my mind. We can
do play animation. You're gonna pop listen to hear. The first thing
that's going to do is get a play character if
it's a play character. Now, if it is the
play character, and we get we're gonna drag our in what am I
doing. Okay, yeah. What we're going to
do is we're going to do a Braanchia and we're going to drag our
play character because our win state is always
going to be the same. If I win, it's always going to be from the player's
point of view. Meaning that if a
player if a CPU loses, it's gonna say it's win, and we want to set that
to be different. So I'm going to do a select. I'm gonna drag out
a wildcard win, draw, loss, nice and easy. We're gonna do play
animation again. I'm gonna do this twice. Okay. So we're gonna need to do this select
twice, actually. Here we go. Now I've got this
little bit of a bit here. So if the player wins, so that's the player
character, it's true. The player wins, you
want to say it too, let's say, it's victory. If they lose, let's
say defeated. And then if they draw, let's
just go back to fight Idle. If the player wins, sorry, if the player this comes back as win because
it's the play character, this will be defeated
because it's the opposite, and this will come as
victory and this one will be whatever this is,
it's the opposite. And in the draw, it's
going to be the same. P, same. Now, now what we
need to do is go, Oh, what have I not done? I need to add skeleton mash up. We need to make sure
skeleton mash is attached. This is AV and we'll
start coming to this, so sex correct. Amer Animation battle. There you go. Animation
battle logic. If I click compound
that should work. Now we need to do a
little bit more work within the game mode, and then we're actually kind of done open up the game mode. And we need to do
one or two things. Well, let's go into Let's
make a new function. We're going to call this
F underscore set right. And we're going to get
the two characters in the world and store
them for information. So I'm going to get
actors R plus So, yeah, we're going to use get
all actors with class, and it's going to do the
BP underscore Caracor. It's really important
to make sure that we've set this before
we do anything else, now we can drag out from here
and do a four each loop. And what it's going
to do is it's going to go through this array. It's going to get a
collection of actors. It should only be
two. If there's more than two actors in the world, something's
gone wrong. You may have added
more than two, and this might not
work correctly. So we're going to
add a little bit of stuff to make sure
we the editor, we tell ourselves that, hey,
the games not working here. But what's going to go there, go through it is
going to look for the character which has
the player character. Variable or bully
and set to true, set that as the player
character within the game mode and set the
other one as the CPU, so it knows it can tie out which choice is done
and to each character. So I'm going to right
click promote a variable. I'm gonna set this one
to play a character. Oh, for some reason, that
doesn't want me to do that. Player character.
Yeah, now it did. Now it's copying and
paste that again. Oh, no, don't copy
and paste that again. Right click, promote
a variable again. We're going to call
this TPU character. And what we need to do is drag out from the array element. Yet player actor. And we're
going to do a branch. True. There we go. So what's
going to happen now is it's going to
go through this. It's going to figure out,
is it a play character? It's going to set that map,
and that's the way it goes. What I'm actually going
to do here is going to add some more information here. So I'm not going to
go in to complete it. I'm going to do
something that is valid. Is valid. I'm going to do this. If it is valid, that's good. I'm gonna do it twice. I don't think I can put two
things in that. No. I can only put one. Now, this is why we're doing
this is because if we finish this function and what happens is we don't have
a correct play character, we don't have a CPU character, the games not gonna work right. So what we're gonna do
is gonna do quit game. Twice. If it's not valid, quit the game. We can
test this out later. And it's valid, obviously,
don't worry, continue. If and what we're gonna do
here is put a print string. We're going to make sure this
is in our log and screen. We're going to add we
can't add a delay here. This is valid note. AracterRference. Check, check for character. On arcters. I'm gonna say it's
red, nice music. So now we know if we haven't
set one up correctly, it's going to first
tell us in our log, Hey, there was a check
this reference error. We even just call
it reference error. Oh, gosh, And now we know when we're sending
this game some issues. We can also do this
a few more times. So let's go into its valid. If we have this, let's
do this. Greater. If this number is
greater than two, let's say, one, one, we're
going to do the same. And all of these are just
something called validation. We're doing some
validation here. So, if this is greater,
we're going to go back. We're gonna do
another print string. When we're going to go
at two many characters. And make sure it's in log, put it in red. Bring
it back up again. These are things
that are going to quit the game and be like, because the games not
gonna work correctly. And it's going to be
one last bit here. We're gonna do it
in play character. And before we get
play character, we're going to get play
character. It's valid. What is valid does is
this an actual reference? At the moment, these
should be completely none. So it should mean the first
time this comes up as true, that should be completely false. That should be empty
and not valid, and it sets the play character. If it is, and this
is going, again, it means that there's too
many player character set. So we're going to
do print string. Too many player characters. Yeah. Again, let's get red Make sure it's printed to
log and then quit the game. So this is validation here, and this is really,
really handy. It does add a lot
of more issues, like a lot more logic here, but actually this is
going to help you in the long run purely just because if you make a mistake while editing
or you make a new level, and you're like, why
isn't this working? We've now got some
shoutouts in Apolog. We can even once we got this all hooked
up we can test it out. So let's go into our event graph and let's
pop set players into here. Compile and then play.
It works right now. That's fantastic. Let's go and take Copley character off.
Going to do, actually. Instead of the validation, what we're going to do just
before we actually save this is we're going to take away
the quick game just because it probably not
mean that it won't be enough time to
actually get it. So we're just going to come
up with the error instead. We're going to add
some own errors. So we click play reference
error, check the character. So if now I set them both
to play a character, check play say Bega. Too many character set. If I didn't add a third
too many play characters, so I just keep adding them.
You see what happens. Too many play character set,
too many play character set. It's coming up with
more and more errors. So again, this is a nice
way for us to make sure that we're not causing any
issues and lay a Meline. So we now just need to add this play animation
in the game mode. This is so easy to do. We're going to go
into our event graph. We're gonna tie these
all together at the Md. So I'm going to grab
out my play character, get player character and
do set and play Anim. I'm gonna drag them all
in. So I'm going to drag all these nodes in. Actually, what I'm going
to do pop this here and we can just pop all this
execution node into one. We could have this pop up at the end of each of them every time, but we're not going to. I want to make sure we
get all of them on there. We want to make sure all of
these lines are attached. Start to get a little
bit spaghetti. You can easily see
if you've ever done anything or talk to
anyone before about Blueprint. Blueprint spaghetti
is very common. And now we need to
our check choice. So luckily enough, we
have players last choice. We can just use that as our player's choice here so we can just patch that in here. And I'm going to do
Winste right into that. Again, we're going to
get our CPU character set and play Anim. And then instead of
players last choice, we're going to use CPU choice, and we can get Wednesday
more just pop Wednesday out again just for some
nicer way of doing. I want to click play,
compile, we've got no errors, click Rock, and we're now
fighting. We get a wingpp. We now have this lovely
little prototype, which realistically, it feels
like a little game now. It looks similar in veins
to a turn based battler to a monster game like Pokemon or you could even play a card game just
out of this style. You have set up like a way to make a battle arena
with two different players. You've learnt how to
do different chances. You learn how to do
some basic CPU choices. And with that, that is the end of the three prototypes
which I'm going to give you to help you learn not just the basics of
making gameplay unreal, but actually the
basics of game design, the basics of adding
some game logic. I'm hoping that
you've understood and learned that while
I've been doing this that I've been
trying to I've been sharing some experience
with making games before. Now, now you've completed this, you might want to go on
to the upcoming course, which is three more prototypes and a much more advanced one, which covers things like local multiplayer with
two controllers, covers stuff like dynamic
AI with behavior trees, as well as making a beloved
version of a Sony classic. Also, please keep an
eye on our discord, because there will
be live streams, which is taking one of
these free prototypes and expanding on it and making another game out of those out of the core framework
of that prototype. So please keep an eye on that. Anyway, it's been a
fantastic fantastic to have you with me for
these free prototypes, and I hope to see you
either again in one of our community events or in the next one.
I'll see you later.
7. Extra: Mixamo: Hi. This is the quick session, just to go over the
MiximoPlatform, which was included in the last session of the
rock paper scissors module. Now, what Mixmo is is
an Adobe products. It's part of the Adobe family, but it's completely free to use. I do believe if you want to use it in any commercial products, you may need to get
in contact with them, but it's completely free to use. All you need is a
free Adobe account. You do not need a
paid subscription. And what this does is has a set of skeletons with
meshes for you to use. You may notice the
Xbox skeleton, which is the default one, as well as a ton of animations
which have been synced to those skeleton,
which is fantastic. There is an ability
to actually rig up a skeleton you've
made within Miximo. It's not as intuitive as you would want
it to be sometimes. And when you're
doing prototypes, it's just a lot
easier just to grab one of these and then
attach it later on. But if you're wanting
to, I don't know, grab one of these characters
that you used with these animations, you
would do it in this way. So the first thing
I would do is I would select the
character I want. So if let's say I wanted
to grab mannequin, or let's go Megan sorry, because I don't want a new
body on there, I guess. So it will load up here. And the first thing you want
to do is click download. You need to make sure
it's TPOs and an FBX, and then you click download. It will download that file. It will download that
file in a second. CH 22 lists 22nd characters
in the list, non PBR. You need to import this file into Unreal before
you import any animations. It's really important
you do it that way. We went over that in the Rock paper scissors
character lesson, and I'm just going
over again with you. Now, if we wanted to
get some animations, it's as easy as kind of
one, two, three here. You have the character you've selected, you've downloaded. All I need to now do is let's
let's grab an animation. We can do a little
bit of changing. So let's say, if we didn't
feel like it worked for this, we could maybe add the range up, which gives it a little bit, or we could even
lower the range up, which just kind of extends or
incensuates the animation. You could even get
it to go quicker. Or you can extend arm space. If you want to trim it, you can do, and you can
use mirror if needed. And then you can click Daload. You want to do it without skin because you've already
downloaded the model. This will make it a lot quicker, and you'll click Dam load,
and it will do it that way. The only other thing you should probably be notable
for is if you're wanting to run
animation, have a look. Let's just search Run. You'll notice that it will
run out of the middle. With it unreal because we like to us stuff
like root motion. We want to make sure that
we're using in place, which means that the character is kind of just
running in place, and then we can add
the movement later. For example, if you
were making maybe a Pokemon battle style game, you could have it kind
of in place like that, in place turned off as you're having a
character stationary and it moves forward
and it moves back. You can mirror it
if needed, as well. But yeah, that is
a nice simple look over Mxmo platform. Hope
this has been useful.
8. Packaging And Exporting Project for feedback: So we've got to the
end of this class within making our quick
rapid prototypes, rock paper says a
turn base batter. We want to export this
out for yourself, but also to upload
Skillshare and get feedback from me
and other students. What we want to do is just check a few settings to make sure
when we package our game, it will play our game correctly. So the first thing we
should do is click on Edit and in project settings. We want to go on maps and modes, which is on the left side, and we want to make sure
our game default map is under our arena. This means when we open up our package project
and play the game, it opens a arena level. We can close this down now. We can click on platforms, windows, and we want to make
sure it's set to shipping. We can go down to Windows again and click Package Project. It will then ask me where I
want to package this project. I would recommend
making a new folder. Let's call it
packaged, turn faced. Paler open that up and
click Select Boulder, and it'll automatically
start packaging. I can click Output Log and
it'll go through this. This will take a while,
but once it's packaged, I would like you to upload
that to either Google Drive, OneDrive, or any other
file sharing platform you might use to then upload it to Skillshare for feedback. Can't wait to see what you do, and I'll see you in
the project files.