Game jam tips and tricks | Live from HQ | Inside Unreal

>>Victor: Hi, everyone,
and welcome to Inside Unreal, a weekly show where we
learn, explore, and celebrate everything unreal. I’m your host, Victor Brodin. And in the studio today, I have
Lead Engine Programmer Michael Noland.>>Michael: Hello. My name is Michael Noland. I’m going to talk a little bit
today about what are game jams? Why are they interesting? Why might you want to
participate in one? And then also go over some
tips and tricks and how I work with UE4 to make games.>>Victor: And you’ve
done how many game jams?>>Michael: Probably
close to 20 at this point.>>Victor: OK, I
think I’m around the same, somewhere around there.>>Michael: So my first jam
was the second Triangle Game Jam in I think 2008.>>Victor: OK.>>Michael: And then
I’ve done every Global Game Jam since then. Been doing Train Jam
for the past five years. Done some Ludum Dares. Just whenever I have time
when a game jam happens, I try and do it.>>Victor: And
it’s probably one of the best things I know
in terms of collaboration, and also some of the
topics that we’re going to talk about today. Yeah, feel free. You’ve got the floor.>>Michael: Cool. So I’ve got a presentation
here that I’m just going to go through first
before we go into a demo. So I’m just going
to talk a little bit about what is a game jam? Who might want to
participate, why you might want to participate,
how do you participate? And then, how do you
actually make a thing? So a game jam is really simple. It’s basically you’re
going to make a game, and it’s going to be in
a finite amount of time. So that time is the
biggest constraint. And so it’s a forcing function
to make sure that you start and then finish in a
limited amount of time. So there’s lots of
different kinds of game jams because the goals are
different for different jams. Like some jams are, hey, we’re
going to make some VR thing, or we’re going to make games
using this piece of technology, or games in this art style. Because of whatever
those constraints are, that radically alters
the output of the jams. So time limit, team
composition, the theme, and your motivation of why
are you actually doing the jam are some of the
biggest factors there.>>Victor: Did we lose it?>>Michael: Oh, there we go. It had just tabbed over. So here’s a couple
different examples of some games I’ve
worked on in the past. So this was the first
game jam game I did. It’s a 2D platformer where you
play this little olive that has to get into the martini
glasses in order to get higher jumping power. But the more you stay
in the martini glass, the harder it gets. So your controls
start getting wobbly. And so it’s just a time attack. You’re trying to get to
the end of the goals. This is Hubert’s
Safari Adventure. You basically drop anvils
down on these dodos, and you’re trying to massacre
as many dodos as you can. The theme for this
jam was extinction. So that’s the tie-in there. This one is Unstoppable
Grave Looter, where, basically, you’re running
around, and you can’t stop. You are always moving forward. And so you’re trying
to frantically gather loot and complete rituals
before all the zombies get you. And then, this one is
Katamari Soup making. So it’s basically you’re
rolling around trying to collect ingredients
from a grocery store and then jumping into the
soup pot to make soup. And so depending on what
combination of ingredients you have, it’ll come up with
a different procedural name for your soup and score it. So why should you jam? One of the biggest reasons for
me personally is to have fun. It’s enjoyable. It’s a diversion from what
I do on a day-to-day basis. Obviously, the big
reason for most people is you’re going to make a game. You’re going to make
something cool and exciting that you want to play or you
want other people to play. To level up your skills. Like how do you
improve over time? How do you learn new
technology and stuff like that? This can be a nice
forcing function of I’m going to use x to do y. And then the last bit is tied in
with leveling up, just building your shipping muscles. Just like normal muscles,
they get stronger with use. So as I was saying,
one nice thing about a jam game versus a lot
of hobby projects is you start, and then you finish it. You actually cross
the finish line there. Even if it’s a
much smaller thing than you might be working
on on a broader project, it’s just that satisfaction
of actually having completed a thing I think is really nice.>>Victor: And it removes–
one of the thoughts I have when I work on a bigger
project– It doesn’t need to
be perfect, right? You can take any way
that works that gets you to the finish line is OK. And that can be very freeing and
open you up creatively as well.>>Michael: Yep, definitely. You can explore new ideas, kind
of like what he was saying. It lets you meet people
with similar interests. Other people at game
jam, obviously, they’re also interested in game
development as well. And also, you can end
up operating in a vacuum if most of your friends are
in the same discipline as you. So this is a chance
to meet people who might be artists, or
sound designers, or writers, or whatever, in addition
to just other programmers. That’s my background. But obviously, everybody’s
got a different background.>>Victor: I had
a doctor on my team once that had never
done games at all, but they were able to
provide a lot of expertise in terms of what
we were working on.>>Michael:
That’s really cool.>>Victor: Cool, yeah.>>Michael: Yep. So obviously, most of the time,
the point is to make a game. That’s not always true. You might go into a game
jam with the motivation of I want to learn this
piece of technology, or I want to try
making art today, or I want to play around
with this piece of hardware. The end product is
not always the goal. And so if you don’t
cross that finish line, that’s OK, as long as you cross
the finish line on whatever your motivation was. So like you were saying,
you can afford to fail, because at worst, you’ve wasted
two or three days of your time. Well, why not take a risk?>>Victor: And you’ve
probably learned something.>>Michael:
Yeah, absolutely. You’ll have created a finished
product you can share. You can put it up online. Most jams will have
some upload process, or you can upload
on itch.Io, or just put it up on a zip link
on a form or something. Another important thing,
one of the reasons why I like doing game jams,
it’s more chances at bat. Every time you make something,
if you have a small percentage chance of finding a really cool
nugget or an exciting thing, then try more times, and you’re
more likely to strike it rich basically.>>Victor: Yeah.>>Michael: So leveling up,
flexing your shipping muscles– when you’re doing a
project start to finish, there’s different
things you need to do when you’re
doing pre-production or ideation, what you need
to do to actually implement your features, and then
what you need to do to polish, to ship, to package. And so this forces you to do all
those different steps in one go. And if you’re on a
small team, you’re not going to have dedicated a
character model and so forth. So one person will
be wearing many hats in what they’re creating. And then flexing your
shipping muscles– can you scope down? How is your time management? Balance for the game
playing, polish, juice– can you make it fun
and exciting to play? And like I was saying, it
gets easier with practice. The more times you
do this, the better it’s going to be in the end. So when you’re
preparing for a jam, you really need to decide
what your motivation is. What are you looking
to get out of the jam? And that’s going to influence
what you want to do, how you might form a team,
what prep you need to do. So if you are using
pretty copious software, you want to make sure
it’s updated, patched, all that kind of stuff. Packing– you’re almost always
going to want a computer, probably a thumb
or a flash drive to be able to transfer
files between people, especially if you have like
big installers or something. I’ll talk in a minute why you
shouldn’t be using a thumb drive to store your project. A pen and a notebook or paper– it’s great to be able to
scribble down ideas, take notes, that kind of thing. Consider bringing
some snacks and drinks if this is a physical
jam that you’re actually going to a location. Not all jams are. Some will be– Ludum Dare is organized
every quarter, and it’s an online jam. So some places will have
physical get-together sites. But for the most part, people
are at their house jamming there. But then, Global Game Jam is
come to this location and jam. Other things that
are useful to bring, like an extension cord,
microphone, game controller. All these things are optional,
but they can definitely be useful. So actually, this is
what I take to jams. It’s just a rollaboard suitcase
like you take on an airplane. And so it makes it
really easy to carry it around when I’m in an
unfamiliar campus or something. And so I’ve got in here an
extension cord, my laptop bag, a notebook, a couple
sodas, a controller, a headset with a boom mic, and
crayons and colored pencils as well.>>Victor: In case
there’s no whiteboard, and you want to–>>Michael: Yeah. Well, and also, I’ve seen
games that do hand-drawn art, and then they’ll
take pictures of it, and then use that in
their game or whatever. And so you just never know
what you might want to do.>>Victor: I usually
say an extra extension cord because you never know if
your teammates are going to be as prepared as you are.>>Michael:
That’s a good idea.>>Victor: Yeah.>>Michael: Yep. So like I mentioned,
definitionally, a game jam has some kind of time
constraint attached to it. In general, the constraints
breed creativity. So you have a time limit. You probably have a theme. Some jams will have
opt-in diversifiers. So Global Game Jam basically
has an additional list, like make a game that
doesn’t involve any text. It can be played entirely
by people of any language or things like that. And then you also have
an implicit constraint of what is your
team composition? Because if you have a team
with no artists, well, that means that you’re going
to have to get batch art or make a game that
doesn’t really rely on art. If you have a team
with no programmers, then probably tone down
the mechanics a little bit. Aim a little bit
simpler for that. And ideally, you can try
and balance teams out based on what your goal is.>>Victor: The Epic MegaJam,
the last Epic MegaJam winner, they were a team
of five artists. And one of them have to take
the hat of Blueprint engineer.>>Michael: Yep,
that’s really cool. But, yeah, the biggest reason
why I think constraints help is it helps to avoid this blank
page problem or blank slate problem, where if the
world is your oyster, it’s like, well, you
could do anything. And so it’s hard to decide
on what you’re actually going to do. Whereas, if you have some
themes, you have a constraint, it helps kind of– in some ways, it’s
narrowing you down, but it’s actually making
you more free to then make other decisions
because you’re not stuck in analysis paralysis.>>Victor: That’s a
good way to look at it.>>Michael: Yeah. And so one tool I
mention on the form that I use a lot is
mad lib generator. So basically, you can just
type in a bunch of words– verbs and nouns– and it will
generate three-word titles. So Pixilated Martini
Roller came out of that.>>Victor: OK,
do you have a link to that that we can show later?>>Michael: Yeah, it’s
just fancygamenamer.com.>>Victor: OK.>>Michael: And I’ve linked
on the forum post for this. I’ve got basically a bunch of
resources listed there as well.>>Victor: Sweet.>>Michael: Yep. Another thing to
mention, you don’t always have to make a video
game at a game jam. So one year, me and a friend
decided to do a card game. And so we actually started
out making a video game Friday night, and it just
wasn’t coming together. And then, on the way
home, I stopped at Walmart and bought a bunch
of crafting supplies. And then, the next morning,
we started making a card game. Another thing you can do is
you can do hybrid things. Because a game jam is not
a game that is necessarily going to be commercially sold
or available or whatever, you can do more installation
or art kinds of things. And so this is
Peter Needs a Pint. And it’s actually–
this is for Molly Jam. And so this was a stand-in Peter
Molyneux with a curiosity cube that poured a beer. Or in this case, it
was actually a soda. But based on how well
you did in the game, it would pour you more or
less at the end of a match. So you can do a lot of
fun, creative things. But the biggest
thing once you’ve figured out what you want
to make based on the theme is controlling scope. The time constraint
is really harsh, and everything will
always take longer than you think it’s going to.>>Victor: Yep.>>Michael: So if you
come up with an idea– say you’re doing a
two-day game jam. Come up with an idea that you
think could be done in one day. Then, cut that in half. And then maybe that’s on
the border of achievable. And don’t just do
it once upfront. You’re going to be
doing this continuously. Evaluate by midday
Saturday afternoon, have you actually gotten
where you want to get? If not, maybe what you’re
working on right now isn’t important. Make sure that you’re getting to
try and explore that key idea. So make trade-offs. Decide what’s important
in your game, what isn’t. And anything that’s
not important, just that can come later. If you have time later, cool. If you have time
after the jam, cool. But don’t do 20% of
10 different things and then never get to something
that’s actually playable.>>Victor: I think one
of the first things I try, if there’s a game loop,
I want that game loop. That’s the first thing I go for
in terms of gameplay framework. And then it’s like,
OK, there’s a win and there’s a lose condition. Cool, now yeah.>>Michael: Yeah, and
you can go from there, and you can just keep
making it more complicated. Don’t let perfect get in
the way of good enough. One of the other things I’m
going to talk a little bit about is polish your juice. And that can be really tempting
to just go down the rabbit hole and do nothing but that. But get it to where it’s
good enough, it feels decent, and then you can always
come back on it later. But do a little bit
on your key pieces. If you’re making
a shooting game, make the shooting feel good. Make the jumping feel good. If you’re making a
platforming game, make the camera feel good,
and then the controls, and stuff like that. Always be shipping. So what this means is try and
package your game early on. Try to make sure that
you don’t ever leave it in a completely broken state. If you’re starting to refactor,
try and do it in a way that– you copied the
Blueprint or something. Don’t get to a point where the
game is just completely broken and on the floor. And then the last thing is,
because it’s a game jam, because this is make
one to throw one away, it’s OK to do things that
you wouldn’t normally do. Make everything public. Have things cast to each
other instead of using interfaces and stuff like that. I’m not saying you
should always do these. But you don’t have to
feel bad about doing them if you just need to get it done. If it’s the first time this
thing needs to talk to that and it would take a while
to route the data around, sometimes it’s easier to just
say get player controller 0 and cast to it. Please don’t ever use
get player controller 0 in a shipping game. But in a game jam, it’s cool. Another really important
thing, like especially I see a lot of
first-time jammers who just are like, I’m going
to work through the night. And it doesn’t make sense. You need rest. Your brain works better
when you’re well rested. So get your normal
amount of sleep. Take breaks throughout the jam. Get up.
Walk around Don’t just sit
there for 12 hours.>>Victor: Play a game.>>Michael: Yeah, exactly. Get proper meals. Treat it like a normal
weekend that you happen to be making game in, not
I got to do all this in one go.>>Victor: And it’ll
prepare you a little bit more for a normal– say if you were working five
days a week at a studio. That’s more what it’s like.>>Michael: Yep. And it seems
paradoxical, but you will get more done if you work
less because your brain is well rested. And when you’re not
working, your brain is actually still
churning on those problems in the back of your mind
whether or not you know it. And you come back, and if you
got frustrated with something, one of the best ways
to solve it is often to just take a step back. Either go switch to
work on something else or don’t even work on
the game jam at all. And then, when
you come back, you may have subconsciously figured
out what the problem was.>>Victor: I think a lot
of engineers or scripters and anyone who’s making
have either right before they go to bed, or
as soon as they wake up in the morning, it’s like, oh.>>Michael: Yeah,
or in the shower before you’re heading in
in the morning, it clicks.>>Victor: It’s just
from nowhere, right?>>Michael: Exactly. Revision control is also
a form of self care. One of the most frustrating
things I’ve ever seen is when a team of
jammers, they’ve all been working on their
own copies of the project, and they’re trying to merge
their work together Saturday late at night or whenever,
they’re going to make mistakes. Somebody’s work is
going to get lost or it’s just going to take a
lot of time to put it together. And you can avoid all of that
by using revision control. It also makes things like
what I was talking about, where if you’re refactoring
or trying to make a big change and you break something,
well, worst case scenario, you can always just throw away like
the refactoring you’ve done, and you’ll get back to a point
where you know it’s good.>>Victor: It
removes that step of having to manually, like
you said, copy a Blueprint, and then manage them, and name
them properly, and remember.>>Michael: Exactly.>>Victor: If
you’re curious about how to set up version
control, we did do a livestream just
a couple of weeks ago on version control. And we did SVN there,
which is a good solution, depending because you might
not know what the internet’s like at the jam site. And SVN, you can just bring
a router and another piece.>>Michael: Just run it
on one of the people’s laptops.>>Victor: Yeah,
and just set it up. And it’s pretty
straightforward and free.>>Michael:
Yeah, absolutely. If you don’t use proper
revision control, then you can always
use a cloud provider, so Dropbox or Google Drive
or something like that. Even with those, you probably
still want to make copy 2, copy 3, and copy
4 kinds of things. They’re not really designed
for revision control and thinking back to
individual checkpoints. They have some
functionality there, but that’s not their primary–>>Victor: And I’d recommend
to not do the auto sync because you will
get clobbered files. And when you try to package,
it will complain about those.>>Michael: Yeah, this would
be more like a backup solution, where you copy your project
into it on a regular basis. But again, best to just set
up actual source control. And then, please don’t
do this to yourself. Having the only copy of your
game being on your laptop, something will go wrong. Or if you’re working
with several people, and one person has to leave
because family matters or whatever, you don’t want– now, the project’s
not available. Or passing around a
thumb drive, people will copy the wrong version. Things just go wrong. Another thing about jams– the vast majority of
jams are cooperative. They’re not for prizes. They’re not for
what is a winner? And even for the ones
that are, usually, it’s still there’s a
lot of camaraderie, or we’re all wanting
to make cool things. So it’s not like
a zero-sum game. So try and help out. If other people have
questions or you can help, then that’s great because the
flip side can be true too.>>Victor: Yeah.>>Michael: I’ve learned
a lot from other people at game jams.>>Victor: Just
watching other people work can be a big lesson.>>Michael: Absolutely. And you have be respectful
of other people’s time, personal space, et cetera. Just be a good human being.>>Victor: They are
good rules in general.>>Michael: So you’re
working on your game. You’ve got to that
first playable fairly quickly,
like we were saying. Ask if other people have a
few minutes to give it a go. See how they play it. It’s really tempting
to try and explain, oh, you need to
do this or this is how it’s supposed to be played. But if you can, just take
that step back and just let them fumble at
it because you’re going to get so much
valuable feedback. You’re going to see,
oh, this thing I thought was obvious in my
head, they don’t get at all. That’s not on them. That’s on you to
present it better. And then tweak it. And then, ask again or
ask a different person. And just have that
tight iterative loop, where you’re constantly trying
your game, playing your game yourself, playing your
game with other people. And that’s how it’s
going to get better. The more iterations you
get, the more likely you are to arrive at
something that’s fun.>>Victor: I had
a friend that always said that if he didn’t have the
main game mechanic in an hour, he was doing wrong. And he would scrap
that and do something else just so that he could
have people just immediately come and play and
give feedback so that he had time for the juice,
to make that one mechanic.>>Michael: Yeah,
the juice, the polish, making it meaty and
interesting and fun.>>Victor: Because you can make one jump or a one-button game
that only has one ability, you can make that
game feel really good if you have the time to
spend on that kind of polish.>>Michael: Yep, absolutely. So like we were saying
before, try to package early. Try to package often. When you’re getting
towards the end of the jam, you probably have some other
things you need to prepare. So depending on where
you’re submitting it, you might fill out a
description on a website, or you put it in a read me. Just some information
about, hey, what was your pitch for the game? Maybe talk about how
it ties into the theme. What are the controls
or instructions? If they’re special
install instructions or you need a piece of hardware
or something, talk about that. And don’t forget the credits. Mention who you are, who
your team was, probably what game jam or game jam
site you were working on. And then, if you use
any third-party assets, make sure that you followed
their crediting or attribution guidelines. So the Unreal
Marketplace content, if you’re not releasing
the source assets, you can use them. If you are releasing
the source assets, you can’t use anything
that’s paid content because the license
doesn’t allow the redistribution in that way. But Learn Tab
content you can use. And we also have some
Marketplace content that’s marked as free, so
the Infinity Blade assets, the Paragon assets,
stuff like that. You can also use
those, although, again, check what the jam rules are
because some jams will say, hey, you’ve got to create all
the assets during the jam, or they have to have all
been made by the team that’s doing the jam. But other jams are
just make a cool game. But yeah, whenever
you use something, make sure that you’re following
the licenses and credits. It was on Google image search– that’s not a license. It’s a lot easier to keep
track of this stuff as you go. So if you download
something and it’s under a CC BY
license that says you must have a link to
my website or a link to my Twitter
account or something. write that down when
you get that asset. And then, that makes
it a lot easier to gather all that information
at the end of the jam because you’re not
frantically scrambling, like, well, what website
did that come from? And just to wrap up, if
you remember nothing else, try and get to that first
playable really fast, like within a few hours ideally. Ruthlessly scope down. Cut ideas or punt. Don’t necessarily have to say
you’re not going to do them. Just say you’ll do them later– anything that is not in service
of that core idea until you’ve gotten there. Use revision control,
back up frequently, take breaks, get good
night’s sleep, and have fun.>>Victor: When
it gets to that– you were mentioning
that you have ideas that you’d like to do. Do you usually write them down? Do you do a shared Trello board?>>Michael: So it
depends on the jam. So if it’s just two
people, oftentimes, it’s easiest just to
talk back and forth. If it’s four or
five people, then I think it can get to the
point where Trello or Sticky Notes or something that is
definitely helpful to list, OK, we think we need two levels. And so you have a
card for each level, and have a card for
the shared tasks of if we need to make props
for the level or whatever. I think it gets even more
helpful the bigger the team is. If you have several
modelers and you have a bunch of
different props to make, you can have a bunch of cards. And people can grab
those cards and say, hey, I’m making this prop. That way, you’re not ending
up with duplicated effort.>>Victor: And
doing a scrum board, even having a
physical scrum board, it’s very real in terms of how
teams work in the real world outside of jams. And so it can help you practice
for what the real world is like if you’re trying to get a job.>>Michael: I’ve never
seen a jam use JIRA, but– [LAUGHTER] –that wouldn’t
be a terrible fit.>>Victor: No, it
wouldn’t be terrible. I think you need
a license though. A good tip that I’d
suggest is HacknPlan. It’s actually free. It’s a mix of Trello and
JIRA, just hacknplan.com.>>Michael: Cool.>>Victor: It’s cool. I’ll put a link up in the forum.>>Michael: And
then, Trello is also. It’s basically just
digital sticky notes. So you can imagine, like
you can make columns that are labeled
different things, and then put a sticky note
in each one of the columns. So you can stuff like
need art for this. Need sound for this. Somebody needs to implement this
gameplay feature or whatever. And then you can just
move them to is it done? Is it half done, but polished? Or is it not even started yet? Things like that. So next thing I’m going to
sort of jump in a little bit. And I’ve got a dummy project
that’s not a fun game. It’s not really a
complicated game. And it’s got no polish at all. And so we can talk a little
bit about some different ways you can add polish. And then, also, just
some tips and tricks.>>Victor: Cool.>>Michael: And so, by the way,
this was actually all in Unreal. Yeah, and so this is just
a silly little game where you can fire cones, and you can
run around and collect gears, and stand in the
fire and get hurt. But obviously, he’s not
reacting to getting in the fire. The coins don’t do anything
when you get them picked up. So this might be an example
of a first playable. This isn’t quite
where I’d get it, because I’d want to
at least have, OK, if your health reaches 0,
you game over or restart. If your score hits 100,
maybe you win screen. But once you have that
core loop, that’s a game. It may not be a fun game yet,
but you’ve got the basics. So first, I’m just going
to talk about a couple of different things I normally
do to set up a project when I’m first getting started. So you probably
make a new project using a template
that has controls similar to what you want. But what I also do is I’ll
create another project that I call a content dump. And so I never add starter
content, or content examples, or the Infinity Blade packs
directly to my target project. I’ll instead add it to one
of these dump projects, and then I’ll migrate
content across. That makes it a
little bit easier to keep your main project
clean and organized. And so one thing
you’ll notice here is you can see that the
title bar in this project is a different color. So there’s a project setting– or sorry, an editor preference
that lets you change that. So under General
Appearance, just down here, you have Editor Main Child
Window Background Override– sorry, Main Window and Child
Window Background Override. And so you can just
adjust the tints on these. And this makes it
really easy if you have multiple windows open
to not get confused which copy of the editor am I in?>>Victor: That’s great.>>Michael: And so we use
this for different branches for internal development. But even in the
game jam project, you can make your dump
project one color. Your main game, leave
it the default color. And then, if you’re opening up
content examples, or a shooter game, or some other project,
you can make that a third color. And then, it’s just
really easy to tell–>>Victor: I love that.
That’s a great tip.>>Michael:
–which one is which. Another thing I’ll usually
do at the start of a project is go into Project Settings
and tweak a couple of things. So I’m not going to change these
right now because some of them will cause a bunch of
shaders to recompile. But if you know that you’re not
going to do something or use something, you can make
shader compilation go faster and make your final project
a little bit smaller too. So just go to
Rendering Settings. So you can adjust Allow
Static Lighting, for example. If you’re not using
static lighting, everything’s going to be dynamic
or whatever, turning this off means you won’t get
lighting needs to be rebuilt in the corner. It means it won’t compile
the shader permutations for the static lighting. But obviously, sometimes, you
really want static lighting. If you’re doing a
VR game that’s lit, you probably want
to have as much as possible in static or even
use completely unlit stuff.>>Victor: And
if that’s the case, you can actually uncheck that.>>Michael: Oh,
for that as well. There’s a couple other
settings like this that adjust how many shader
permutations will be generated, like supports stationary,
skylight, and stuff like that. I would probably just Google for
what these checkboxes do if you want to play around with it. But turning them off at
the start of your project will mean every time
you’re importing something or every time you’re
making new material, it’s a few fewer
permutations to deal with. One other setting
that is new in 4.24– and it’s experimental,
so your mileage may vary. But it’s incredibly useful. What is it called? Oh, it’s an Editor setting. That’s why I can’t find it. So it’s called Base Classes
to Allow Recompiling During Play in Editor. And so, normally,
when you’re in PIE, your game is actually running. All the Blueprint
editors gray out. You can’t interact with them. So this will actually
let you say, no, I know that it’s OK
for these things to get recreated during PIE. And so you can turn
that on, and then you can actually tweak
these Blueprints while you’re playing. And so you’ll be running around. That doesn’t feel right. Let me change the Blueprint. Now it feels right. And so this won’t
work for every class. And some classes will
have lifecycle problems where, when it gets
recreated, references it to it won’t be correctly
updated and stuff. But for anything that’s a
statically placed object in the scene or a
transient thing, like the projectile
when you fire it, or the sound that plays,
or whatever, those all should work fine.>>Victor: So
I know it’s new, but what’s generally
your workflow when you’re dealing with this? Will you add them right before
you’re iterating on them?>>Michael: Usually,
I’ll just set it up when I make something. So for example, anything
that’s based off camera shake, I want to be able to adjust
the settings on that. I’ll create a base
class for effects, like something that plays a
sound, and a camera shake, and a vibration, and
everything else all together. I’ll add that to the list. I might add like the base
class for like my world props, those kinds of things. I mean, you can go the nuclear
option and just add Actor. And then be really
careful not to recompile. Probably the player
controller and the pawn are the two that
may not work well. And it won’t crash if you
do it for the most part. It just might not– you might lose input
or something to that. And worst case
scenario, you just hit Stop PIE and
then Start PIE again. And so I’ll show
off like what that lets us do in a little bit. What else for Project Settings? I think those are the
main things for right now. You can also go check out
the Packaging Settings and turn on or
off whether or not you want to compress your pack
files and stuff like that.>>Victor: Engine
Content is usually something, especially if you’re trying
to have a small package game– turning off Engine Content. What you should do is
I have a folder that I call Engine Content Copy. So anything that I actually want
to have in the final packaged game>>Michael: You
can copy it from there.>>Victor: –I copy
it from Engine Content and move it back
over to my folder. And then I know that
it will be packaged.>>Michael: Yep.>>Victor: Saves you
about 300 megs, I think.>>Michael: OK. So in this game, we can see
that you can run around, you can fire cones, and
you can get damaged, and you can collect coins. So there’s not a lot
of oomph right now. Everything just feels flat. You stand in the fire. You can’t even tell
that anything’s really happening other than it’s
debug printing in the corner. So let’s change that so that
the mannequin actually does something as a result of that. So over here. So in my dump project,
I added the animations, the animation starter pack. So this has a couple
of hit reacts in here. So you can see what
these look like. So you’ll kind of see
he’s taking damage. So we’ll go ahead
and grab these. And so in Asset Actions, there
is a tool called Migrate. And so this is how
you move content between different open
three to four projects. And so you can see it’s selected
a bunch of different stuff. I happen to know that I’m not
going to need all of this, and so I’m going to uncheck
the Mesh and the Textures. Actually, not all the mesh, but
the fact that the textures are going to import wrong
is OK because I’m going to move this over
to the mannequin that’s already in the other project. So we can just
turn off Materials.>>Victor: Are
those checkboxes new?>>Michael: I think
they’re new in 4.23 or 4.24.>>Victor: Yeah, they are.>>Michael:
They’re fairly new. Used to just be–>>Victor: All or nothing.>>Michael: Exactly. And so these are the four
that we actually care about. And then, you also
need the Skeleton. And when in doubt, you
don’t have to uncheck this. You can just let
it do everything. You’re just going to end
up with a few extra assets you’ll have to go
back and delete later. So you hit OK. And it’s going to ask you
where do you want to go? And so you want to select the
content folder of the target project. So I’ve got Jam Presentation
and then Content. And then you don’t go
any deeper than this. You always just go to
the Content folder. And then, it’ll create
the hierarchy that matches where it came from. So it’s telling me
some of this stuff already exists
because I had already copied a previous asset. And so I’m just going
to say no to all. I don’t need it
to overwrite them. So now, we can switch
back to the jam project. And it’s created these
assets over here. But all those
assets are pointing to the skeleton that came along
with it and the Skeletal Mesh. And so that’s not
actually what we want. So we’re going to go ahead
and consolidate this. So consolidate is I’ve got
two assets that I basically want to replace the references
from one to the other. So you can see I’ve got
these different skeletons. And so we want to combine
the mannequin skeletons. It’s actually called
Replace References now instead of consolidate. And so this is just
asking me which one is the one that I want to keep? And then, all the ones
that I don’t select will go into that one.>>Victor: OK.>>Michael: And so we can
see game mannequin is the one that the sample started with. And so that’s the
one I want to keep. And then, this
other one, I’m going to replace the
references from the one I migrated over to
point to that one.>>Victor: And there
it says consolidate.>>Michael: Yep. That just asked
me do I want to delete the one that was going away. So now, that’s done. You can see it left a
redirector because I have Show Redirectors on. You don’t have to worry
about that for the most part.>>Victor: Do
you want to show them how you can actually turn
that filter on because it’s a little hidden?>>Michael: Yeah, sure. Well, actually, in general,
filters is one of the things that I think a lot
of people sleep on. This can be really useful
for finding different assets in your project. So usually, I’ll turn on like
Blueprint Classes, Material, Particle System, Static Mesh. Then, I also turn on
Material Instance. But then, there’s a lot of
other interesting filters in Miscellaneous
and Other Filters. And so in Other Filters,
there’s this thing called Show Redirectors. And so redirectors are
basically symbolings or pointers from one file to another. So when you rename a file, when
you do things like consolidate, it’ll drop a pointer. So anybody who is unloaded who
is pointing to that old asset will then still point
to the old asset. But then, that will
point to the new asset. And then, you can
always replace them by selecting Redirector
and saying Fix Up. And then, that’ll make
the links go like that, and it’ll resave all the
things that are pointing to it. But that’s usually
not something you want to do when you’re
working in a team unless everybody’s got all
their stuff checked in. Because the fixing
up of references, anything that they had locally
that created a new reference to the old asset isn’t going
to get fixed up because you don’t know about it yet.>>Victor: The rule I usually go by is don’t rename
anything during the jam. Stick to what you–>>Michael: I
think renaming is fine. Just don’t fix up redirectors
unless everybody’s got all their work checked in. So that’s a cleanup thing you
might do at the end of the jam or once a day kind
of thing, if any. But it’s also fine to just
leave the redirectors around. But by default, they’re hidden. And so this filter lets
you actually see them. But each one of these things
that you turn on or off is a button. And so you can
turn it on and off. So you just leave it at the
top root of the content folder, and it’s like, let me
see all the particle systems in the project. Or let me see all the materials. And these work in conjunctions. You can go down into a
deeper folder as well. I was going to
mention this later on, but I’ll go ahead and
do this right now. There’s also In Use By
Level, and Used In Any Level, and Not Used In Any
Level, which are really useful towards
the end of the jam. If you’re trying to clean
up your packaged game size, you can use these
to get an idea of, well, what assets I
migrated in, but I actually ended up not using. And so you can use those
to try and clean up. But if you have
something that isn’t used and you want to know can
I actually delete it– you shouldn’t always
just delete everything. So you can do this thing
called Reference Viewer, which actually shows you what– this is the asset. Things to the right of it are
things that it references. So this Static Mesh
or Skeletal Mesh references the skeleton
asset and the physics asset. The things to the left are
things that reference it. And so you can see that that’s
actually a circular dependency, that this thing
depends on each other. And you can see this redirector
actually says all these still reference that old name. And so this tool is just really
useful for project management and trying to figure out
why does this still exist? Or if you’re trying
to break a reference or trying to understand
why is this getting loaded or how is this
getting pulled in, this is the first tool to go to. Related to that,
there’s also something called the Size Map, which lets
you see why is something big.>>Victor: It’s a little
further down in the main one.>>Michael:
There it is, yep. And so you can see this is– the things it references
aren’t very big. It itself is pretty big. So you can see it’s– but if we go over
to one of the maps. Where is it? Now, we’ll just search. So there we go. And so you can see
it breaks up where is all this data coming from. And so you can see the world
itself is a decent size. But then like the sky
texture is 15 megs. So if you didn’t need
blue clouds in your sky and you’d put everything
inside of a building, then you could go ahead and
remove that from the project and save a decent
amount of size. So this is the kind of
thing that you probably don’t normally do
during a jam or you do during that last
hour of the jam, but it’s still useful
to know it exists. OK, so let’s pop back and so what we want to do is
get these hit reacts playing. Oops. So in here, we walk over. We take damage, but
nothing happens. So we’ve already got the
player taking damage. So like I said, this
is jam quality code. Not saying this is showing
off the best way to do things. It just subtracts the health
and sets the new current health. And so we know that
something’s happened, but nothing’s doing
anything with it yet. So if we open the
Anim Blueprint.>>Victor: What was
the shortcut you used?>>Michael: Oh,
so that’s Control-P, or I think it’s Control-Alt-O is
the other binding or Control–>>Victor: Control
is for maps, I think.>>Michael: It’s
Control-Alt-O or Control-P. They’re the same binding. And so this is what’s
called the Asset Picker. And so basically, it’s
like a content browser that you can just
immediately start typing in. And you can use the keyboard. So I can open up
the Anim Blueprint, and then just hit
down and hit Enter. And it opens up. And so that shortcut is really
useful for just moving around the Editor quickly.>>Victor: Instead of having
to tab over to the Content Browser and find it, yeah.>>Michael: And
there’s also one that’s Control-Tab
which lets you switch between different
tabs really quickly as well. So in here, we got
those new hit reacts in. So now we can see– actually, they’re
not showing up. So we may have repaired
them to the wrong Blueprint or to the wrong skeleton. So this is the skeleton
that it’s using, UE4 mannequin skeleton. So that’s what we wanted. So this one skeleton is
UE4 mannequin skeleton. Hmm. So oh, there. It just apparently
didn’t refresh. So I’ll just open
all four of those. So now, we’ve got
these four hit reacts. Just drag in each one. And so what we can do is
we just do a random node or blend by random. Actually, just in
the interest of time, I’m going to skip
that right now, and I’ll just make it play
one of the hit reacts. So we want to blend this in. And so there’s a couple
different ways we could do this. We can make it a different
state in the state machine. We can do a blend by bool. And the way that’s
actually usually the best is what’s called a montage. So you can create
a montage that’s like I’m going to plug this
in somewhere in the graph. And so montages
can have one track that’ll be the base
layer, one track that is an additive layer,
so on and so forth. And then you can trigger
from gameplay saying, hey, this montage should
play now, and then it’ll play a separate timeline. But for a jam thing, we can
just play a single effect. So we’ll create a Boolean
for Was Recently Damaged. Just promote. So then, if it’s true,
we’ll blend this in. If it’s false, we’re
going to use the him being at that idle point. And we’ll replace that. And so this is
something I did before. So the default graph you get in
a brand new blank project just has the state machine going
over to the output post. So I added what’s
called a layered blend by bone, which allows you to do
upper body, lower body stuff. And so I had imported
this idle hip rifle– idle rifle hip
animation earlier. And then, I’m blending
that in, basically starting at the spine. So anything below
the spine always uses the locomotion
state machine. And above the spine,
it starts to use whatever we’re doing over here. So the hit react will only
affect the upper body. So now, we can test this out
by checking or unchecking the Was Recently Damaged. So you can see–>>Victor: It’s
getting a little–>>Michael: Yep. And this is actually
probably best done with the state machine
because you can make the state machine automatically
transition back out when it finishes playing. Because doing it by just
setting the bool on its own, you’re going to end up with
the hit react potentially starting to loop back if you don’t
manage the time just right.>>Victor: And if
it was multiplayer, there would be latency. You’re not entirely sure. And even if you set
that delay to be exactly the time
of the animation, you’re not sure
that that’s going–>>Michael: That’s
going be it, yeah.>>Victor: Yeah.>>Michael: But for right
now, for this jam thing, this will be fine. So now, we’ve got
this Boolean, but we need to get it from somewhere. And so what we can do is this
already gets the pawn owner, and grabs some stuff off of it. So in the player pawn, what
we’re not doing right now is we’re not
returning– you’re not thinking about when
were we damaged, just that we took damage. So let’s go and create
a new variable that’s like the last time
we were damaged. I’m just going to change
that to be a float. So now, every time
we get damaged, we’re going to remember
when were we damaged. And then, in the Animation
Blueprint, we can pull that. So what I did there is I
double-clicked on the wire. And that creates a
reroute node, which helps you organize your Blueprints. So I’m casting it
to the player pawn that we actually have so that we
can actually get properties off of it. So now, we can actually grab the
last time that it was damaged. And we can compare that
what is the current time.>>Victor: There are
a lot of time related functions in the library.>>Michael: Yeah, there are. Just make sure. Yeah, this is what we want. So we want to know
the time since. Then, we can just compare that
to some threshold. That’s set. So say we’ve recently damaged,
and then we can save that off. Now, this is actually
going to be– the last time damage
will start out at 0. And so this would actually show
up for those first 0.2 seconds. So what you probably
also want to do is say, also, this needs to
be greater than 0. It was set at some point. And if both of those are true,
then we were recently damaged. And there’s other
ways to do this. But this is just one quick
way we can hook this up. So now, let’s try it out. And it doesn’t work.>>Victor: It didn’t?>>Michael: So let’s
figure out why it doesn’t work.>>Victor: I
thought I saw it.>>Michael: No.>>Victor: Yeah, see?>>Michael: Oh,
there it’s working, yeah. I must just not have been
standing right in the fire.>>Victor: And it’s
mandatory to onomatopoeia during a game jam.>>Michael: Yep. Although, actually,
that’s another thing that can be a lot of fun
is you can actually use a microphone to
record your voice and use that as sound effects
as placeholders or whatever. I did a little shoot-em-up
where you’re flying around on the back of the snake. And all the sound effects were
just like pew-pew-pew and stuff like that.>>Victor: Yeah. One of the best flash
games I ever played was completely
onomatopoeia, and it just made me laugh every time. Every action made me laugh.>>Michael: As you
can see, it’s happening. But this still
doesn’t feel juicy. He’s taking some damage,
but it doesn’t feel great. And also, he’s actually gone
all the way down to 0 health. And nothing’s really changed. There’s not a sense of
urgency that I really need to get out of this fire. So let’s try and make that
a little bit meatier still. So back in the player pawn,
when we take the damage, all we’re doing right now is
just subtracting this value. And then the Animation
Blueprint is listening. And it knows that it
needs to do something. But we could also
do something here. So we could play a sound. We can play a camera
shake, so on and so forth. So let’s actually hook
up playing a sound. So we’re going to play a sound. Center it on the Actor. And it’s just going to be– oh, well, we have no sounds. So now, we can go over and grab
some from that dump project. Or we could import them. There is a cool
tool called BFXR. Let me just grab that real
quick and show that off. This is great for
placeholder sound effects. Do you see where it went?>>Victor: No. See if you– click on the–>>Michael: Oh, there it is.
Yeah, I see it.>>Victor: We’re just
on the second monitor. That’s why it’s–
we’re still up. We have a black background.>>Michael: So
this is basically a little modular synthesis
program, basically. But it’s got a bunch of
presets for 8-bit gamey sounds. So I don’t know if
we can get the audio.>>Victor: We
might be able to. One second.>>Michael: OK.>>Victor: OK, we
should have audio now.>>Michael:
I’m not hearing it.>>Victor: We’re not able
to because the TV is muted.>>Michael: OK,
well, then, I’ll have a hard time figuring out
exactly which is the right one. But, say that–>>Victor: We might be able
to change it in the settings.>>Michael: Oh, OK.>>Victor: And we
can get the sound here. Oh, you know what? If we do that, they
won’t be able to hear it.>>Michael: Ah, OK. Won’t worry about it. Won’t go into too
much depth on audio. But this can be
really useful for let me get some quick
placeholder sounds in. Even if you’re
working with somebody who’s going to do sound for
you, this can let you prototype. And then you can always
replace them later. Or you can just end
up shipping with them.>>Victor: OK.>>Michael: And
so you can basically save after you’ve adjusted
the parameters or whatever and got something you like. You can save it. And that’ll save
basically a little text file that is all the settings. And so somebody else
could load that up. That’s like the source art.>>Victor: OK.>>Michael: And then
you can also Export Wave. And so that’s what
we’re actually going to import into Unreal. And so another thing I
usually do in my projects is I set up what I call
source art directory. So in our jam
presentation project, we’ve got a source art folder. And so we can do– So now, we can just
say this is jump. Then, back in the jam
presentation project, we can go and import that. And another nice
thing about this– once you’ve done
this once, it will remember that folder hierarchy. So it’ll keep asking do you want
to import something from source art time and time again. And because it’s
under the project if you’re using
source control, this would get checked in along
with the rest of the project. On much bigger projects
than a game jam, usually, we still have
a source art folder, but it’ll be in a
separate directory because not everybody wants
to sync all of the assets when you’re syncing a
game that’s 100 gigabytes or whatever. But for a game jam game, putting
it right inside the project is a nice time saver
because you’re not going to have a ton
of stuff in here anyway because you can’t make
a ton of stuff in a game jam.>>Victor: And
it’s easy if you’re working with someone who’s not
used to using source control. And then, you can just
tell them, hey, just always get latest–>>Michael: Yep, exactly.>>Victor: –of
the one folder.>>Michael: So
now we’ve got audio– [SOUND PLAYS] –and it’s playing now. Awesome.>>Victor: We had
to turn it up on the TV.>>Michael: OK, so
now, we go to player pawn and just go and play that. So now, obviously, jump is
not really a pain sound, but it’ll get the job done. [SOUND PLAYS] So that definitely starts
to ground the animation. So you can– you see
something’s actually happening. But it’s also really repetitive. And so one thing you can do
when you play a sound is you can click on this More
Properties dropdown. And so now, you can
see Volume Multiplier, Pitch Multiplier, Start Time. So you can do things like
randomize this a little bit. That’s one way to do it,
but this is very hard coded. And so a much
better way to do it is to use what’s called
a game play cue– or a sound cue, rather. And so we’ll go back over to
the sound asset that we made. So we imported this is just a
wave, and so there’s not really much you can do to edit it. What we can do is we
can do create cue. And so now we’ve got
a jump sound cue. So back in the Player
Blueprint, we’ll change it to use jump
cue instead of jump. And right now, it’ll
sound exactly the same. There’s no difference. But this is another graph
we can go in and edit. And so you could actually import
three or four different jumps sounds, then pick a
random node, and pick between the different ones. You can also do like
randomization of the modulation and stuff like that. So if we do modulate, then this,
basically, every time, it’s just going to pick a number
between these two values for the pitch and the volume. And so you can say let’s
actually shift it between 0.8 and 1.2, 0.9 and 1.1, let’s say.>>Victor: Those are
my default values as well.>>Michael: And so
now you can try this out. [SOUNDS PLAYING] Sounds pretty similar. I mean, this is a
very one note sound. It doesn’t have a
lot of other stuff. If you use other
samples, it’s going to be a little bit more obvious. But we can shift this down
to make it more exaggerated. [SOUNDS PLAYING] Yeah, there you go. Yep. So that’s one way to
get a lot more bang for your buck out
of these assets is basically with randomization. With modulation and
stuff like that, you can adjust and get something
slightly different every time. One thing that
we’ve done so far is we’re doing all this directly
in the Player Pawn Blueprint. This is going to be probably
the highest contention file in your game jam project
is this, maybe your Player Controller, maybe your
game state or game mode. And so it can be really
useful to try and split these up in a couple
different ways. So one thing I’ll
normally do for a game jam is I’ll create a base class
for the player pawn that has what is the really
core gameplay mechanics, and then separate
out all the juice so that that’s actually
a child Blueprint of it. And basically, the parent
Blueprint will fire events, and the child Blueprint will
respond to those events. And that allows two people
to be in there at once. One person can be
working on the gameplay. Another person can be working
on the polish at the same time. And they’re not conflicting
with each other. Although, obviously, if you
need to go back in and add another event,
you can still have to reach over, and
poke somebody, and ask.>>Victor: Yeah.>>Michael: But that
kind of thing helps a lot. Another thing you can do
is split it out entirely. So the ability system,
which I don’t recommend using for a small game jam, but
it’s great for big projects, has something called
a gameplay cue. So in the same way we
talked about the sound cue, it’s I want to raise
that an event happened, and then I want to
respond to that event. And it lets you basically
decouple them entirely. They’re only bound
by a gameplay tag. And so we can do sort of
a poor man’s gameplay cue by just spawning an Actor
whenever one of these things happens. And then, all the
details of what happens can be over in this
other Actor Blueprint. And so that other Actor can play
the sound, play a camera shake, play a screen shake, play
a controller vibration. And then, now, I never
have to touch the pawn to tweak what a
given thing does. And you can use child Blueprints
to organize your stuff. So you can have light
hit, medium hit, and heavy hit, which
medium and heavy are just parented off light. And all they do is change
the strength of the effects. So let’s go ahead
and demonstrate that. So we can just make
a new Blueprint here. So I’m just going to base
it off Actor right now. And we’ll call it B
Base Gameplay Cue. And so this doesn’t do anything. It doesn’t have anything. This is just going to be so that
we can keep pointers to this. And now, we’ll create a
couple different children. So this one is B Took Damage. Let’s also create one
that’s B Fired Weapon. And actually, what
I’m going to do is I’m going to create
one more in here. Actually, I’ll create one
more and then re-parent. B Standard. And so what we’re
going to do is we’re going to make a standard one
that knows how to play a sound, plays a camera shake,
and stuff like that. So then, all you have
to do is fill out Properties on the other ones. So in this one, this is where
we’ll actually put the meat. So let’s just go and
create a couple variables.>>Victor: I did not
know about that button.>>Michael: Which one?>>Victor: I did not know
you could click the actual–>>Michael: Oh,
the little pill?>>Victor: Uh-huh. I always go to the
Details window.>>Michael: Yeah,
and so you can also right-click on something to
turn into an array as well.>>Victor: That’s amazing.>>Michael: The
left-click on the type icon will actually change
what the type– lets you pick what the type is. Right-click changes is
it an array or whatever. And then, it’s
basically the same thing you get over here, where you
can pick what is the type and what is– or what is the kind of
type and what is the type.>>Victor: That
makes perfect sense because the buttons
are exactly the same. Just a different location.>>Michael: So paste. So one minor gotcha
here is camera shakes are always classes. And so instead of picking
an object reference, you’ll pick a class reference. And you’ll create a
Blueprint based on that in order to define
what a camera shake is. And I’ll go over
that in a minute. And then, the particle system. I always forget what
these are called. Oh, it is particle system. So now, we’ve got these three
different default things that it could do. And so we’ll see if
we got one of these. So what I did here is
there’s a lot of shortcuts in the Blueprint Editor. So I held down the S key,
and then I just single-click. And there’s other ones like B
key and single-click to make a branch, and so on and so
forth that are really useful– time-saving shortcuts. So Sequence Node is going to
basically run things in series. And so I’m going to do a
bunch of these Is Valids. And so instead of chaining
the Is Not Valid back to keep the flow in one go,
I can do basically one line for each logical thing. So basically, if we
have a sound to play, then we’re going
to play that sound.>>Victor: Do
you want to show what you can do with the Sound
To Play reference there instead of the Is Valid node?>>Michael: Oh, yeah. I mean, you can also convert it. So you can convert
to a validated get.>>Victor: That’s my favorite.>>Michael: Yep. I’m old school.>>Victor: I wish
we had it for the bool so you can right-click the
bool and just make it a branch.>>Michael: Yep, that’s
actually not a bad idea. Yeah, so we’ll go ahead
and grab the Effect To Play and Camera
Shake To Play as well. So camera shake,
because it’s a class, instead of Is Valid, you do
Is Valid Class, which only comes in the Boolean forms. And then you have
to use a branch. We’ll go ahead and
do one of each. [LAUGHS]>>Victor: Nice. And there’s no right or
wrong way in terms of this. It’s just whichever
workflow you prefer.>>Michael: Mm-hm. I don’t need to adjust anything
else right now on that. So we’re going to play
a sound on ourselves. We’re going to play an
emitter on ourselves. Then, we’re also going
to play a camera shake. And so we can do– this is a little bit– you actually play
this on something. So what we’ll do for,
again, game jam– we’re just going to get
the pawn for the player. Then we’re going to
get the Camera Manager. Get Player Controller. Actually, we’ll just go
straight to Player Controller.>>Victor: They were
wondering earlier why shouldn’t you get Player Controller 0.>>Michael: Oh, because if
you’re making a single player game, single screen game not
networked, it’s totally fine. There’s nothing bad about it. But it’s a really
bad habit to get into once you start getting
into a multiplayer game. Because on each client,
you’ve got your local Player Controller. But on the server, all of
those Player Controllers exist. And the numbering is not going
to be deterministic or useful in any particular way. So whenever you
want to do something on a Player Controller,
especially in the server, you want to route it to– you want to have a
route from whatever’s happening to the player
that it’s happening to. And so instead of calling your
Player Controller by index and have to figure out an
index, if you’ve got a pawn, you can get the controller
who’s controlling that pawn. Because the pawn
stepped into a thing, so you know who the instigator is. It’s also bad for
split-screen games because if you’re in
a split-screen game, you actually have two
Player Controllers on that local player.>>Victor: And that’s
what the index is for.>>Michael: Yeah. But in general, if
you’re doing stuff the right way for a
split-screen game, you won’t need to try
and figure out the index because you’ll always
have a route from it. So for example, you
add your HUD to each of the players’ viewports. When you add it, every
widget knows a route to a Player Controller. And so now you know what Player
Controller your HUD’s for. So your HUD doesn’t have to
call get Player Contoller 0. It can just say get
my Player Controller. Then, get my control pawn
instead of getting player pawn or get Player Controller. And the same thing is true
for most stuff in the world as well. But for game jam,
it’s really easy.>>Victor: Yeah.>>Michael: So then,
the controller has a reference to what’s
called the Camera Manager. And then, this is the thing
that you can add things like screen shakes to. Oops, I want to shake. And so this thing takes
a camera shake to play. And so you can scale it. And so we could give
it a strength for is it a light shake
or heavy shake. Or you can do that in the asset. So now we’ve got the setup. We’ve got a base thing. So I created these out of order. So you can see this
is based off of Actor. But I actually want
it to be based off of that parent class I made. So I can say re-parent
Blueprint, and then change it. So now, this is based off
the base gameplay cue. But then the other two I
created, the concrete versions, aren’t yet. So go back to those. So B took damage
and B fired weapon. So you see the fault of these
to the data-only Blueprints because I hadn’t put
any code in them yet. So I can switch it over. Now, repair it. OK, so now, that’s done. I’m just going to close
these and reopen them so that I get back to
that data-only Blueprint to show you what
that looks like. Doesn’t really matter.>>Victor: I think
there’s a way to switch here, but I don’t remember how.>>Michael: Yeah,
I think there is. But what we can do is we
just set these properties. So we created effect to play. So when we fire our weapon– don’t have anything that’s
really perfect here. We used the bomb for now,
but that’s probably not what we want to use in the end. Then, let’s go over here. Let’s get a shoot. [SOUNDS PLAYING] That sounds good. So go ahead and export that. And you can also hit
mutate, which will basically stay roughly where it was, and
then tweak it a little bit. And so you can get
variations that way as well. So we’re just going
to grab two of those. Then, back over here
in our audio folder, we can import them. Then, we can create a cue. Oops. Oops. We want a wave player. I’ll just copy this one. So now, we’ve got
our 8 and our 9. And then, we can do– that’s got some variation. Then, we’ll do a modulate. So now, it’s going
to pick randomly between one of these two. And it’s going to further
shift it a little bit more just so your shooting sound
doesn’t sound super repetitive. So we’ve got all that. Now, we can plug that in here. OK, so we’ve got these two. Then, this third thing,
I’m going to go ahead and– this is something
I made earlier, and I’ll explain how to
make that in just a minute. But go ahead and hook it
up for the demonstration. So now, our Fired
Weapon Blueprint is going to play a
sound, play an effect, and do a camera
shake once it spawns. So we would go back
to the player pawn. So down here is
Input Action Fire. So whenever you fire, right
now, it’s spawning a projectile. We could actually put
this in a projectile. So the projectile owns what
does it feel like to spawn. But for right now, we’ll
go ahead and spawn it here. So we’re going to pick fire. And so what we
probably want to do is we probably want to
pass in the instigator or make a expose on
spawn parameter of who caused this cue to happen,
so this pawn or whatever. Right now, we’re not
actually using that. We’re just using the location. But if you make a more
complicated cue that’s like, OK, now you’re on
fire for five seconds, or you make a cue that’s
you have a glowing halo or something, you need
to know who you’re going to attach it to basically. And so you can pass
that in as part of this. OK? So now, we’ve got
this hooked up. So when we run, that’s
a little overkill. But you can see that firing
is definitely a lot more interesting than it was before.>>Victor: Yes.>>Michael: Yeah. So we can turn that down. But for right now, let’s just
go and pull the particle system off so that we can show
off something different. So I’m just going to get
rid of that and play. And so you see I had
to stop and do that. Let’s go ahead and change
it back while we’re playing. So remember that
setting I talked about?>>Victor: Yeah.>>Michael:
So now that we’ve made this new base Blueprint
class, we can opt that in. So now, we can edit those
Blueprints while we’re playing. So we can go back to
Editor Preferences.>>Victor: And
in this case, you know that this Actor will
never exist in the world.>>Michael: Yeah,
they’re always transient. But even if they
exist in the world, it does actually handle that. It’ll replace all
the references.>>Victor: OK.>>Michael: It’s that if you
have certain life cycles that are not in something
that the Place References Archiver can get to. So hard to explain exactly
what those circumstances are, and that’s why it’s
still experimental. Once we can make it a little
more foolproof to use, we’ll probably turn
it on by default.>>Victor: Cool.>>Michael: Now, we can
pick base and blank cue. So now, we’ll be able
to edit this actually while we’re in PIE. So let me go ahead and make
this play in a new window. So Windows supports
snapping windows. So I can snap this to
the left, and then snap the Editor to the right. So now, I can see it here. And you can hit Shift-F1 to
get your mouse cursor back, which is a little bit
easier than if you had to do the tilde stuff before. The Shift-F1 lets
you get it out. And then you can click
right back in to get there. So you can see we’re firing. No effect. But now, I can actually
be tweaking this stuff while I’m playing. So just close some of these. So now, you can see
it’s actually not grayed out anymore. So I can actually adjust
stuff while we’re here. So I could just switch
this over to here.>>Victor: Oh, you
didn’t have to compile there.>>Michael: Yep, but
for just setting properties, it will actually propagate.>>Victor: OK.>>Michael: Yep. But this can make that
iteration time a lot faster. So in this simple game, there’s
not a lot to run around. But you can imagine if you’re
making a game as a platformer, you’re halfway
through the level. You don’t want to have
to run all the way back from the start of
the level every time. And so this can save you a
lot of time on iterating. Another thing you’ll see right
now is the camera is shaking, but it’s really subtle. Let’s say this cone
launcher is meant to be like really meaty and powerful. So let’s adjust that. So I made this Camera
Shake Blueprint earlier, and we can have a look at it. And it’s got the
same setting where it’s allowed to be
modified while we’re in PIE. And so all the camera
shake modifier is is you just create a Blueprint based
off of the class camera shake. And then you’re basically
just using it as a data asset, like you’re setting
properties on it. And so it’s got all
this different stuff. Right now, it’s doing a little
bit of shaking in all the axes. And then it’s doing a little
bit of FOV oscillation– actually, none right now. So let’s turn this up. So what this is going to do is
it’s going to make it punch in. And so now we can see. But that on its own
doesn’t feel that interesting. Oops. I accidentally quit. So let’s up like
the roll, pitch, and yaw just a little bit. So we’ll just make this–
let’s try 3 on each of these and see what that looks like. That’s definitely a
little more impactful.>>Victor: Yeah.>>Michael: Like I was saying, this is the kind of thing you
can spend an entire jam just iterating and tweaking on. So usually, what
you want to do is you want to get to a first
pass that is good enough. And then, you can always come
back later and polish it. Because your opinion will
also change as you play. Like, man, this
is getting to me. It’s too much, or it’s
not enough, or whatever. So don’t spend too much
time on your first pass for this kind of stuff. But our original
thing where we wanted hit react to feel better,
it’s still not using that. So don’t forget to change that
to fired one of these cues, just like the other one. But one thing I didn’t talk
about or didn’t demonstrate is the cue that we spawned
is just sitting there. It’s just going to live forever. And so you’ll actually probably
want to clean it up. And so like the quick, dirty
jam way is to just make a delay or set the lifetime of
it, and then the asset will destroy itself. The nicer way would be
to like actually query the length of the
particle system and the length of the sound cue,
and take the max of all those, and then destroy themselves
when all of those are finished.>>Victor: I think you can
assign an event dispatcher.>>Michael: Or
you can use a– yeah. And then you’ll just vote. When all three vote that
they’re done, I’m done, so therefore I can go away. Right now, we’re not going
to worry about the leak. And honestly, if you
did this in a game jam, you probably wouldn’t notice.>>Victor: You’re
probably fine, yeah. It depends how long.>>Michael: How
long and how much. If you have a bunch
of different things off in the world that are like
spawning something every couple seconds, it can add up.>>Victor: Like an
Gatling gun or something.>>Michael: Yeah. Another thing to watch out for with these cues is if you do
do that thing where you measure how long does it take to finish,
if it’s a looping particle system or if it’s
looping sound cue, it’s never going to finish. And so then, you
have to be careful where, OK, if you
spawned one of those, you need to make sure that
you then go and clean it up. And we’ve actually
added safeguards in the Engine when you’re
using the gameplay cue system I mentioned, where a
gameplay cue that wants to play a looping sound that’s set
as a burst will be like, no, this is an error. I’m never going to
clean myself up.>>Victor: OK.>>Michael: So just
a second here. One other thing that we can do
when you step into this fire is, right now, we’ve got the
player taking a hit react. But maybe we actually
want to do something where it’s visible on him too. So we can grab the Blueprint. So just one other
key shortcut I did there is when you select
something in the Editor, you can hit Control-E
to just immediately go to whatever the authoritative
asset for that is. So for a Blueprint, it’ll
open the Blueprint Editor. If it were a Static Mesh, it
will open Static Mesh Editor, so on and so forth. And you can also hit
Control-B, which will find it, which basically just
puts it in the browser. So those are really useful
for like figuring out what is this thing
in the world, where does it go if you don’t
have the Details panel open. So in here, back over here where
we’re playing the sound effect, we can do something
else like set material parameter on the player. So we can see what the
player’s material is right now. It’s just this MI
character, which is just overriding the body color. And then the master
material is here. So let’s just add
a pulse to this. So one of the easiest ways to
do pulsating, oscillating things is a sine wave. So we can just drop down
a sine node, wire in time. So that’ll make it go up
and down based on the time. And then we need to
do something with it. So we’ve got body color. Let’s create another color. Let’s call it hit color. So now, the player is going
to flash this color when they get hit is our goal, OK? So just make that– I’ve actually painted
myself in a corner because I made the
pawn red already. Maybe we’ll make him
actually flash green because he doesn’t like green. So now, what we can do
is we can interpolate between these colors
based on the sine. Now, by default, a sine is
going to go from minus 1 to 1, which is not what we
want here because we want to 0 to 1
value for the lerp, so we can do a scale bias. And the default
settings for this node actually do exactly
what we want. We don’t have to adjust it. But if you weren’t
sure what they do, one thing that’s really
cool is the debug node. So you can pick debug float
2, 3, 4, or just debug scalar. And so what this
will do is it’ll let you wire a number into it. And then, usually, you want
to map that to a color. So in this case, let’s just
break this other length so we’re always going
to get this input color. So once it finishes
compiling shaders, we’re actually going to see– It’ll print a number
directly in the material. So this is great for
trying to figure out what is the range of this? Do I have the math right? Is this doing what I expect? And you can see now that’s
going between 0 and 1, which is what we want. But we actually probably don’t
want it to go quite that much. We don’t want to go all
the way to the other color. But for now, you know you
can always add a multiplier or add a remap or whatever. So let’s go and
hook this back up. And so now, what
that’s going to do is it’s just going to
constantly ping pong back and forth
between these colors. But we only want to do that
when we’re actually hit. And so what we can do
is add another multiply, which is going to
multiply by basically what are we wiring into here. So a lerp is just
going from A to B when alpha goes from 0 to 1. And so what we’re going
to do is we’re just going to make alpha always
read 0 when we’re not hit. And then, I’m going
to right-click on this and convert to parameter. And this will let
us set it from code. So we can call this hit effect. So right now, it’s 0, so we
don’t see anything happening. So I’m going to go and hit
Apply, save this material, and then I’ll go back
over to the Blueprint and actually use it. So in the construction script,
what we can go ahead and do is grab the mesh. Then, we can create
a material instance. And then, we’ll go
ahead and save that off. So what we can do is, now,
we can grab this and set properties on it later on. So back over here,
when we’re getting hit, we can grab that variable
we just added, and then do– And now, we pick that
same property name that we just added over here. So let’s see what we called it. We called it Hit Effect Active. Is that the one? So right now, what’s
going to happen is I’m going to get to the fire. And then he’ll just change
to be playing this forever. We’re not setting
it back, but just to show what it looks like. [SOUNDS PLAY]>>Victor: Nice.>>Victor: It’s very clear
something’s happening there.>>Michael: Yes. You also see that he
lost his default color, probably because I maybe didn’t
wire in the default color.>>Victor: Are we using
the instance or the master?>>Michael: We should
be using the instance. Let’s just double check here. Mesh– yeah, we’re
using the instance. So oh well, we’ll
worry about that later because we’re running a
little short on time right now. So you can see,
OK, he took damage. Because he’s now not red, we can
actually make that damage red. So we’ll go back to material. There we go. But we want to turn it
back when we’re done. So what we can do is– there’s a couple
different ways to do this. I would probably actually
drive it with a timeline. But one real quick
thing you can do is you can just
throw in a delay. So we want it to
happen for 0.2 seconds. Then we want to set it back. So like I was saying,
this is not always the cleanest way to do
these kinds of things. But for a game jam,
you do whatever works, and then you move on
to the next thing.>>Victor: Ship it.>>Michael: Yep. One great technique for
driving this kind of stuff is you can use timelines or
you can use curve assets. And then, that lets you
just click on points and then shape it to do
exactly what you want it to do. And so now we can see that
I run through taking damage. It’s just really clear
that he’s taking damage, but it’s not staying
stuck on him forever. So that’s definitely
feeling a lot better. These coins, though,
they just disappear. So that’s not very good. So one last thing we can do is
let’s make the coins actually snap to you. It’s kind of like the coins
flying into your backpack or something like that. So right now, it’s just
got this silly overlap. Oh, that’s actually
one of the things I want to talk about real quick. So right now, they’re
actually blocking projectiles. And if we had other moving
characters that weren’t pawns, they could trigger them too. So the collision’s not
set up right on these. So you can edit
collision on something by going down to picking
a collision preset. And so the Engine ships with
a number of collision presets. This is one of the least well
understood parts of the Engine, and actually, it can be a
little bit daunting to get into. But it’s also really powerful,
and it makes it a lot easier to have consistent behavior
throughout your game if you go into your project
settings and set some stuff up. And so I made a couple earlier. So we go to Project
Settings, Collision. You see that there’s this
list of presets here. Oop. I accidentally– I’ve– I can’t get to the title bar–>>Victor: Maybe 1 pixel. Yeah, you had a pixel. Do maybe windows down. That worked.>>Michael: There we go. Sorry about that– minor
technical difficulties. OK, so now, we can
see that there’s these two at the
bottom that are– you can see it’s got
a different icon. These were added at
the project level. So I created a
projectile, which is what’s used for the projectile. And then I created one for
what I call player sensor. And so you can make
a new one here. So let’s make like
another one that’s the same as player sensor. And so I’m going
to define this to– by default, it’s query
only because I’m just trying to sense. I’m not trying to
block the player. And the object type– I’m going to make this– you can pick different things. But we’ll make this
be world dynamics since we’re probably sitting
somewhere in the world. And now, you pick whatever your
default collision response is. So we actually want it
to ignore everything. And then, we turn on for
pawns only that we overlap. So now, whenever something
hits this sensor, it’s not going to
block anything. So it won’t block visibility,
or camera, or whatever. The projectiles will
fly right through it. But if a player walks into
it, then we know about it, but we don’t prevent the
player from walking it. So Accept. So I just added another
one to the list. So now, that’ll show
up when I’m over here. So where I pick
collision presets, I can actually say player
sensor, for example. So now, I’ve changed
this to player sensor. We’ll see that when
I fire stuff at it, they just go right through. But the pawn still triggers it. Let’s go back to– OK. So now, this is what’s telling
the player that it scored. And probably,
you’d actually want to call a function here so
that you could do something like play a sound, like
a clink or whatever. But for right now,
we’ll just do– let’s make it go
into the backpack. And so at the moment,
we’re just immediately destroying the Actor
after we gave it a score. But I had in here a
Set Actor Collision Enable so that it’s not
going to do anything once it’s triggered. Once it starts, nothing else
is going to trigger it again. You can also use a gate or
something like that as well. So then, what we can do
is we can play a timeline. And so a timeline
basically just lets us define some curves inside. So we can add a curve that
it is how high and how close. And then, let’s add
one more for scale. So scale will start
at 1, and then, we’ll make it go down to 0. Or actually, not quite a 0. So this will make it
start big and go small. And you’ll notice that I’m
making everything 1 and 1. It’s really helpful to
make timelines normalized, because that way, if you want to
change the scale a little bit, you don’t have to go in and
reshuffle all the points. You can just multiply
the output instead. And then, that way, it basically
lets you tweak it a lot faster. How far will be a similar thing. We’re going to start at 0,
and we’re going to go to 1. And then, how high– we’re actually going to
go up, and then back down. So we’ll start at 0. Then we’ll go up to 1. And then we’ll come
back down to there. So basically, it’ll start
at the height of the coin, and then we want it to go
to the height of the player. So that’s a simple effect. And so we’ll try this out
and see how that feels. And we might tweak
it from there. So now, we’ve got an
update pin, and we’ve got these three parameters. So now, we need to do
something with them. So I want to move
the Actor from where it was to where it needs to go. So I need to know where it was. So I’ve actually created
a variable already. So I can set the start
point as where is the Actor? So we’ll go in and grab
the start point and play. I also grabbed the target
Actor, which is basically, what is the pawn
that overlapped us? Right over here. That way, if the player
keeps moving around, the coin will follow them instead of it being
moving to where we were, it’ll move to where we are. So now, every time, we can
figure out where we need to be. So we can lerp. So we can lerp from where we
were to where we want to be. Let’s just only do this and
see what that looks like. And then, when we’re
finished, we still actually want to destroy the
Actor, basically once it finishes this timeline. One last thing I want to
check is use last key frame. So instead of it
always being length 5, it’ll shrink it down to whatever
the last interesting point you had in the timeline.>>Victor:
And even if you go back and you make
it a little longer–>>Michael:
It’ll auto update.>>Victor: Yeah.>>Michael: OK,
so now, we can see– Well, it’s OK. It’s not very good. So obviously, we want
this to play a lot faster. So all timelines are
actually also variables, and so you can grab it. You can get access to it. So I’m just going to make
a little more room here because we’re getting messy. So I got the
timeline 0 variable. Now, I can call set rate. So I can make this
play faster or slower. So we normalize it to 1 unit. So basically, we can
just do 1 over the length that we want it to do. And then, that will make
it play at that rate. Do 1 over, and then just
promote this variable. We can call this
CoinToPlayerRate. So let’s make that 4. Instead of 1 over, you
can do this either way. But actually– yeah, sorry. CoinToPlayerDuration
is actually what it is. So instead, we actually
want this to be 0.2. Let’s try that. And of course, we didn’t call
it, so it doesn’t work so well.>>Victor: That’s
an important step.>>Michael: Yeah. Let’s do that. All right, that’s feeling
a little bit meatier.>>Victor: Yeah.>>Michael: But let’s now take advantage of those
other two curves I did. So what we can actually
do is set Actor transform. And then, we’ll split this pin. And so you can either
do a make outside of it, or you can use split to
actually break things up to set multiple
properties at once.>>Victor: It’s also
just how you prefer to lay out your Blueprints.>>Michael:
So now, I’m going to go ahead and do an add. I’ll explain this
bit in just a minute. So now, we’ve got
a scale wired in. And so we can make a
scale from the how big. So now, it’s going
to shrink down as it comes into your
inventory, basically.>>Victor: Look at that.>>Michael: That
feels a lot better. But let’s get it
flying into you. We want it to come up in
the air and come back down. And so we’ve got how high. So we can multiply
that by float. Then, we’ll split this further. So we’re going to make
it go up and down in z. So we can make this,
say, let’s try 150 and see what that looks like.>>Victor: Swoop.>>Michael: So now,
that’s feeling pretty good.>>Victor: Yeah.>>Michael: Let’s just keep on
making it a little bit neater. So we can make these curves a
little bit more interesting. So we can add kind of a
bit of wobble to the scale. It might be going
a little bit faster than we can actually see it. You can get a lot
of interesting juice from doing that kind of stuff. And so I’m going to go ahead
and skip making it rotate. But I’ll show you what
it looks like if I did. So here’s one I made earlier.>>Victor: It’s been
cooking all night.>>Michael: So just
wire that in back up here where we did this. So we’ll just skip
all this other stuff. And it’s going to go down to the
version that I’d made before. And this won’t actually
score, but it’ll show you. Oops. Well, messed something up there.>>Victor: It looks
like it’s gone to 0.>>Michael: Yeah. Oh, that’s actually
probably what it is. It probably missed
the set point. So if we just actually
break it right here, that’ll probably do the trick. Oh, and the Target Actors. Yeah, that’s the other
thing that’s not there. So we’ll just skip these two. There we go.>>Victor: Nice.>>Michael:
So now you can see it’s flicking into your
backpack like a coin. So it’s really easy to just– we spent not even
10 minutes on that, and now it feels
completely different. It just makes the game feel
a lot more fluid and alive. Those kinds of
techniques can really start to make your game
start to come together.>>Victor: They all add up.>>Michael: Yep, absolutely. So let’s go ahead and
do some questions.>>Victor: Yeah, we have a few. And I thought one that came
early in the stream was just general, just
general question. It’s kind of interesting. As a student, how do I know
I will get something back if I spend time learning Unreal?>>Michael: There’s no
guarantees in life, I guess, is the short answer. Whatever you spend time on, you’re going to get the
knowledge back from doing that if nothing else. So you will know how
to do something you didn’t know how to do before. And usually, those lessons are
applicable across a broad range of things. For Unreal specifically,
lots people use Unreal for game jams. Like Unreal, Unity, and Godot
are the three biggest engines that were used for
Global Game Jam this past year, for example. A lot of those ideas
are transferable. And obviously, I think
it’s a great thing. We like to hire people
who have Unreal knowledge. I mean, it’s not a hard
requirement for somebody we’d want to hire, but
it’s absolutely valuable. And whatever your goal, like
if you want to make games or whatever,
now you know something in order to make games in.>>Victor: And you’re right. The idea of how you set up a
gameplay framework, or a game loop, or like you were talking
about earlier how you split different functions of
logic into different Actor sets, it doesn’t matter
which engine you’re in. It goes across all of them. They were curious if
the 20 jam entries that you’ve done if they
were all using Unreal or if you were working
in some other tools.>>Michael: So when I
first started doing jams, it was actually before UDK. And so I used to use XNA, which
was a Microsoft framework in C# that allowed you to
do 2D and 3D graphics. And it was just this
little immediate mode API to draw a sprite here
or add a mesh to the scene or whatever. And so first several
jams I did in that. So all those 2D games
that I showed off there at the beginning
were done in XNA. And then, when we
did you UE4, 4.0, and it was publicly
available for everybody, that’s when I started
using UE4 for jams. Because now, it’s available. Anybody can download it. I can work with somebody who’s
not working at Epic in order to also use it. So I’ve been using
UE4 for game jams since, I don’t know, 2015,
2014, something like that.>>Victor: Cool.>>Michael: So I used
it for basically every jam I’ve done since then,
except for that one year where I made a card game. Because there, I
didn’t use any engine. I used markers. [LAUGHS]>>Victor: Someone, I think
they joined a little bit later in the stream, and
they were curious how you made the window red.>>Michael: Oh, yeah.>>Victor: If you wanted
to just show it off again.>>Michael: Yeah, sure. So you can make– it’s in the Project Settings. Or sorry, Editor Preferences. So under Appearance, there’s the
Editor Main Window Background Override and Child Window
Background Override. And you pretty much always
want to set both of these to be the same thing. They’re just split out
for technical reasons. So now, we can make this
blue, and make this blue. So now, the project
I’m working in is blue. So that’s really
useful for just when you’re running multiple
copies of Unreal, keeping them separate. Another thing you can do– this doesn’t fix anything
or make anything better. It’s just a silly
little polish thing– is you can actually
change your splash screen. So when the Editor
starts up, you can set what is the image
that the Editor uses. So that’s actually
under Project Settings.>>Victor: The amount of times you open and close
the Editor, though, makes this a nice little– I don’t know. It’s polish and juice
for the project itself.>>Michael: Yep, and
so then, you can just import a different image here. And if you hover
over it, it tells you where the default image is. So you can use that to get
the dimensions and size, although it doesn’t have
to be exactly that size. But that’s something
you can basically use that like a template and
then just paint on top of it if you want to make– customize your Editor
a little bit more.>>Victor: How
long do you think you should whiteboard
your ideas before starting in the actual project?>>Michael: I think
that really depends on what your team composition
is and how integral they are to the thing, I guess. So if you’re trying to make
like a narrative-driven game or something like
that, or you’re trying to tell a
story in the game, you’re going to spend a
longer time figuring out exactly what you want to do,
like what the story beats are, and stuff like that. Whereas if you’re
going to be like, I’m going to make a game where
you go shoot some robots, you may be able to
jump into the game development a little bit faster. And you might do
planning as you go. I think in both cases,
it’s important to realize that your initial plan may
not be what you end up making. So it’s always OK to
pivot halfway down. And so you might be like, well,
this isn’t coming together. Let’s huddle together
as a team and try and– what do we need to do? Or, OK, we got our
initial version done. Where do we want to go next? And now, have that
conversation again of what ideas do we want to do? Different game jams
do different things. Some game jams,
you’ll come as a team. You already know who
you’re going to work with. You may not know what you’re
going to work on because you’re waiting for the theme. Other game jams will do
a team building exercise, where if people come
and they don’t already have a team or
nobody has a team, then you might do
something like, OK, here’s what the theme is. Now, people break up into groups
and discuss amongst themselves what are some ideas. Then, usually do a pitching
process, basically, where anybody who has an idea– I want to make this game, or
I want to see this game made. They can argue or describe
what they want to do. They can stand up
and pitch that out, and then you can see if
other people are liking. Oh, that’d be cool
if you did this. Or I want to work on that too. And then you can start
to group together.>>Victor: I heard
of a Global Game– or think it was at Train
Jam I think you mentioned that– where someone
had the entire train pitch in towards the one game.>>Michael: Yep. I think they were doing
a meta game almost, where they basically
had poster boards. And they would go
around and ask can you add a rule to one of these games
that’s on this posterboard? And so was able to like bring
everybody in together to make this one project basically.>>Victor: That’s very cool.>>Michael: It was
a very cool idea. Every year at the Train Jam, there’s always one
or two people who are sound artists
or sound designers. And they will literally
just walk around with a giant sign that’s like,
I will make audio for your game. Because they’ll
often end up working on several different
projects instead of just one project the entire time.>>Victor: In Train
Jam, there’s no competition. So there are no rules in
terms of how many people you can be on a team.>>Michael: Exactly,
although there’s always practical constraints.>>Victor: Yes.>>Michael: If you’re
working on a team together, the more people you have,
the harder collaboration is, the harder merging
assets, the harder just getting everybody
on the same page is. So usually, four to
six people, I think, is probably the sweet spot
for a game jam project.>>Victor: And
don’t be afraid to bring on people who are new. You never know
what they might be able to bring to the project. They were curious about when you
were working the material there on the sine. Is there a way to
trigger the start when hit so the sine
starts from minus 1?>>Michael: Yeah, so
what I was using right now– or let’s just open
up that material. So I’m just using this
time as input data. What you can actually do is you
can send down as a parameter– The hit effect active could
actually be a time to start. And then you can subtract
that off the time. And then, now, you’ve you
synchronized the phase to whatever you want it to be. And you can also actually
use that same parameter in the material to turn it
off after a period of time. Because what you could
do is send the time that it started at and
subtract that from the time. Now, you know it’s 0
to 0.2 or whatever. And then you actually
lerp it back down directly on the Blueprint. So that’s one thing you can do. Shove the work over to the GPU.>>Victor: Nice. Are jam games enough to get
a game designer position in AAA games?>>Michael: I couldn’t
really speak to that. I’m not hiring for
game designers. I interview programmers. And so what our game design
team looks for from a designer I don’t know for sure.>>Victor: I think
it would depend. I mean, I wouldn’t say
that it’s an absolute no. I mean, there are lots
and lots of game jam games that are astonishing
in terms of what they were able to accomplish
in such a short time.>>Michael: It was
just a I can’t say. It’s not a no. What I will say is I’m usually
positively impressed by– it’s a good thing when I see
people have game jam projects. Or it doesn’t have to be a
game jam project, but just extra projects that
they’ve worked on that. It shows that
they’re interested. They’re doing the
lifelong learner stuff of trying to improve their
skills and stuff like that. So that’s always
a positive for me.>>Victor: And
it’s fun to work with someone who has passion for
what you’re working on, right? Who does it in the spare
time, not getting paid.>>Michael: Yeah.>>Victor: Someone’s asking if we were planning on giving a
talk about packaging games. I don’t have anything
planned at the moment directly in terms of that. But I will continue to try to
do these more general streams where we discuss typical
workflows and things that are important that you might
not pick up going through Unreal Online Learning,
and et cetera. What do you recommend for
a shared repo for teams? I found it difficult to
set up Git LFS on site.>>Michael: So what
I’ve done in the past is either use a web-hosted SVN. So DreamHost, I think, has
just a one-click deploy to create a SVN repo. And so that’s what I normally
use for Global Game Jam. Train Jam, you have no internet. You’re going through
canyons and stuff, where you have no cell service,
no internet and a lot of times. What I’ve done in the
past couple of years is I actually carry a
little single-box computer, a single-board
computer about that big that I actually run a
local copy of Perforce on. And Perforce has a
free license if you’re using no more than five users. And so I just set
up Perforce on that, and then it’s hooked
up to a router. And so we just hook up our
laptops to that router, and then can use
Perforce on the train.>>Victor: That’s good. And you can bring that last
resort to any other jam as well. They might not have it. Those were all the questions
that we had for today.>>Michael: OK, cool.>>Victor:
Michael, thank you so much for coming
on and showing some of your tips and tricks. I learned a lot. I hope chat learned a lot. It seemed like it. They said that they were amazed
like six times about some of the little
tricks that you did. And it was an interesting quote. They were saying is it me, or is Noland’s cadence
very Bob Ross style? I just gotta say,
happy little typos.>>Michael: There you go.>>Victor: That was great.>>Michael: We’re just going to
paint a little camera shake here.>>Victor: Yeah, a
little camera shake, yeah. Curves in the timeline. Yeah, happy little
auto interpolation. That’s great. Thanks, everyone, who joined
us today for watching.>>Michael: Have a good day.>>Victor:
Next week, we will be going over network
replication fundamentals with Michael Prinke, one of our
technical writers here at Epic. And so if you’re
interested in how to get started with making
networked multiplayer games in Unreal Engine, you
should tune in next Thursday. As always, make sure to check
out your local user groups. We are doing a
big revamp when it comes to how that is managed. So keep an eye out for a
bit of an announcement. And the new site is
going to look really cool in terms of how you see
Meetups, where they are in the world, and so forth. And it’s a bit of a
new community there. We’ll be launching
that really soon. It’s a work in process. And as always, make
sure you follow us on social media for
all news Unreal. That’s where we post the
next Livestreams, what’s going on in the community. And I do want to mention that
we are not doing a Winter Jam this year, but we are
planning a different kind of contest leading up. And then we will
do a Spring Jam. So there will be a Spring Jam
this year, and it’s coming up.>>Michael: Actually,
that’s one other thing. Let me pull up a
site real quick here.>>Victor: Yeah, go ahead. We’ve got nine minutes
till complete curfew. We’re hitting the two hour mark.>>Michael: So itch.Io has a
website calendar, basically, where, basically,
people will put game jams that they’re running. And so as you can see
from this, there’s basically always a game
jam running or always many game jams running. So if you’re ever in the
mood to do something, you can always jump
into one of these. And you also notice not all
of these are a two day jam. Some of them, they run for
a month or things like that. That doesn’t mean
you should spend a month working on your game. It’s just more
like they’re trying to fit people’s schedules,
because not everybody can spend two days on a weekend
doing non-stop game jamming. You’ve got other things
you have to take care of. And so I think that’s actually
one of my favorite jam formats. Simple Jam was
couple of years ago, where it was like, no more
than five game rules, no more than five assets, and spend
no more than two days on it over a two week period.>>Victor: Oh, OK. So you have to clock your
time as you’re working on it?>>Michael: Well, it’s
not as rigorous as that. It was just more like,
I’m giving you two weeks because I know you’ve
got other things to do. But I don’t want you
to use the full two weeks, if that makes sense.>>Victor: That’s pretty cool.
I like that.>>Michael: I think Alan
has proposed Noon Jam, which is work between 11:00 and 12:30
on your jam for the next 15 years.>>Victor: Interesting.>>Michael: I don’t
think it’s formally posted, but he’s talked about
on Twitter before.>>Victor: OK. I’d like– curious to
see how that would go. Thanks for the little
tidbit about Itch. With that said, it’s time for
us to end the stream today. I hope you all had a great time. I know I did. I think Michael has shown us
some real cool stuff here. And so, with that said, we
hope to see you all next week. Have a great rest of the
week and the weekend. And rest a little bit. Like Michael said, make
sure you get that rest in so that your brain
can think properly. Bye, everyone.>>Michael: Bye. [MUSIC PLAYING]