Developing with Blueprints and Marketplace assets | Inside Unreal

Developing with Blueprints and Marketplace assets | Inside Unreal

>>Amanda: Hey folks, I hope everyone had
a fantastic week, and we have a few
exciting developments to share. In our latest
Visual Disruptors Podcast, FXGuide’s co-founder
Mike Seymour speaks to Stiller Studios
CEO Patrik Forsberg. As one of the most
technically advanced VFX studios in the world, they offer clients
advanced motion control and motion capture equipment
housed within a huge, pre-lit green screen space
all tied together with a live, real-time preview on
set courtesy of Unreal Engine. Forsberg describes how they help
old school directors work in a new school environment, giving them the ability
to see their live-action footage perfectly in sync
with their CG imagery. Visit our blog to listen
to the full podcast. The next evolution
of the Unreal Engine learning portal
is almost here and you can preview
the new experience now. Try out over 35 courses and take advantage of updates
such as improved search, progress tracking,
quizzes, and badges. Your feedback is critical to the
success of this new platform, so please feel free
to submit your feedback in the learning portal
or visit our forum thread
to join the conversation. If you have not heard, Epic Games and Twinmotion
have joined forces. Twinmotion, a high-quality,
easy to use, real-time visualization solution enables you to assign
PBR Materials set up lighting, and even choose the season
and the weather with just a few clicks. The best news,
our new version of Twinmotion is absolutely free to download
and use for all customers until November 2019. Find full details
and answers to questions you may have in our FAQ. Storm in a Teacup hopes
to turn heads with its ambitious
fourth title, Close to the Sun, a horror
adventure loosely centered on the works of Nikola Tesla.
The Unreal Dev Grant recipient, sporting a brooding, steampunk
aesthetic, follows Rose, who must rely on her wits
and puzzle-solving skills if she wants to survive
a creepy voyage on the fictional
floating ship. Learn from founder
Carlo Ivo Alimo Bianchi, who has worked
at Ubisoft, Crytek, and Square Enix
in this interview. He shares his reasons
for venturing out as an indie developer, the benefits of developing
with Unreal, and what the Unreal Dev Grant
meant to him and his team. Now, onto our top weekly
karma earners. Many thanks to Everynone, Ikav, Stwyford, Shadowriver,
Nebula Games Inc, IndieGameCove, Bariudol,
norlin, and KristofMorva. They have jumped in on AnswerHub
to help their fellow devs. If you answer questions there, you too could see
your name up here. Our first incredible spotlight
of the week is Koral, a love letter to the ocean.
Dive into the beautiful, underwater world
as a sea current and solve puzzles to bring
coral reefs back to life and spread the beauty
of the oceans in the different
sea ecosystems. The Dev Grant recipient
has also created an incredible making of video of his team’s
adventure at sea. This is all out now. Now, to take a look at Jump, a solo, student-animated
short film in both 2D and 3D. The 3D elements
were created in Unreal with the 2D overlaid on top. Jump has a great, unique feel,
and I hope we can see even more blended projects
like this in the future. Our final spotlight this week is
a project from Embark Studios. They have created
a short blog series on how they have
leveraged photogrammetry with remarkable results as shown
in this beautiful desert biome. Learn about their process
and their series linked below. Thanks for joining us for our
News and Community Spotlight. ♫ Unreal logo music ♫>>Victor: Hi, everyone. Welcome to the Unreal Engine
Livestream. I am your host, Victor Brodin.
All the way from Seattle, we have North American
Evangelist Christian Allen. Thanks for coming
on the show, Christian.>>Christian: Hey, everybody.
How you doing? Thanks for having me here.>>Victor: Before we get started, I would like to let
everyone know that we will be handing out
Steam keys to Koral, which, if you paid attention
to our Spotlight that we ran earlier, it was
the first one of the day. Keep an eye out in chat,
and make sure to grab them. As always,
we will be pasting images, so you actually have
to type them in manually. It does not matter what fancy
bots you have going there. To snag some keys, you have
to do it the old-fashioned way. What are we going to be talking
about today, Christian?>>Christian: Today, we are
going to be going over a demo project that I built called ParaChess. It is created all in Blueprints
mainly using the Paragon Assets that are free
on the Unreal Marketplace.>>Victor: That is awesome. We chatted a little bit
earlier about rapid prototyping using
Marketplace Assets, and that has been a big part
of this project for you, right?>>Christian: Yeah, definitely. When I started the project,
I wanted to have a platform for experimenting with
different things in Blueprints to present different concepts
in Unreal as new features
and stuff come online. I wanted a test bed
of a single game instead of having a bunch
of different little showcases that I would do and kind of
throw away and start over again. I wanted something
that I would kind of build on. Even just getting
started with that, I very rapidly
or very quickly learned some of the benefits
of using production-ready Assets doing rapid prototyping. You learn a lot of gameplay
elements, performance wins. There is just a huge host
of things that you get from using high-quality Assets
in your prototyping that you do not get
out of grey boxing.>>Victor: Yeah, we were talking
a little bit about the fact that you can
actually use Assets that are the poly count
that you would like, the instruction cost
for your Materials and everything off the get go. Even though you are
in the prototyping phase or you are building out
the core framework of your game, you are still sort of
in the realm of the cost of all of your Assets
and mechanics in the game. You can then find and fix
performance issues early on instead of afterwards
once the artists get on board, or the designers, et cetera.>>Christian: Yeah, I think
that is something that people really overlook, is that the old school way
of doing it is kind of you grey box
everything, you get your prototype up
and running, you do play test after play test
after play test over months and months,
however long it takes. Then once you are
kind of satisfied with that, the art team comes in
and starts arting things up. That is generally when you start
running into performance issues and optimization issues. By starting with production
level Assets, the example that I use is that if you were making
a third person shooter, you could sit down with
your art team very early on, your art
and your technical team, and agree that, for example, the Paragon Characters
that you chose like Shinbi, that could be the model
for the quality level that you are going to hit
as far as poly count and amount of Materials
and memory cost and all of those things.
You can kind of sit down and go, okay, we are going
to be in that range. That is where we are
going to be at, maybe we are going to be
a little higher. But you can do your testing with
those things actually loaded, and then your play testing
and all those kinds of things, and then as—
Oh, I am getting a visitor. I am on livestream.
Sorry about that. As the art Assets
come online from your team that are unique to your game,
you can swap those out without having those kinds
of performance hitches. You also might run into issues that you might not
have foreseen. One of the things that I ran
into as new Paragon Characters were coming online
as we released them on the Marketplace, I was of course really excited
to bring those into ParaChess. I decided that the way
I was going to do that was to have different chess sets
that you could choose from. Well, there are a lot
of Paragon Characters, especially when you take
into account the different Skeletal Mesh skin variations
for the different Characters. I very quickly realized
that especially as I am working to bring this prototype to consoles
and things like that, that it was not going to be
feasible to have all those Characters loaded into memory
at any one time. I went back and did some
research on soft object loading and how to handle
that in Blueprints. I went ahead and built a system
to handle that. Again, that is something
that those kinds of things in the older way
of thinking about things, that might be not something
that you consider. You might think, well, I am going to have
X number of Characters and I will build
all my standards to that. Then all of a sudden,
you want to do DLC or you want to add more
Characters or have expansions. Then all of a sudden
you are running out of memory. That is a great example
of something that you can get in early on and get an idea of what
your budgets for your Levels and your Characters
and your animations and all these various different
things are going to be, and then just swap out those
live Assets as they come online.>>Victor: Great. Do you want
to jump into the project?>>Christian: Sure! Yeah, I am
happy to. I will have to look over
to my screen over here, so I am not ignoring you.>>Victor: It is the classic
streamer point of view, I would say.>>Christian: Yeah, exactly. This is ParaChess
at its base Level. Essentially, not to give it away
too much, but it is chess. I did not make up
a new game here. Normally, when I present this,
I have this whole pitch about how I came up
with this great new idea for a turn-based strategy game. But you folks are probably
a little more familiar with it. You kind of gave it away
that it is a chess-based game. I chose that
for a specific reason. When I started doing prototypes
for presentations— I am a game designer by trade.
I have been working in AAA and indie game development
for years and years and years. Like most game designers, it is hard for me
to present Gameplay to folks when I know
that it is not 100 percent. I would find myself, when I would sit down
to start doing demonstrations, I would be like, oh, I am going
to work on a space flying game with randomized planets. Then all of a sudden,
I would go down a rabbit hole of implementing
a randomized planet system, and then I would want to get
the effects on the ship just perfect
to relate to different things. I just naturally start
to feature creep. When I decided
to put this together, it was timed
right along the lines when we were releasing
the Paragon Assets. I said, well, why don’t
I pick an existing game and just build to that standard? The great thing about
that is one, it keeps you from getting
rabbit holed because you have
an existing rule set that you need to implement. You can just work
to that standard, much like a more standard
production environment where you might be working off
a design plan or production plan,
implementing a set of features. It helps you learn
prioritization, what is more important for both
demonstration and core gameplay. But the other thing
that it does is people understand
the core game concept, so I do not have to explain
what the game is. I can just demonstrate
how the Assets work and how the Blueprints work. That turned out
a really smart idea. It exposes you to a lot
of different things that you might not, again,
get into until later. You start implementing UI. You start implementing
different environments and getting concepts for that
going relatively early on that you might
put off until later. Especially if you think
as many games developers do. You think, well,
I have a plan for that. It is going to work out
just fine once I implement
this new environment or this new feature set. But you often run into issues
as you do those, so the earlier that
you can do them, the better.>>Victor: What do we have here?>>Christian: Yeah, I will go
ahead and just play the actual game. I will put it up to a resolution
so that you can see it. This is ParaChess.
As you may expect, it is chess. I have a suite of Characters. You saw I could choose
one of out of three sets, and I am continually
adding more sets to choose from. We have got the different
Characters represented: pawns, kings, queens, bishops.
That sort of thing. Each of them is represented by
a different Paragon Character. Then we kind of have themed,
color-based sets ideally with profiles that match
the different Character types. They all have
their own animation sets. Every Asset that visually
you see in this first Level is available for free on
the Marketplace to Unreal users. This is all
the Paragon Characters along with the Monolith
and Agora Paragon map set, which comes with
some free kite demos. Just recently, when we released
it for free on the Marketplace, I put in the GOOD SKY Blueprint and used that for
a customizable sky box. That is a really cool setup
that you can get. Gameplay wise,
I will go into gameplay mode. We have all of the logic built
in for the actual chess moves. As I select
the different Characters, the game highlights
what the legal moves are available
for those Characters. Right now, this supports both
mouse and controller input, although the input is
a little bit different for the Controller. I can get into that
if we have time. But I can move
Characters around. As you can see, we use kind of
a teleportation presentation. The Characters play
an animation. We play an effect, and then when the Characters
actually get into combat, you will see here
I have highlighted a Character. We have got a capture
move available. It highlights it in red. If I actually capture the piece,
then it plays a death effect and plays a little animation
for the Character coming in. One of the things
that I learned very quickly for what you just saw there was
that the animation time for the emotes,
which is what plays after a Character captures
another Character, really do affect the Gameplay
experience in chess. Something like you just saw
is incredibly fast. It can be really too fast
for the opposing player to really comprehend
what is going on if they are not
paying attention. I found out that something
like that was very short. Then we have much
longer emotes available for some of the more fleshed out
Characters besides the creeps. What I found out was that
while those are really cool, especially the first time
you watch them, some of them
can get too long. What I found was actually
probably about three and a half seconds is the ideal time frame
for a capture Character. Again, lessons that I learned
using real Assets. If I had been using chess pieces
and blocks and said, well, I will put in combat animations
at some point in the future, then I would not have
learned that lesson. We can move
the Characters around. There is Gadget again
doing one of her movements. Each of the Characters
has a set of emotes based on the animations
that come with the Characters. Essentially, it randomly chooses
between the different sets. Again, we have one
of the longer animations. While they look very nice,
they can be a little bit long. Yeah, so that is the basic
core of the Gameplay. We have all of the rules
set up for chess. Well, I am still working on
all of the rules for chess. We have all of the logic for the appropriate moves
for the Characters. That is all handled
in the board Blueprint. This is essentially
built out of two Blueprints with a couple
supporting Blueprints. The board has the logic for
actually constructing the board and all of the move logic
for the different Characters. I have built in the capture
logic or threat logic for the king, because of course
you have to be able to track when kings are under check. The next set of logic
that I need to build in that has not been built yet
is the logic for when a king is trying to move into a tile
that is under threat. One lesson
I actually kind of learned— I have said this quite a few
times when presenting this— in hindsight,
if I would have done this again, I probably would have done
ParaCheckers, because chess is a little bit
more complicated as far as the rule set. It has taken me longer to build
the actual logic for chess moves and different things like that than it has
a lot of the other basic systems to actually get the moves
and things like that. I have got that to build in, and then I have some special
moves like doing a rook, those kinds of things. But essentially,
all of the logic is in as far as highlighting
the available pieces. I definitely wanted to—
Because this is game design, I wanted to have
a good user experience so that I can play this
with my kids. As I am playing the game, it is almost kind of a learning
experience where I can, when we run a little cheat, move some Characters
around here. We can click on the various
different Characters and see what
their moves available are. The knights have
their appropriate jump moves and kings and queens
and things like that. This is something
for demonstration purposes I probably could have
skipped over, but again, it was
a really good logic exercise, a good optimization exercise
as far as how many computations I am doing at any one point, seeing how things like
that affect framerate and things like that. In the actual tile Blueprint,
that is where the magic happens. One of the things
about ParaChess is I designed it to be as efficient as possible. I wanted to do as few
computations as possible and have it as flexible
and as expandable as possible. Eventually, I have grand ideas
of trying out things like 3D chess
and stuff like that. I want to build the systems to be as development
friendly as possible. The actual logic for
“moving the pieces.” Which is an interesting
little sleight of hand, Is that if we look at the
main board Blueprint here, you will see that the board
is constructed of the tiles. The tiles is each one
of these units represented by this square. If I go over to the tile and go
to the viewport and zoom in, these are the fundamental pieces
that construct the tile Blueprint. We have the base cube
with the Material setting on it, which is the actual tile itself. We have a Skeletal Mesh that is
represented with the Character. We have the two Cameras attached
to it that are used for the Camera swapping,
for the capture effects. Then we have a couple effects
that move, and death effects are actually attached to the actual
Blueprint itself. Within the board,
even though to the player, we are moving Characters around
when we actually play chess, in actuality, nothing actually
ever moves in ParaChess. All we are doing is we are using
the game logic in the board, which is presented similar
to a Game Mode in a classic, first person shooter,
to tell the tiles the set of logic
that they need to know. When a player activates
a move on a board, we tell the last tile, i.e., the tile that
the Character is moving from, what it needs to do. Which is pretty much
the same every time. We just tell it that it is
essentially moving away. Then based on the piece
that it is moving to – because in this case, chess rules
are relatively simple because you are not allowed
to move into a friendly space. You can only move into either an
empty space or an enemy space. If you move into an empty space, essentially we just play
the move effect and then go on, because there is no point
in playing cool animations every single move. That would get really
repetitious really fast. But if it detects that there is
an enemy in the space, that is when we actually
do the sequence where we do the Camera switch,
we play an effect, while we are playing
that explosion death effect— Again, that is out
of the Paragon Assets that I have just done
some scaling on. We play a death animation, then we destroy
the existing Skeletal Mesh, bring in the new Skeletal Mesh
for the new Character, play the move in effect, and then start playing
the emote animation, and then as soon as that
emote animation is completed, that is what actually triggers
the Camera to return, the boards to swap, everybody
to return to their idle state. Essentially, everybody resets
once that is done. Is any highlighting
or anything is still active, all that gets cleared up. All of that is covered up
by those Camera swaps so the player
does not see anything. Now, one of the things
that I did learn pretty early on was that doing these cool
Camera effects when we captured
the Characters— Oops, I pressed
the wrong button. Wrong cheat code.
There, you just saw one. You saw a little
death animation. Do a little bit bigger one here. One of the things I run into
like with this pawn right here, we see the queen come in, and they play a cool animation,
and that is all neat. But if we let the board
come out here and we see where the queen
is placed right here, right adjacent
to that is another Character. That Character right here,
depending on its size, if it had been this big,
bulky rook over here, there is a good chance
that Character would have gotten in the way of that animation.
I found that out pretty quickly. Having a Character play
a cool emote animation is not all that exciting when all you can see is the back
of another Character’s head. What I do is I detect whether there is a piece
in the adjacent tile, and if there is, essentially
while the animation is playing, I check the piece
and then set the timing of this to the other
Character’s animation timeframe. I just hide
that adjacent Skeletal Mesh. When I first did it,
I initially hid the entire tile, and that worked great at 1920
by 1080 resolution. But then when you blew
it up to 4k because you had
a wider field of view, you could actually see
the missing tile drop out of the world
while I was doing that. Change it over just to hide
the Skeletal Mesh. Again, because all that happens
during those Camera transitions, unless I explain it to someone
that that is happening, your brain just does
not register that the other Character technically
should be in the way. Again, those are the kinds
of things that you are going to run into
using real Assets to prototype that you would not necessarily
run into if you are just prototyping with blocks
to get your core Gameplay in. Again, by having things not just
on performance and optimization, but on things like
scale of Characters— Choosing your largest Character,
your smallest Character, or if you are just going to have
one size human Character, just picking what size that is— Having those things
locked in ahead of time can save you a lot of trouble
and challenges down the road. You can imagine
in a first person shooter, you have got
your environment team making Levels and building doors
and all that fun stuff, and then all of a sudden,
here comes the Character team and they have on Character that is half a meter taller
than all the rest, and now they do
not fit through doors. Now you have to go in and, well, do we adjust all the doors
in the world? Do we adjust the Character’s
animation so they squat down? Do we have to come up
with some kind of special movement capability for them to move through
these tighter spaces? Again, by having
those things up front, hopefully you can avoid
of those things that you have to go back
and fix in development.>>Victor: Yeah, especially if
you would have had little cubes there. Then the Camera problem
would never have been the case.>>Christian: Exactly. You do not think about a lot
of the things that you run into when you get real Characters in
a game or real Assets in a game. You might not consider parallax. I come from
a shooter background, so I use shooter examples a lot. If you put in a third-person
Character of a certain size and scope with a very particular
arm placement for the weapons and you adjust your parallax for
the player aiming capability, that takes a lot of
tweaking a finessing. If you have not standardized the
exact height of the Characters, the exact height
of the Character’s, shoulders, the arms, and then how that looks
and feels in relation to your third person Camera
and cover if you are using a cover system,
how all that plays out— If you are just using
a default mannequin, which can be great
to prototype and test with, but if you are just using that
and your Character team is not on board with those
specifications matching up, you are going to have to go back
and re tweak all that. You are going to have
to re polish all the things like parallax and things like that,
Camera placement, cover systems. The earlier that you can have
finalized standards for your Assets
and development, the better. I mentioned before having
the different Character sets. If I come here to the tile, if I come here to my Set
Piece Mesh, this the logic. I need to clean up
this Blueprint a little bit. This is the logic
for swapping out the Meshes when we do the different moves. Originally,
I was just doing set Mesh, so I was just setting
the different Skeletal Meshes. But I ran into an issue
where certain Material values on Skeletal Meshes
would be inherited. If there were specific Material
settings on Skeletal Meshes and you started swapping them
between other Skeletal Meshes that had other custom
Material settings, you would sometimes
run into errors where Skeletal Meshes
would inherit Material settings from previous
Skeletal Meshes. I found it just was not
a good way to be constantly swapping these Meshes over
and over and over again. What I actually do is destroy
the Skeletal Mesh Component and use that transform, spawn in
a new Skeletal Mesh Component, and then set it
to the new one. Now because all the Characters
are preloaded, a benefit of chess— One of the nice things
about chess from a performance
planning perspective is that you start with the maximum
amount of Characters on screen that you can possibly have. That is going to be kind of
your worst-case scenario. Then as you play the game, you get less and less
Characters on screen, so your performance kind of
goes up rather than down, as opposed to a real time
strategy game where you start with less
Characters and continue to add. About the Character
loading, I needed to have
those Characters in memory, and hopefully users know
that when Blueprints do a Hard Object Reference,
when the Blueprint is loaded, it loads all of the related
Assets to that Object reference. In order to have all of
the different Meshes available, I decided to come up with—
Sorry, my little streaming button is in front of some of
my Blueprint icons here. I decided to come up
with another Blueprint that actually loads
the appropriate Character Assets using soft
Object variables. What I did is, this is
actually a separate Blueprint. I am actually probably
going to go back and revamp this and move the logic back
into the tile Blueprint itself. That way, each one of these can
just be a Blueprint interface with just the variables in them. I went ahead
when I first set this up and put the logic here
into the Blueprint, so it needs to be
a full Blueprint. But I think it would be
a little more efficient to have the Blueprint logic
in the tile and just have it load
the interfaces with just the variable
information. That is on my task list. But essentially what we have
is we have the actual variables that are used in the tile.
We have the move animations, which are the animations
that play before the Character moves
after they are selected. We have the emotes,
which are those dances and things that you saw
after they do a capture. Idols, and things like that. Then death animations, and then
the actual Meshes themselves. In these Blueprints, these
references are actually empty. If you see over here
on my default values, all of these references
start empty. That is on purpose,
because the references are Hard Object References,
so by having them empty, they are not actually
loading anything. Then what we do is we have
a set of Soft Object References. The way you can think
the difference between a Hard Object Reference
and a Soft Object Reference
is a Hard Object Reference is actually pointing to
the actual “physical Object” and all of its related Assets. Once that is pinged,
it has to load in the memory so the Blueprint knows
how it is functioned. A Soft Object Reference
is much more like a web address to your hard drive. It is just telling the engine
where the Asset is, and because it is
a Soft Object Reference and the Object is not loaded, if you need to interface
with that once it is loaded, you need to cast to it. What we essentially do
is we go through, we have
the Soft Object Reference, we load the Asset into memory, and then I cast to it
and then set the actual variable to that reference
once it is loaded.>>Victor: Yeah, we actually got
that question last stream, and we went over it
a little bit. But it would actually be great to see
exactly how we are using it, because we did not have time
for that last week. This is a real use case, right, where we need
a lot of Skeletal Meshes and we do not want to have them
loaded into memory at all times, right?>>Christian: Exactly. A lot of Skeletal Meshes
and a lot of animations. Because while I am not using
the complete animation for the Blueprints
for each Character, we have got five animations
loaded for each Character. Each of those animations
is specific to the Character. We have got each of the Skeletal
Meshes for the Character, and then each of the skin
variations like if I go in and – I will load
a different set here. If you will notice
that the bishops, rooks, and knights are skin variations. They are variations offered
with the Paragon set. The same Character profiles,
the same base Characters, but they are actually
separate Skeletal Meshes with a separate set
of Materials loaded. I actually keep those
separated out as well. The way I have it set up –
again, by moving this logic
into the base Blueprint I can set this up
as Blueprint interfaces. Basically, I have a master here. This is where everything
is set up. I do not actually use this. This is just a master
that everything is set up in. Oops, maybe I should not
minimize the entire engine. Bring that back up again. In my Content Browser,
I have children set up, so the children
is where I do the variation. These can just be data
only Blueprints that have the actual
Soft Object References in them. By doing that,
the nice thing about that is you are very specifically controlling what is
being loaded into memory. It takes a little
bit more setup, but you are actively
loading into memory. Once they are not used, either you can specifically
unload them, or generally when a garbage
collection happens, they will be unloaded
automatically if they are not referenced
anymore, I believe. I have to double check on that. But yeah,
so if you are going to have a – it is something commonly
that I see where if you are going
to have a large variable set of different variations
that you want to reference but not necessarily load
at any one time, this is a way to do that. You will commonly see people
set up a Blueprint with say a weapon
selection screen or opportunity where you go over a weapon and it detects
what kind of weapon it is and then assigns
that to the player. A lot of times in those kinds
of Blueprints, you will see a ton
of variable references to all the different weapons, and then it will just choose
the one and assign it. But what a lot of people
do not know is by having all those
Hard Object References in that Blueprint, as soon
as that Blueprint is loaded, every single one of those
is loaded into memory. Whether it is a direct variable
or whether it is cast to, it is going to be
loaded into memory. The way to control that is
through soft Object referencing. When you set that up, it is
relatively straightforward, although it is not
well-broadcast, is when you create the variable, essentially over here
on Variable Type. I will expand
that a little bit out. Over here on Variable Type, you have
what type of variable it is. You go in, you choose the type
that you want to have. But you get this drop over menu
to your right. You have your Object Reference,
your Class Reference, Soft Object Reference,
and Soft Class Reference. That is pretty straightforward. The Object Reference is going
to load that specific Object. The class reference is going
to load that specific class and be able to reference
an entire class of Objects. The soft versions
of those are again, that concept of a web address
in your hard drive. It is not loaded until you
specifically need it loaded. Now, you need
to keep that in mind because you might get used to –
again, one of the things that people tend to forget
with this as well is once the Object
is loaded into your Editor when you are in Play
in Editor mode, like here, you will notice
when I start playing and I decide to load
the Character sets, it is instantly happening. That is because once the Object
is loaded into memory in the Editor, the Editor is going to keep it
loaded into memory. It just assumes that you need
that loaded into memory because you are going
to be using it. That load time in actual play
if I start up a new session and hit play, for this PC,
it is a few seconds. It loads it in.
But for lower end machines, it is going to be
a longer load time to load that stuff into memory. I need to take
that into account. How do I want
to handle that load? Do I want to cover that up
with a UMG Widget? Do I want to have some other
kind of player interaction while I am doing that? Do I want to use
the cinematic fly-in or something like that
to cover up that load. Those are going to be
other things that I play with
as we go forward. Again, by prototyping
with high resolution Assets— Again, I could have gotten here, if I had
started out with this project and I had one Character
that my art team had built and I said, okay, cool,
duplicate that a million times, but then expand out and start
using other Characters, then I start running into
those kinds of issues that I need to deal with. I start running into
real world issues like, oh, this loads really fast
on my superfast, awesome laptop that I have, but if I try to
put it on a console or put it on a lower end
PC or mobile, that is where I have got to
start worrying about load times. I need to start thinking
about solutions for that.>>Victor: Could you explain
the difference between the
Soft Object Reference and the Soft Class Reference and possibly when you would
use one or the other?>>Christian: Yeah, so the Soft
Object Reference, the Object
is a specific UObject, a very specific
Blueprint generally or a very specific Asset
like a Skeletal Mesh. The class is referencing
just the higher level class. If you have a class of multiple
different types or a class of Blueprints
like a Character class, and then you have multiple
Objects based off of that class, sometimes you want to reference
just every class in the Level versus a very specific one.
That is when you would use that. I have not worked too much
with referencing classes over specific UObjects. I have not run into it
as much here. But if you wanted to have say
multiple, you have a base class and then you have an extension
to that class with multiple
different specific Objects and you want to reference
every Object in that class, you can create
a class reference. That is when you would use that.>>Victor: Cool. Where are you
expecting to take this project? What is next for you? Is there an ultimate goal
that you at some time will hit, or are you going to keep
iterating sort of to learn and to be able to demonstrate?>>Christian: Yeah, for me right
now, one of the goals that I am working on
is porting it to console. I am working on both Switch
and Xbox versions. Part of that is just to go
through the process for myself, because it has been a while
since I worked on console, and I have not directly
worked on Switch. But I am also using that –
in my role as an Evangelist, my focus really is
on independent game developers. I spend a lot of time
with developers, especially
EULA developers who are
getting close to ship and dealing with certification
and things like that. I am going through
the same process that any indie developer
would go through as far as getting approval
on the console, having that approval sent over from the platform holder
to Unreal to have it affect
my Unreal account and access the console
development ability and things like that. That is helpful for me to just
go through those processes. I try to approach everything
as if I am a consumer. Hence, I generally try
to only work with release versions
of the engine unless I am doing
some very specific demo. I try to access the Assets
in the Marketplace and things like that. That way, I am always,
as a game designer does, always trying to experience
things as the end user, the consumer, in this case
developers, are experiencing. That is part of the reason
for me to bring it onto console, is just so I can have
that hands-on experience. Again, having these different
things— For example, when I first implemented
ParaChess, I had this very— The great thing about it
is that I actually, if I can remember
where it actually is, all of the move actions
that you see in the game are all based off of this one
tiny little block, EventOnTileClicked. This is in the tile Blueprint,
so all the tiles are sitting there waiting
for a click interaction. When they get a mouse
click interaction, they check to see
if the game is actually going, and then they call out
to the board and start that entire process
of running all the game logic and highlighting all the tiles. Right here
is where it all kicks off. Now, that worked great on PC. That works awesome on PC.
You just click on the items. You saw how easy that was
for me. It works perfectly. But of course on console, that
is not going to work as easily. Again, this is kind of looking
forward prototyping systems, as soon as I sat down
and said, okay, I am going to put it
for console, I have got my handy game pad and hooked it up
and started playing it, and of course
that whole on click thing is not going to work. Now, I could have tried out
doing a virtual mouse click, a virtual mouse cursor. Obviously,
on touch screens like iOS and things like that,
that might still work. Although, I am suspect
as far as screen space and things like that. What I did is I went into
the Player Controller and just came up
with a set of logic. This took me about one evening
in a hotel room somewhere as I was traveling
around the country and did a— This is basically a stick
input for doing the Character selection.
Essentially, I detect which player
is in control of the board that drives some
of the directional motion, because I use north, south, east,
west for my direction logic. When I first set everything up, I labeled everything up,
down, left, right. Then I very quickly
ran into the problem where when you are
switching sides on the board, the whole inverting up,
down, left, right just kind of friend
my mind every time I tried
to wrap my head around it. So I changed over to that north,
south, east, west. But essentially, what it does is
it just has a logic system for detecting
what tiles are on your team and how to move through them.
When I actually play the game, you will notice that one of
the things that it does is it always highlights
the king first. Whenever it is your turn, the first piece that is going
to be highlighted is the king. That does not really matter
on mouse, because I am immediately just
clicking the thing that I want. Most mouse and keyboard players
do not even notice that the king is the one
that is initially highlighted. One of the reasons for that
is right when it starts off your turn,
that is when it runs the check to see
if your king is under threat. It checks any possible
move spaces to your king. But what I have –
you cannot see it, but I am trying to loudly click
left and right on my keyboard.>>Victor: Yeah, we can hear it.>>Christian: That is me clicking
left and right,
simulating my Controller. But you can see it just scrolls
through the Characters. If I continue
to go to the right, it gets to the lower left.
Then it cycles back around. That was easy enough to do
just using the tile counts. But the other thing I noticed
is when you are clicking again – I click on a Character,
and it highlights, and then I click again.
Again, it is very intuitive. Anybody who uses a mouse
is very used to that. But with a keyboard,
you do not necessarily get that amount of feedback
of what is highlighted. I actually put in an affect
from one of the Paragon – actually, I do not think
this is from Paragon. I think this might be
one of the free effects packs that we released recently. But I just play an effect
on the Character. Again, that is attached
to the tile. Now, when I move left
or right or up or down, now it is cycling through
the available move positions. I have kind of
a two-step process. Now we have got the position
highlighted in green that I want to move to.
I press the select key again, and the Character
actually moves. The next thing I ran into
with that is again, left and right works great, but what do I do
when I have Characters that are all spread out
across the board? If I play my little cheat,
which will swap teams, now I have Characters
all over the place, some in the front,
some in the back. What I decided was that a set
of logic is essentially left, will continue to move upwards
left and right across the board. If I basically just continue
to click left on my stick or my keyboard, it will just cycle that way
all the way across the board. Up and right just mirrors.
If I go down to the right, then it will just start
back up at the top. Again, that seems
like little things. But UX and player interface
is a huge part of the game.>>Victor: Yeah, it needs
to be intuitive.>>Christian: Yeah, exactly.
The next step for this is to actually get this
in players’ hands, because what you want to do
with something like this is be able to hand someone – ideally, in this case, someone
that understands what chess is – hand them a Controller and say,
okay, choose a piece. They are going to hopefully use
the system that
I think they are going to use and just kind of click through
and go, oh, okay, I pretty much
instantly understand this. I click through here. Once I get to the Character
I want, I hit A. Once I hit A, now I cycle through the
actual available move pieces, which for a queen
is quite extensive. But I get it onto the place
that I want and hit enter. There may be other things
that I learn once I start handing to
those people. The first thing, maybe it should
cycle through the Characters that are available
to capture first and then cycle through
all the empty pieces. I do not know.
I am not going to know that until I actually
put it in the hands of players. I can have an idea of what
I think players are going to do and what I think players
are going to want to do, but you never really know that until you have
that in and functioning. Again, one of the best things
that I heard in a talk at one of the Unreal Dev days,
was one of the engineers. He was talking about
optimizing performance. He said, one lesson that people
continually do not seem to learn is that you really should be testing your game
on your target hardware. To me, that sounded like, yes,
you should definitely do that. But this is an example
of something like, oh, I can add Controller
input at any point that I want, but there is I think going to be a lot of tweaking
on this Controller input that I am going
to need to do once I get it in players’ hands
and have them interface with it that I would not necessarily do
on a mouse. Because I have not done
turn-based interactions like this
on a Controller, my intuitive gut on
how it should work may be right, and it may be wrong. But by building
it modularly in Blueprints, all of the logic
is all built in and labeled so that I can go through
and actually – it is all done
with math variables on how it moves through
based on what your title is and what the numbers are
to the next tile over. I will be able to adjust that. The other thing, because I am
doing quite a few actions every time you cycle
through those, when you change the different
selections, I am doing Material swaps
on the highlighted tiles, doing Material swaps back from
the other highlighted tiles, doing lots of various
different things. I try to build efficiency into
the system right off the bat. For example, with this,
once you start up your turn, it goes through, and when it is doing
that king threat check that it does
at the very beginning, it also builds an array
of all your available pieces so that when you are doing
that cycling through, that left and right,
it is only running the check on the tiles
that you already occupy. That automatically for one, skips over tiles
that you cannot select, so that solves that problem
right off the bat so players are not moving the selection
to an empty spot and sitting there hitting A,
which they will do. It solves that problem
right off the bat, and then it also makes sure that
it is only running the functions on the various tiles
that it needs to run. Again, thinking about
optimization and performance as early as possible.>>Victor: Is this in 4.22?>>Christian: This is 4.22,
correct, yes. Which I honestly have not gotten
enough time to play with since it came out. I chose to upgrade to 4.22
the same time I got a brand-new system, so I had to get everything
moved over in the new system and just got everything
running up in 4.22.>>Victor: Was it relatively
seamless?>>Christian: Yes. Yeah. The only thing I ran into
on 4.22, once I made sure
all the Marketplace Assets were up to date.
That is one of the reasons whenever I give talks
on Marketplace Assets, I definitely recommend
keeping your Assets organized so you can quickly see the
folder structure and everything. But I think the only—
4.21 to 4.22 is one of the most
seamless transitions that I had. I do not think anything
is deprecated. I think the only thing
I am getting is I am getting some errors
related to lighting that I have got some RGB values
that are deprecated that are no longer needed
that I just need to go through and clean up
in some of the environments. But other than that,
everything was super smooth. Even though I did have the extra
steps of having a new PC, so I actually not
only upgraded engines, I had to have everything
checked into Perforce, did a brand-new install, recompile all my shaders
and run everything like that.>>Victor: That is good to do. I tend to make sure
before I do a significant commit that I try it on another PC
that I have. I am sort of simulating
if someone else who I was collaborating with would be pulling my file
sound and make sure it happens. I also try to package
on another computer that is not the one
that I have been working on, just to make sure that at least
it is a double check, right? You at least have another
computer that it is working on. That is one of the things
that I decided when I was working
on a large project. I stayed on binary
because I knew that I would not have the time or even the knowledge
to fix anything serious if something got deprecated
in C++ that I had customized myself. That is one of the benefits
of doing it all in Blueprints is that you essentially leave
some of the tough engineering to all of the engineers
here at Epic, right?>>Christian: Yes.>>Victor: Each version goes
through a very rigerous QA process to make sure that
when you upgrade your project and if it is built
entirely in Blueprints, it is relatively seamless. Obviously,
some things are deprecated, but we try to always
put a little note there and make sure
that it is visible.>>Christian: No, I definitely
recommend, especially indie developers and folks starting out, I recommend staying in
Blueprints as much as possible. Generally, my process when a new
version of the engine comes out is I will get
the new version of engine, get everything installed, and quickly to your point
of testing it on other machines and testing other downloads, that is an excellent thing
to do. Because even on this last
install, I did a full check-in
through Perforce, got my new laptop,
did a full download, went through all that process. It turns out that
there was one file in— It was actually
in the Howitzer Character Pack. It was a Material Object. For whatever reason, it did not
get properly added to Perforce. But I never saw that, because I had not downloaded
it onto another PC. I had it locally,
and it just was not— It for whatever reason
did not get marked for add, and it just was not added. Of course,
my luck being the case, I went on a business trip
the next day, grabbed my new laptop,
went on a business trip, and went to install everything. I started getting errors popping
up about missing Material, missing Texture reference. I am having to do the research,
like what? Of course, I am doing it
at the same time as an install of a new engine. I am assuming maybe
there is something deprecated. Maybe there is something
that has not been updated in the Assets. Finally, using the output log,
I looked at the errors, tracked it down,
and went, oh, that is because this file does not exist
on this instance of the game. I go back
and I look in Perforce. Oh, it just was not properly
added to Perforce. I pulled a fresh copy
of the Marketplace content down, re added it the project,
updated it in Perforce, rechecked that on my other PC,
did a fresh get, and then it was all good to go. But yeah, testing it on
multiple PCs to make sure that you have not accidentally
locally duplicated some file or locally created some files
or not had it checked in, or things like that,
it can be really important. Cooking in and out
and trying it on different PCs, those kinds of steps,
as often as you can do them, again, can save problems
down the line. Those are little things.
With a project like this, it seems like
a relatively simple project, but we have got,
I do not know, 70,000 files I think
in the depot for this project. Just doing a straight
70,000 file get onto a new laptop
over a Wi-Fi in a hotel room is generally not the best place
that you want to be testing out and making sure that you have
everything checked in correctly.>>Victor: Definitely a real
world example, though.>>Christian: Yes and I think I forgot the other part of your
question. I got onto testing other stuff.>>Victor: I was ready
to ask you the next question.>>Christian: Okay. Oh, just as
far as errors on 4.22, this is basically the examples
that I have got are just some vertex pinging errors that needed the Levels basically
just to be resaved in 4.22, and then it solved the issues.
I think the other couple areas were just basically
some extra lighting data that is not needed anymore.
Super smooth. When you do run into issues with
deprecated stuff in Blueprints, that is where I was going, was essentially when I go into
a new version of the engine, the first thing I really do
is try to open all my Assets. I just sit down, I start opening
up my core Blueprints, opening everything up,
seeing what the output log says, run the game. Obviously, you are going to need
to re set up your shader cache. I actually have a special Level
that has all the Characters in it
so that the Editor loads up all the Materials
into the shader cache. For me, what I did, because
I have all those Characters, I just open up that one Level. It has got all the Characters,
all the Assets in it. It starts building
a shader cache, and then I just let the laptop
do that overnight. Of course,
you do not have to do that. But it saves you time
in the future.>>Victor: That is a pretty
neat way of doing it. You can also actually store
the shader cache and push that
to Perforce as well, right? I know that that—>>Christian: Maybe you can.
I will have to look into that.>>Victor: I remember having
that as a solution once when one of the members
of my team, their computer – it took too long every time, but they had
a good internet connection. It was faster for them
to actually pull the shader cache versus generating
it themselves. I would say that is probably
a very rare instance that that is the case. But it is possible.
This is apparently a chess term, and I Googled
it behind the curtains, because I did not know
what it meant. Did you develop en passant?
En passant? Which is a chess term
that I am not really familiar with what it is,
but I know it is a chess term.>>Christian: I do not think
I have implemented that. I know I need to get
the rook move in where if you have not moved
your king or your rook, you can do the swap there. I do have the logic in
for the pawns that can detect, adjust their movement based on whether
there is a threat in there, but en passant – someone asked me
about that at some point. En passant.
I am going to look it up.>>Victor: Well, it is an old
game, and it is very popular.>>Christian: Oh, an enemy pawn
that could have captured— Oh, yes,
someone did ask me about that. Yeah, if you move past
another pawn from
your initial two-pawn position, then the other pawn
could catch it. That would actually—
Looking at it, I could probably implement that relatively easily
in the pawn logic, because I do have the pawns
set up into their own logic set. That is one thing
that I did is actually, the move logic was the most
time-consuming in chess for me. Part of the reason –
it is funny, because I actually started out
kind of doing the rook first, moving up and down. Then I went and started moving
the rook east and west. Then I started figuring out
the logic for diagonal piece movement, which got a little
more complicated. But I actually thought the knight
would be the most complicated, just because in my mind
as a player, the knight is always the one that
I think of as most complicated, because it does not move
in straight lines. But the night
was actually the simplest. This is the knight here. The knight essentially
just has the eight possible move locations
based on its current location. It does not care who is in
between it and its move piece, because it moves independently
of any of that. Essentially, I just had to check
those eight slots, check two things, basically. Well, three things.
Is it on the board? Because of the way
I am doing the logic with math, I want to not allow the pieces
to move off the board, so I check to see
if the tile is on the board. I check to see if the tile is
empty or occupied by a friendly, and then I check to see
if it an enemy slot. All of that logic
is very much simplified compared to the queen, who actually runs through
all of these checks: the north south check,
the east west check, the diagonal piece check. Then the pawn has the special
checks built in to see if either it has moved yet, because that is the thing
that is different. If it has not moved, it has a different rule
set than if it has moved. Like I said, ParaCheckers would have been
a lot less custom stuff. Then we get into the king logic, which is basically checking
all the other pieces against the king,
the same kind of thing.>>Victor: They were wondering
if it might be better to divide all your logic in the graph
into individual events. Off the top of my head,
I believe that each event that you actually add
to your graph adds to the memory cost
of loading the actual Blueprint. Using a ton of events just to sort of clean up
your Blueprint code will actually add to the memory
cost of loading that Actor.>>Christian: Right. If you are going
to have a lot of events, i.e., a lot of event
dispatchers, right? Because you are going
to need event dispatchers for those custom events. At the beginning of play,
you can see here where I have got my begin play,
and essentially I am assigning all the various
different events. I have got tiles selected
with some kinds of tests that I have built,
the Camera switches, the king threat check,
loading the characters. Essentially, at the beginning
of the play of the Level, I assign all those events. But each one of these event
dispatchers has its own costs. Each one of the associated
events has its own cost. Having a ton of events
everywhere – I think one of the challenges
that I commonly see – me and you actually had
this discussion at a meetup a while ago. There is a little bit of
a breakdown between efficiency when it comes to the visual
cleanliness of a Blueprint versus the actual computational
cost of a Blueprint. In this example here, I like
to use this as an example. This is the logic for the north
south piece check. When I move a rook or a queen, this is the logic
that checks the row or the column of pieces above
that piece and the column of pieces
below that piece. What it does is it comes in.
For the first sequence, it is going to set that
to a positive, i.e., it is moving north
on the compass. It could be up or down, depending on which side
you are on. It sets that to positive.
Then it comes through, and eight times,
it goes out and it checks. It says, is this a valid tile?
If so, can I move there? If I can, great.
Do it again. Bump up another eight spots,
which is one column up. Run that check again,
do it again, do it again, do it again.
Do it eight times. At any point that it hits
a blocker in that check, it hits either a friendly
or an enemy or at the end of the board,
it stops doing those checks. It is rare that
if you get a piece right in the middle of the board and have it completely empty
both ways, it is going to run
all the checks. But it will stop checking
once it hits a collaboration. After that sequence, it comes
down into this sequence, sets that check
into a negative setting. Now it is running south on
the board instead of positive. It runs those
eight checks again. When I originally set this up, this looked much more
like these pawns where the pawn
has three different blocks. Right here it has a north check,
a northwest check, and a northeast check. The queen would have had eight
of these blocks going north and then eight of these blocks
going south. They were all duplicated
of each other. I did that initially just so I
could start working out the logic of, okay,
I am going to do these checks. Okay, what happens
when I run into a friendly? Okay, what happens when I run
into the end of the board? What happens when I am already
on the edge of the board? Implement it, start testing it, and oh, I had not taken this
into consideration. I needed to add this logic. Get it all sorted out,
get it all cleaned up. I had this massive wall
of script blocks on my screen. Obviously, from an organization
standpoint, that is messy. From a load time aspect of actually opening
the Blueprint in the Editor, that takes time. However, once I took
those amounts of checks – 2 times here. That is 2 times 8
on this sequence. That is 16. Another 2 times 8 here,
that is 32 checks. Then we are doing that 32
times here, 32 times here. We have got
exponential amounts of checks. It is the same amount
of computational checks, whether I am running it
off of a sequence that looks nice and clean, or I have just got
the same block duplicated over and over and over again. Of course, once it is cleaned up
like this, the nice thing is once I have
got the logic all worked out and all the kinds
of bugs worked out, if I want to make
fundamental changes, how I do it, I can just go in
and modify the on block. But I find having
a messy script early on, i.e., lots of references
and lots of lines, it can be tempting
to want to clean that up and move things into functions
or whatever. There is a time
and place for that. Everything has its cost.
A good example of – this is something
that is a work in progress. This is a Character selection
Blueprint. This is a Blueprint object that has a set of Skeletal
Meshes attached to it, a little base, and some effects.
This will be dropped in, and then as you choose
the different Character sets, it will show you.
I have just got the logic in that no matter
where I place it, the Skeletal Mesh
is facing the Camera. That way, if I drop them
into a different environment and I want to spread
the Characters out or whatever, move them around, that is all controlled
through array variables. I can go in and customize
their different data sets that I have here
for the different Meshes and stuff like that. When I came up with the logic
for building that transform, I actually built that
into a function. Essentially, to do the transform adjust based
on the Camera location, essentially I start
with the original transform. The location essentially
is what I am getting. I get the Camera location,
get a look at, break the rotator, adjust the Z,
add a 90-degree variation, because I have a 90-degree
adjustment on the Camera just because that is
how I set it up. Make a new transform,
and then do a return. When I come back over
to my actual event graph, all that it looks like –
it is in my construction script. Sorry. When I come
into my construction script, all I am doing to each one is
just getting the Mesh locations out of a transform,
playing that function, and then setting
the transform on the Mesh. If I decide to use
that set of logic, because functions
need to be math only logic, no temporal modifications, I can bring that in
and use it in other places. It is partially a function of
“organizing your Blueprints” and partly a function
of making them more efficient. But those two things
do not necessarily always mean
the exact same thing. Just because you have a
reference that is polled a lot— If I go into my tile
Blueprint here, these two integers,
these team owner integer and this piece number integer, these are the integers
that drive the logic for the actual tile
to know what to do. Essentially, I know what my team
already is as a tile, and this is telling of what
the team owner of the new tile is and what
the piece number coming in. These two integers are used
in a ton of these calculations. A cleaner way to set
that up would be to set a variable right here, just set that to a variable
right off before I run the sequence, and then reference
those variables. But because I am still continually
adding things to this, I like to be able to
just visually look up and across and see, okay, I am directly
referencing that integer. I know for a fact
when I look at these green lines that that variable being
referenced is that integer. Yes, it is “messy”, and yes,
at some point I may come back in and actually replace it with
a nice little variable reference so they all have their own
variable references and it is nice and clean. But what I can know is
I can look across this and know
that all of these variables are referencing those integers. I do not have a situation where
I have accidentally gone in and maybe accidentally dragged
this variable over and dropped in a different
integer variable in here. Because that is a possibility,
right? You could accidentally do that or accidentally drop
in the wrong one. I know specifically it
is referenced off of that.>>Victor: Yeah, and then code
is for humans, right? We are the ones that need
to read it and understand it so that we can tell
the computer what to do. If you have a method that is
easier for you to understand and get a glance at your project
and understand what is going on, that is all good.
There are almost no wrongs. It just depends on the scope
of your project and how many people
you are working with, right?>>Christian: Yeah, the one thing
I would say is essential is label
your Blueprints. Even though you are going to be
the only person that ever works
on this project and you know exactly
what you are doing, you know exactly the logic that
you are implementing right now, and thus you do not need
to label anything. In six months when you come back
and reopen this Blueprint and need to change something
or want to add something to it, you are then going to
have to spend an hour sitting down there
and figuring out your own logic because you did not
label anything. I am definitely guilty of it. I try to label things.
When I know ahead of time, you will tend to see blocks
like this that are very nicely organized
and very nicely labeled. But it would be very easy for me
to go in here and go, oh, well, I know that
when I look on these references, these are
all referencing Meshes. These are
all referencing emotes. The variables are labeled,
right? I could just leave this off.
It is not necessary. But when I pop in here
and look at it, it saves time to be able to go, oh, okay, I have got a bug
in my move animation variables. Let us find the correct one. I am going to go through here.
It is all right here. It is all nice and labeled
and clean and laid out. I was raised in the west,
so I think left to right. Although,
I tend to go up and down, as you can see within my blocks. But as I get into larger
Blueprints, I will tend to kind of
spread out from the middle. I will tend to have my begin
play kind of in the middle and then branch out from there. Here I have got
my movement logic and my king threat logic
down here. This is off of begin play. This is
the initial team selection bringing up that widget and
loading the actual Characters. That is right here
in the middle. Then up here, this is the logic
for actually swapping the turns. Just essentially
changing the team turns, doing the Camera swaps,
assigning the king. Then over here, I have a bunch
of cheats that I colored red and said, do not ship. Please do not ship this.
Color it red. Red means it is eventually
going to be deleted. That is the color-coding I use, is that green is in ready state,
grey is working. Blue and green
are usually ready to go. Red is going to be deleted
at some point. Then some things like
placeholder, special tests, I will usually leave it to grey
until I get to a certain point. Sometimes I will just make it
a super crazy color like purple
or something like that. I just use colors
like that that help. To me, again, it is about
having things organized not just to organize them,
but 90 percent of the time, you are going to have to
come back and touch something in here at some point. Either yourself,
and it is going to be even worse if it is someone else
trying to debug. Trying to debug
someone else’s script, whether it is in Blueprint
or any language, is always a challenge. I think any scripter worth their salt has
probably been there before where someone got sick
at the end of the project and you had to go in
and fix a bug in their script. If they have not labeled things
and have not organized them, it is a real time sink. I highly recommend
right off the beginning, just start labeling things.
You can always change them. This was one of the very first –
this is the script. It is actually
in the construction script. Again, organizing-wise,
I thought, oh, I will start it
and put it into its own function because I am going to have
a bunch of stuff in the construction script. This ended up being
the only thing in the construction script, so do not really need that
to be in its own function. But I set this up last July.
This would have been last, around GDC,
I think, that I set this up. It was
the very first thing I did. I have not really needed
to touch it since. This is the logic
that just lays out. It sets the size of the tiles
to 300 by 300 units, lays them out in the 8
by 8 grid, and then notifies them
of what tile place they are. I might never come back
to this ever. But if I did not have any labels
on this and it just looked— That will delete
the entire block. But anyway, you can imagine if this was just
a bunch of script, I would not be able
to decipher what this is. I would have to sit down and actually go through
and figure it out.>>Victor: Would your logic
and everything you set up allow the game to support times
N amount of tiles?>>Christian: Yes. That is the
idea. I have not moved those
into their own variables, so I would have to go through and at some point
what I want to do, I want to add
spacing capability, i.e., shrinking
and expanding the board. How I handle pieces on that
is still up for thought. But also,
multiple Levels of boards. Star Trek 3D Chess. That is why I use pretty
much integers for everything. Then probably in hindsight, now that I am talking
to you about it, if I had set those
into a base variable that I could then change
on the fly, so I need to go back in
and set – basically,
the way the math sets up, because the boards spawn
I think left to right, basically to go right left,
you go plus 1 or minus 1, and to go up and down,
you go plus 8 or minus 8 because it is an 8 by 8 board. I would just need to change
those into variables for a 10 by 10 board
or a 12 by 12 board, something like that.
Change those into variables, and then
you would be able to go in and actually set those options. That is the idea, is to build
these kinds of things to be really expandable. Even if we go back into
that Character selection Actor, if I go into the viewport,
it is pretty simple, right? Most people’s inclination
for something like this of, this is going to be a Level that you open
at the beginning of the game, so it will be
some kind of environment. It will open it up and these Character
sets will be sitting here. You will be like,
I want Character set 1. I want Character set 2.
Actually, if I open up the demo, I have got a demo space
for that. Go to open Level, test showcase.
Let us not save anything, because I have no idea
what I have been doing. In this space,
I have got that Blueprint. You can see this Blueprint
is just a duplicate of my default Level. Again,
I set the GOOD SKY on noon. But just drop that
Blueprint in, and the functionality
is that essentially I just am cycling
through the Character sets. I can be like, oh yeah, that is
the Character set I want. This is Team A on the left,
Team B on the right. I have only worked on this
for about a half an hour, so it is not fully fleshed out. But I have got
the basic functionality. Hey, there are Characters.
They are set up. They are moving around.
You could see the initial way that a lot of people
would do this is they would make
a duplicate of this Level, they would place these Skeletal
Meshes into that Level, and then they would open up
the Level Blueprint and start doing the logic
based off of that. But I always try to build
things systemically. I do not know
if in the future that if I want to actually
use an actual Level – I might want to have
this floating in space. I might want to add this as part of some other
UI Blueprint loaded in and have it displayed
in front of widgets or something like that. I might want to do
different things with it. What I do is in the logic
of the Actor itself, like I said,
I have that construction script. That is basically setting up
the look of the Characters. But even doing that,
when I go back and I have those
Characters placed, having the Characters
look at the Camera is relatively easy to do
if I set the Camera in the Level and tweak all of the Z axis
of each of the Characters. I could set them all perfectly
up to look at the Camera, and it would look awesome. Until six months down the road,
I go, you know what? I need the Camera
to be way closer than that, because I want to have
a better view. Or maybe I decide,
oh, you know what? I need to dynamically move this
Camera based on the resolution. Now, all of a sudden, I move the Camera closer
to get a better view, but the Characters on the edge
are looking off into nothing. I just build the construction
script to handle that and build it systemically
so everything is handled through these arrays
in the build in the event graph to actually do
all that adjustment. Those are the kinds of options
that you can build in.>>Victor: That is great. Are you planning on sharing
the project at some point?>>Christian: Yes, I am. Amanda hit me on
the last interview about that. I have gotten quite
a few questions about that. I have got some cleanup to do. I want to move
some things around, like I mentioned moving
some of those Blueprints, transferring those
into interfaces, moving the Objects in there. I am looking at moving
some of that board logic into the Game Mode
in preparation for the ability to have different
Game Modes in chess. By having that logic
live in the Game Mode, then I can have children Game
Mode or different Game Modes and be able to swap those out. In the beginning,
it seemed logical to have all that
in the one Blueprint, but I think having it
in Game Mode fits better within the Unreal system. Once those things
are kind of done and I just do
my initial tests on console, just have a build on that,
then I do plan to put it up for people
to be able to download and rip it apart
and start messing with it.>>Victor: Are you planning on
writing AI for the enemies so you can play against
the computer as well?>>Christian: You know, that is
on my list. The way that it is set up,
because Characters do not move and because everything is based
off of those two integers, actually building a “AI system”
would be relatively simplistic. I think the way
that I would approach it is that I would have to go get
someone’s cool rules for chess of what the best moves are,
what some of the moves are. Essentially, I would do a survey
of the board each move and say, okay, the AI
opponent’s set looks like this. My set looks like this, so I am going to choose
one of these random moves and do a reset from that and then just continually
just have this database which would probably just be
an array of variables that the AI would check. Whether that is
the best use of time – I might just do a framework
of that system of what the actual logic
would be and not do a fully fleshed
out multiple choice AI, maybe just have
a single run through or a single set of things
that then other people could be able to plug in,
that kind of stuff. There are plenty of experts
in the world that have come up with awesome chess logic stuff.
Me trying to roll my own is not ever going to compare
with what they have done, so it is going to be more about
pulling that information in and how to make it acceptable.>>Victor: But it would be in
Blueprint?>>Christian: It would be
in Blueprints, yes. Like I said, I think actually
building the framework and the logic behind it, for me, I think is
relatively straightforward, so it would not be a lot
to add to the project. Probably a couple days of work. It is just the actual,
all those combinations getting all that data
entered would take time.>>Victor: What was your process
or workflow to put the Paragon Characters
together? For example, fixing cloth,
hair physics, et cetera.>>Christian: I have not really
had any issues with that. Let me open up
that other Level again. Essentially,
I just dropped them in as is. There are a couple little things
to clean up. The couple issues
that I did find in the Assets that were actually bugs,
for example, Howitzer in the first iterations
on this particular skin did not contain all the Material
Assets for the rabbit, so he was green. There were a few Materials that
were not correctly hooked up, especially in the variable
different skins. I actually found those,
notified the Marketplace team, and they actually got
that cleaned up on the Marketplace side. Aside from some
very minor issues, like I think the cloth physics
on her sword, on Countess’ sword
are not active. But we have got hair
going on on Countess. Serath over her has
some awesome cloth physics. All these cloth physics
are actually responding to a wind actor
that is placed in the space. If I open it up, I can bring up this wind
directional source here. That is just an Actor
that you drop into the Level. That is affecting
all of the trees and such to. When it is actually playing, you can see the trees move
and stuff like that. I essentially
created the project, added the Assets to the project
through the Epic Games launcher, and then just went in and started setting up
references to them. One of the things
I have done again, and I think this is a really
good idea for all— I recommend doing this whether
it is Unreal Marketplace content or other licensed content
that you may get, or even outsourced content.
I keep it all separated. You can see on the left here
on my layout, I have my chest content, which is essentially
all the content that I have created
for this project. I have got some custom
animations that I have modified, my Blueprints.
I have some environment Assets that I just run
some basic things on, the effects that I have edited
a little bit. But everything else I keep in
the default install directory. That way,
if there is any update, if GOOD SKY updates
their Blueprint, which they just recently did
I think for 4.22, updated their Blueprints to be
compatible with the new engine, I can just go
and re add that to the project. It is going to default it
to the same directory. Perforce can tell
what has changed, and then I can only check
in what has changed, and we are good to go. I do not recommend
taking those kinds of Assets and ripping the folders apart and spreading them out
all over your project. If you do want to put them
into your project, you can use instances
to reference back to the parents and put instances
in other places in your project. But that way,
your source content— Another way of having
source control, since it is external to yourself
and to your project.>>Victor: Just to look back, because we have a follow up
question for about using [inaudible] instead. The best information
you can find on events, functions, macros,
different types of ways to communicate
with your Blueprints will be to watch
Zak Parrish’s tutorial that he did on
Blueprint communication. I will go ahead
and paste that into chat. I thought I had that copied.
All right, taking questions. I will go ahead and paste
that into chat. Check that out.
I have watched it several times. I mentioned it on the stream
previously. It is amazing.>>Christian: I need to watch it
again.>>Victor: Yeah, and it is
all still relevant. Nothing has changed there. You can just go ahead
and watch that. You should get a good overview
on how all that works. They were wondering if…>>Christian: Getting a handle
on Object communication is super valuable, and getting your brain wrapped
around how to have different Blueprints talk to each other
is super important. Once it kind of clicks in
and you really understand it, that expands out to widgets and how widgets
communicate with Blueprints and how Controllers and Pawns
communicate with each other. Starting to get a handle on all
that stuff is super valuable. That is a great resource
to check out.>>Victor: I would especially say
if you are ever planning on making your game multiplayer, which you should be thinking of
from the start, you need to know
how these things work. When you are not
doing multiplayer, you can do it in a lot of ways and it will all work on the one
instance on your machine. But when you are trying
to do it in multiplayer, you are going to have to know
when you need to use
which kind of communication and the instances of your Actors
on different clients and the server communicate
with each other. Knowing that and using that
as part of your design when you are working
even on a single player project will set you up to be able to
faster get the results you want if you are developing
a multiplayer game.>>Christian: Yeah, even in
single player games, think about efficiency and think
about your target platforms. Especially when you
are starting, if you think, oh, this is just only going
to be a single player game, it is not going to matter, so it is fine if I am getting
all Actors of class every frame to check
this one Actor. Whereas you could get exactly
the same thing at the beginning of Level of
get all Actors of class and add those Actors to an array and never get
all Actors of class ever again and just reference that array
for the rest of the Level. There is a lot of optimization
like that that you need to think about
in Blueprint communication and think about
how you are calling stuff. I hope Zak touches
on Event Tick in there and why you should never use it
as a designer. At least that is my opinion. But always think about
efficiency and performance. Again, both the target platform
that you think you are going to be on and where you could
possibly be going. That is one of the biggest
things with indie developers is that you have the flexibility
and the independence and the mobility to be able
to change to market conditions. Hey, a new lower end
mobile device takes off and is super popular
and Unreal Engine supports it. But if your game
is hugely inefficient because you have only tested it
on your massive water-cooled PC and you do not have
any efficiency built in, it does not matter whether you are
single player or multiplayer. You are going to run into
huge performance issues as soon as you try to bring it
on that lower end hardware. Building in performance
and optimization ahead of time, even if you do not think
it is really super necessary right now,
there is no harm in doing it. You are going to learn a lot of
stuff while you do that as well.>>Victor: Did you consider using
Blackboard and Behavior Trees for basically the logic
of the chess pieces?>>Christian: It was a
possibility. I worked with Behavior Trees
quite a bit in my last Unreal game that I worked on
before I joined Epic. It is not really needed
for the logic of the moves. The way that ParaChess
is set up is not – it is intentionally all glass
and smoke and mirrors. It is intentionally
not moving Characters. One of the reasons
I do not move Characters— the biggest thing
that everybody says when they see this game is oh,
it is like Battle Chess. They are like, well,
can the Characters fight? Well, they could.
I can still get the Characters. Actually, it is on my list too to have
when one Character captures, they will beam in, you will have
two Characters in each corner. They will both play
a little fight animation, and then one will win.
That is on my list. That would be relatively easy to build
within the existing system. Having an AI pathfind
through the other AI or have them play
a walk animation and then in the old
Battle Chess system, one Character would just slide
out of the other Character’s way while one Character went up
and those kinds of things. That was not really
a high priority. It did not bring
a lot to the game. It is not revolutionizing chess.
Teleporting Characters around
is just as useful. The way I would approach –
again, because I am building
to this rule set and it is not about necessarily trying to build the smartest
next thing in chess enemy AI, because I am never
going to do that. I am never going to be able to compete with anybody
in that realm.>>Victor: That is not the goal.>>Christian: It is more about
creating a functional— Yeah, that is not the goal.
Just by having a system— In chess, it is always
a set number of variables. Every single thing is always
a set number of variables. That is one of the nice things
about chess. There is no time
that AI has to react where at the beginning of the turn
the queen is in one place, and at the end of the turn,
the queen is in another place like a shooter AI
might have to do. That is where AI Blueprints and
things like that come into AI reacting on the fly of,
hey, I am doing this. Now the situation has changed,
so I am going to switch over to this other behavior
in my Behavior Tree because now the inputs
are different. In chess,
the inputs cannot change. Until I start getting
crazy later.>>Victor: That is great. I think we are actually
a little bit over time here.>>Christian: Oh, no.>>Victor: We have definitely
gone through
quite a bit of questions. Yes, we are.>>Christian: I could go for
another hour talking about this.>>Victor: I know you can.
That is what is so great. For everyone,
Christian very frequently visits Meetups here in the US, so if you have the chance
to attend one where he will be— Where do you usually advertise
which meetups you will be at? Is that Twitter?>>Christian: Usually Twitter
is the best place. I try to get stuff out
ahead of time onto the launcher. Amanda is super helpful
with that, but sometimes the dates
do not come in, get locked down. A lot of times the meetups
especially are getting locked down a week
or two in advance, and then there is not enough
prep time to get stuff up
onto the launcher. If you follow me on Twitter,
@Serellan, it is in the tweet
that you guys put out. Usually what happens
with Meetups is I will have a show
or a conference in a specific region.
A few weeks ago, I went to the Vector Conference
at Eastern Kentucky University. While I was going there,
I reached out to Amanda. She touched base
with the Meetup leads, ended up in Indianapolis
and West Virginia. They had meetup openings
around that timeframe, so then once the conference
got locked down, then I had a couple weeks
to lockdown with them. Then they locked down
their venue, and I think a week and a half, and then I was able
to share it out as soon as they had
it locked down. It is a real collaborative
effort with the Meetup groups because they are
community driven. I try to be as flexible
as I can to help support them. Sometimes that means things come
down a little tight to the wire, but definitely Twitter,
LinkedIn you can also— If you do not do
the more casual social media, LinkedIn is another great place
where I try to share all of the various different Meetups
and opportunities like that.>>Victor: That leads me—
Not putting my hands in Christian. I am so sorry.
No hands in Christian. I cannot, really.
It is kind of blocked there. I just shared a link
to our user group page where you can actually find where all of our user groups
are around the world. If you feel inclined
to host one, there are none in your area and you think there is
a local effort to go to them and share what you are
working on, feel free to reach out to us
at [email protected] We will take it from there. We will let you know what it
includes and some good tips and tricks to think about
when you are hosting, and how to— As always,
finding a venue is hard. We know that. We are trying
to find one right now, actually, down here in Raleigh
that we can use that is not necessarily
just a bar. A better place for us
to bring our laptops and projects and such. It can be tricky, but feel free
to reach out to us. Christian,
it has been a pleasure. We are not going to say
goodbye just yet. I wanted to mention
a few things. For those of you
who do not know, all of the Paragon Assets that Christian
is using in this project are actually available for free
on the Marketplace.>>Victor: They have been out
there for a, while,
so most of you might know, but I just wanted to make sure
that we mention that if you want to go ahead
and play with them. They come with
all the animations. There are particle effects. I am not sure how much audio
there is for attacks and such, but I do know there is quite
a bit of VO in one of the packs.>>Christian: Yeah, there is the
VO pack, and it has a bunch
of audio Assets too. Definitely take some time to dig
into those folders as well. There are effects and things
that come with the Characters that are not necessarily
hooked up by default that you can use
in a lot of different places. I think the effects
that I used for moving, exploding those Characters, those are out of I think the
Monolith, the actual environment pack. I do not know what they were
used for in actual Paragon. Then I think
my little twirling effect I think I got out
of the FX variety pack which is available for free
on the Marketplace as well
in the sponsored section.>>Victor: If you do start
downloading all of them, make sure that you add them
to a project that is not your main project, because otherwise that can
get bloated really fast. The Assets are large. They come with a bunch
of Materials and Textures and animations
and everything else. Use a sort of intermediate
project where you just move all those files to check it out
and experiment with them. If you would like for us
to host you as one of our community
spotlights, post on the forums. You can also send us an email.
We are inclined and we love watching everything
that you guys are working on. As you could have seen
if you were here from the start, which was quite
a while ago now – we have been going on for a bit.
We have a countdown video which is 30 minutes of
development time that you record and then speed that up to
5 minutes and go ahead and send us that to, again,
[email protected] together with your logo,
and we will probably go ahead and put you on
as one of the countdown videos. It is always fun to watch them, and sometimes you learn
quite a bit just from seeing someone doing so much
in such a short amount of time. It is pretty useful. Thanks to Exodus.
He is in the chat as well. His was the countdown video
we were showing off today. If you are streaming on Twitch, make sure that you use
the Unreal Engine category. I frequently visit that. I know Tim and Amanda
do as well. We love to come and check out
what you guys are working on and just be part
of the community. As always, follow us
on social media. That is where you will most
commonly see all of our tweets
about the news and such. We also do a highlight
in the livestream, but we are also on social media. We are not only doing
this livestream thing, because that would be tough,
every day, every single time we got something going on.
I do not think we can do that. Special thanks to all of you
primarily, because without you, there would not be
an Unreal Engine Community and we would not be doing
these livestreams. Then I would like to let
all of you know that next week
we will have Oystein. I am actually pronouncing
his name right because I am from Sweden, and therefore I know how to say
Norwegian names. Hopefully. I am saying that,
but I do not actually know. Oystein from The Future Group
will come and talk about
the Virtual Production Tool, the way that they
have customized Unreal Engine to be able to do live
AR. They actually did
the Superbowl event, and he is coming on
to talk about that, which I am really
excited about that. I have been chatting with him
for a bit to come and make that a reality
for all of you. I think with that said,
that is it. Thank you once again, Christian,
for coming on and showing ParaChess
to the world this time. I know you have been doing it
at a couple of Meetups, but it is great to be able to
share it with a larger audience. The chat was definitely liking
seeing some of the progress, for those of them that have
already been at the meetups and met you already.>>Christian: It is really
exciting to finally have it out to a broader audience. It is a little more intimidating
coming on the livestream than with 50 people at a Meetup. Yeah, so now I definitely
have got to finish it. It is officially announced now,
I guess.>>Victor: Yeah, it is happening. You did say that you were
going to share the project. That said,
that is live. It will stay on the internet
forever now. You all can keep tabs
on Christian and what happens
with the project. Definitely interested in seeing how some of your console
development goes and the things you had to change or the stuff you learned
to make that happen. It can definitely be
a little bit of a barrier taking your product
that works so well on PC and then making sure
that it works on consoles. I am sure there are
a couple of steps there that will teach you a lot, and then you can share it
with everyone who is excited about developing for console,
which I think most of us are. All right, that said,
we will see you next week. Christian is saying bye
from Seattle. I am saying bye
from North Carolina. You all have a great rest
of your week, and I will see you next week.
Bye, everyone. ♫ Unreal logo music ♫

Comments (8)

  1. Wat the desenvolved and Finding Bigfoot the game?!!!!

  2. Can you post a tutorial for Linux developers on how to get assets you buy on the store to your project on Linux?

  3. 12:00 begin play

  4. What is the name of the game from the start of the video?

  5. Love the Marketplace

  6. BattleChess on the Amiga did it better and without all this tech

  7. People who disliked the video are those who love to watch useless pseudo tutorials. This one is about real experience developing actual game. With a lot of info.

Comment here