Godot Tutorial -- Collision Detection and Physics Simulations in Godot Video Lecture | Godot Game: Learn and Master - Game Development

hello this is Mike and welcome back to
our ongoing Godot tutorial series from
game from scratch today we're going to
be taking a look at two subjects that
are related but not quite identical
collision detections and physics
simulations I said they're related
because when you get into physics it
will handle collision detection for you
but you can also in quite often we will
want to check for collisions without
necessarily requiring a full physics
simulation pretty much if you've never
used a gambit in the past it has a
physics engine in it the way they work
is kind of by trying to simulate
real-world physics mathematically so
what you do is you create a number of
different objects I'll explain what
those objects are a little bit later on
that are part of the physics simulation
and then each frame or each update it
goes through and calculates what
particular movements should happen you
then take those movements that apply to
these objects and you apply them back to
your game sprites so that way say for
example if you had a ball and you wanted
to bounce you would apply some physics
to the ball sprite to say this is its
mass this is how bouncy it is and then
you would let it go and then the world's
gravity would pick kick in and then it
would fall until it hit something at
which point it would calculate the
balance and then each one of these
updates the the physics object itself is
getting updated its location and then
that gets tied back to your sprite so in
a in the long run is what you're doing
is you're basically mathematically
calculating the movement based off the
physics of your world now collision
detection is a different thing
altogether
sort of collision detection is simply
detecting if two objects collided with
each other you'll use this all the time
in all kinds of programming from simple
checking if a ray cast or a pixels
within certain bounds for example if a
user clicks on a button that's an
example of collision detection
determining if two sprites ran into each
other that's a type of collision
detection now like I said the physics
engine has all the functionality you
need to do a collision detection test
and more however a lot of times that's
actually complete overkill so first
we're going to look at just calculating
a collision between two objects to start
with it's going to be a little
convoluted and one thing to realize is
later on down the road when we actually
get to
the physics engine the collisions are
done for you it's actually a lot simpler
so this is going to look a little bit
more complex than it is but let's jump
right on it just like hearing and
address my mic hopefully that's a bit
better okay
so I've loaded up Godot here first thing
we're gonna do I'm just create a very
simple scene let's see let's just add a
note at the top and we will add two
sprites to the world alright
sprite one and we'll just we'll be using
this guy a lot I'll just use the icon
that ships with it let's relocate him so
and let's go ahead and create
another sprite reader coop let's give
him I gotta like so bring him over here
oops my bad I parented did it not want
that alright let's try that again
now let's go ahead and the texture okay
so now we've got you sprites in our game
world and what we want to do is just
move this one over until it hits this
one and we're going to check for a
collision and when it does we'll just
start it back to the starting position
where it came from
and we're just going to do this over and
over and over again I don't like having
spaces in my name so I'm an old-school
UNIX guy that way I find they cause more
problems than worth but there's no
actual reason not to I'll just change
that guy to sprite to no space all right
so I need to set my scene up so first we
need to save it that's fine and then set
it as the active scene again if any of
this doesn't look familiar at this point
go back to the old tutorials this is all
covered I'm only going to cover new
stuff as we go through it alright so now
we need to attach a script to this guy
to get it moving so let's go ahead and
with the incredibly horrible name of
sprite one script all right so let's get
to work first thing we want to do I'm
sorry I can't uh there's no ability for
presentation well so I can't make this
code big or easier for you to read
however if you go to game from scratch
comm there's a corresponding tutorial
that has all of the source code listings
I'm doing here available there so if you
can't see what I'm doing here just go to
game from scratch you can get the source
code there it'll be linked in the
comment below or the description below
so first thing we need to do is set up
so that we can update each frame like so
and now we're going to need obviously
the process function oops hit caps lock
key so all right now I need a couple of
variables your collision detection
actually I'll get to that in a second
built-in type of vector
this is just the initial position where
we're starting from so when we reset it
later on we'll have it there and then
we're going to have box 1 and box -
these are occlusion volumes we'll see
that in a second so we'll see that right
now so first thing we're gonna want to
do is just grab our start position like
so and then we're going to want to
create the two collision volumes they
are rectangle shape two DS like so now
the shape 2d class is what you're used
to define a shape in two dimensions so
there's there's the 3d equivalent of it
as well and there are a number of
different options things like bounding
box or the in this case called a
rectangle shape the bounding sphere
which I believe is called circle shaped
2d there's a capsule then there's convex
and concave polygons as well each one of
these is used to define just basically a
shape in general these are what we're
going to actually so your sprite itself
is just a graphic it's there's no real
dimensions to it in the world so these
shapes are going to say these are the
dimensions of my sprite now we're also
going to use the texture resolution to
determine what they are but to do your
collision math you need to use shape 2d
derived classes such as for example this
rectangle shape 2d so that's what we're
going to do is we create a box for that
are going to represent the dimensions or
the location of I suppose the boundaries
of both of our sprites so that's what
box wanted box to are what did I do
wrong
oh I typo'd okay let's try that again
there we go okay so all we're done here
is we get our initial position and we
create two boxes so we haven't defined
them yet we'll define them actually on
each frame because as you you could
potentially be changing your sprite as a
result you could change your dimensions
ultimately chances are that wouldn't
actually happen but doing it on a per
frame basis isn't a terrible thing it's
not that slow either so it's not really
something you need to watch out for so
first thing you're gonna want to do is
get a reference to our other sprite and
it is I believe
old sprite too so you know what I'm
getting in a new habit giving things
slightly better names and for hierarchy
making my hearties all start from a note
because I find you're going to want to
repair things you know never topically
hat you can only ever have one top-level
node as your parent and I find it's
constantly later on down the road I want
to change it so making it a node that
does nothing your parent it seems to be
the most effective way to use Godot so
that's what I'm doing and then the name
node is not particularly good because
it's used a lot so I've been getting in
the habit now of changing it to a scene
root as my name you can call it whatever
you want it's just when you now call
your get node to get the other the other
sprite you're going to have to keep that
name in mind so it's off route and now
it's called scene root like so and it is
called sprite two again if you didn't
take the space out now you would
obviously put the space in right here
but this is going to get a reference to
the other sprite class and now what we
need to do is let's move ourselves zero
point one so we're going to move each
update zero point one pixels to the
right updates called a number of times
per second so this actually gonna be a
fairly fast move rate and you could
probably normalize it based off the
Delta but I'm not going to get that
sophisticated in this one okay why are
you indenting oh because you don't
actually exist I forgot to put the
coordinate local alright so now what we
want to do is define our box
so our first bounding box we use the
method set extent why are you mad oh I'm
indented wrong
all right see if it's happy yet
why are we upset at this point now
I've done something wrong I don't know
what it is specifically yet but I'll
find it in a second here are parsing
okay it might be back now okay so this
takes a vector2
it probably takes a little bit of
explanation of how you defining the
extents of your rectangle and more or
less you're giving it a width and a
height relative to its center so
basically what we want to do is get the
texture of our sprite itself and figure
out what its width and what its high are
but obviously we only want to have that
because the dimensions for the rectangle
shape 2d are relative to its middle so
basically you pass in half with half
height to create the rectangle so then
we want to pass and yet texture then get
size and then height oh sorry and then
wait if two and get texture get size
height give two so that's our vector two
we're going to create the extensive like
so and now we want to create the second
bounding box
they built Vic Thor 2 only differences
this time we are now using sprite twos
reference get text sure
it's size width and sprite to get
texture obviously something's gone wrong
there
sometimes it's not the friendliest
for figuring out why it's not happy that
sprite to get texture yeah that should
just work so I know type for some reason
is returning the wrong type but it
shouldn't be okay so in theory so what
we've now done is we've created two
bounding boxes based off the extents of
each of our textures texture map now
obviously in this case we've used this
family texture so we could technically
use the same box but in most real-world
cases you've actually use two different
images and you would have two different
dimensions etc which is why I've done it
as two different texture boxes so now
that we've got them what we need to do
now is just see if there's a collision
we're checking again this is processed
we didn't run each frame so we just come
down and over if box 1 dot collides and
then what you're passing in now is the
matrix 3 transform for each of the
entities and then the blocks the second
bounding box to check against so we just
do get transform so that's the the
coordinates of the first sprite box - so
that's the bounding box of our second
sprite and then sprite 2 dot get
transform like so so if there is a
collision and we will set our position
back to the start that's it now there's
obviously an error here because it's not
liking sprite - scene road sprite - go
ahead and run this and see what it does
slides plot oh yeah let's get rid of
that the s and use a function that
actually exists and there we go
and if I've done this right boom back it
goes so that is very simple collision
detection again the Mike I'll show you
how quickly alright help
that's fine shape 2d shape too
all right they're shape 2d so so far we
actually just went ahead and used this
rectangle shape 2d which is a bounding
box for I guess obviously since each
sides not the same size a bounding
rectangle that's what we used for the
dimensions but if your sprite was more
accurately represented by a circle or a
capsule which is like what's the word in
ellipse those would be what you would
use instead so it all comes down to like
what the ultimate shape of your thing is
segment shape I believe it's a set of
lines Sigma shifted its just to point
okay so it is actually literally a line
ray shape would be it's a ray cast into
the scene normally you would probably
use this for for Mouse picking line I'm
not entirely certain why line shape
exists as opposed to a segment shape but
we'll leave it at that and then you've
got concave and convex polygons we'll
actually see those in a little bit
longer a little bit later when we
actually get into the the physics engine
itself so there are other shapes you can
use but the basic logic is exactly the
same they all inherit back from the
shape 2d guy and they all have a method
called collide and you can check for a
collision between a rectangle and array
or rectangle and a circle etc and then
there's some more advanced stuff like
your custom solvers you're probably not
going to get into those also you can get
into context which is how the things hit
again you're not going to get into those
most of time what we've covered is
generally what you would use when
dealing with collision detection unless
you get more advanced and you start
dealing with the physics engine itself
which is exactly what we're going to do
next so we're not going to cover that
too much further so simply that was a
collision detection in Godot
as you can see you can you can roll
these hook by hand you create these
objects as you go you just basically
define it set its extents and then check
for collisions done now where this
starts to fall apart and get really
crappy is when you have 30 40 50 60 70
objects in your game and you're checking
for collisions because that's a lot of
if else's and in that case you're
probably best to use the physics engine
even if you're just using us for
collisions because it will handle that
for you all right so now let's move on
to the physics engine itself
this is actually pretty cool stuff
because it gives you a lot of power for
almost free and one of the nice things
about Godot is sort of thing um it's an
all-in-one solution so the physics
engine is built right in and a lot of
times what you have is you use something
like say box 2d it was one of the most
popular 2d physics engines and you slot
that into your code but then what you
have to do is box 2d will work in its
own system it's mostly metro kits so
it's in meters etc I know what you have
to do is map it back to whatever pixel
space makes sense to you Godot works
entirely in pixels so it's quite
intuitive it's when you're working in
the engine if you say move by 90 it
moves by 90 pixels it makes the the
learning curve the learning process
quite a bit easier a lot of people get
tripped up on the process with with like
F integrating a physics engine using two
different math coordinates and it gets
especially knowing when you start doing
things like mapping from UI coordinate
space which might be the origins in a
different location to pixel space and
then casting that ray into physics space
and then casting that value back to game
space and then back to UI space and that
stuff you do all the time and the
all-in-one nature of Godot makes it so
none of that stuff comes up which is
very nice okay so that's one down let's
take a look at physics let's put this
under room video and did it it did I did
it create OOP oh that was dumb all right
one sec let's try this again under video
create the folder called physics so
alright created a new project - actually
let's get this set up really quickly
so for sings first that's at our top
level node call that scene root and add
uh okay I can't go past that point for
right now so let's go ahead and save
this and set it as our default
getting sick of doing this yet all right
Ariel should all be second nature at
this point so now we have it set up it
does nothing but we have a single node
seen set up ready for us to get physical
in pun intended
so now let's get back in the 2d view
over here first thing we're going to do
is we're just going to create a physical
energy a physical entity and have it
apply to a sprite and that's it what we
want to do is basically create it and
then let gravity do its thing and watch
it fall pretty simple so first things
first what I would normally do is create
a sprite at this point but we're
actually going to have the sprite being
owned by something called a rigidbody
now I said earlier that there are a
number of different physics types
available that are used in the
simulation let me just go ahead and show
you them as we're creating this here and
here we go so physics body 2d we have
these three guys here plus the area 2d
which is a little bit different so we'll
not cover it for now but the three
things to be aware of are your rigidbody
your static body and your kinematic body
those are your three different kinds of
entities that exist in the physics
simulation now keep in mind if you've
got stuff that isn't physically related
it doesn't need to have anything to do
with it so let's say for example if you
have buttons or entities in your world
that don't interact with each other in
any way they do not need to have a
physics body attached to them or they do
not need to have a physics body as a
parent this is only for physics related
simulations so you can mix in machs
graphics that are not physically
controlled and ones that are so it's
only things that will be updated by the
physics engine that you need to attach a
body to now let's cover very quickly
what these three different things are
and what makes them differ start with
static because it's the easiest one to
explain static doesn't move and that's
the definition of a static body it's
basically the the physics engine will
interact with it so other physical
entities can hit a static body however
the static body will not do anything the
nice thing about this is and what else
in for the physics engine is it's very
CPU intensive so the less calculation it
has to do the less CPU it's going to
take up which in turn means if you're
working on mobile less battery life
drain the Vice get not getting is hot
and of course everything else will run
faster so it is a someone import
thing to not run - too many intensive
tasks and a static body is probably the
least intensive as they get generally
what you would do use a static body for
something like the earth bounds of your
game screen and I guess simply things
that don't move another thing that you
might use it for particularly is things
that trigger but this is what an area 2d
comes from is you can have you can have
physical entities as well that aren't
part of the world at all but they want
to be aware of it so if something hits
them it will trigger some code to run so
that's another thing that can happen
I'll cover that later on but for now be
aware that there's the static body and
that is a physics object that does not
move next up you have a rigid body a
rigid body kind of a strange name
because a rigid body can be very elastic
can be very bouncy it's got nothing to
do with the tacticity of the object
itself a rigid body is simply something
that has a full physics simulation
attached to it the rigid body are the
most CPU intensive but they also have
the most functionality so rigid body
basically has its the full suite of
things that can collide with other rigid
bodies who can collide with kinematic
and Static bodies it has you can apply
forces to it you can apply impulses to
it etc so the rigid body is basically
your physics entity and you don't want
to have to too many of these things if
you have a game with three four five
hundred of these things it's going to
probably grind to a halt
so you want to kind of keep them to a
minimum I six is you can sleep them
we'll cover that in a bit but you can
actually have them so something's a
rigid body but when only when it's
actually awake is it going to take up a
whole lot of processing power now
finally the last thing we have is this
kinematic body kinematic body is for all
intents and purposes your character for
the most part and there's a couple of
things that you would use it for but
that would be the primary thing is your
game sprite and the idea behind a
kinematic body is unlike the rigid body
the Kingdom if body you control the
movement of so you don't control it by
saying you know set in pulses or
applying force to it or you know giving
it a weight and letting gravity take
ahold of it instead you're basically
sitting there with your joystick or
whatever your keyboard and you're saying
move six in the x-direction move three
in the y-direction
that's what you use a kinematic body for
us when you're actually controlling its
movement however it's still going to
interact with other things in the world
so that kinematic body could hit a rigid
body it can hit a static body and it
ain't it and it participates in the
world but the biggest thing is generally
that you're controlling the movement
there all right so that's an overview of
what the different body types are
available for simulation let's go ahead
and start with a rigid body so you make
it the parent position it wherever you
want in the world I like so and now
let's go ahead and oh so I'll give you a
quick view over here these are the
settings that you can set for it
all right that's kind of pointless Oh
where'd it go
all right come on back so you can set
the mass and the weight now at first
glimpse you would think weight mass and
weight are the same thing as no they're
not mass is more like a physical
dimension or boundary it goes back to
that whole expression of what what falls
faster a ton of bricks or a ton of
feathers well obviously they fault the
sames because they both weigh 1 ton
however the mass of the one volume is
going to be much larger than the mass of
the other volume so mass think of it in
terms of I you usually think of mass
honestly as density so a denser heavy
object will fall faster a higher mass
object will soon forget math correct
here will fall slower so the bigger an
object is and the higher weight is the
less dense it is so anyways that's the
difference we Madison wait wait
ultimately determines how much gravity
applies to something how much impact
something has when it hits something
else
etc and then mass is basically you're
indicating how big your volume is next
up you have friction friction is how two
surfaces respond to each other so when
you run your hand across the top of a
glass desk
you've got your skin has a certain
friction volume and the last is a
certain friction volume now you take
your hand and you run it across the
brick wall for example you're going to
have a lot more resistance you're going
to move slower it's going to take more
force that is ultimately with friction
is it determines the amount of well
friction on that surface so it's mostly
about how two objects will slide or
interact with each other that way
finally you have bounce in other physics
notion balances often referred to as
restitution the whole idea behind it is
the amount of boying in something so if
you've got something that's a ball or
something and they hit something else
bounce is going to determine how much
counter force is applied so how much it
goes back in return to that finally you
have a couple other settings here we're
not going to get into some of these
until later on if at all but sleeping is
what I was talking about earlier can
sleep and sleeping is if something's
slept to sleeping it is no longer
calculated in this in the engine so you
can turn things on and off
and like I said that frees up the CPU
processing quite a bit on the simulation
next up you have these velocities for
angular and linear velocity this is your
angular is a is a direction of travel
whereas your linear velocity is the
amount of speed you're going to start
off going in that particular direction
the engine is ultimately going to
calculate a lot of this for you for
example when it applies gravity it's
going to apply linear velocity down the
y axis but you can if you want to set it
to move right off the hop you can set it
by setting the x and y velocities right
here now this last guy right here is
your layers and layers are very
important because what it is is telling
what will collide with what so if two
things are on the same layer they will
hit each other but if something is on
its own layer and nothing else is in
that layer because obviously you could
have multiple layers so if I put a layer
here like so
I will only hit things that are in this
layer and this layer where's if I do
this I will only hit things that are in
the second layer go back to the first so
I don't screw this up now where this
gets important is when you start talking
entities that shouldn't hit each other
say you're making a shoot-'em-up
bullet-hell kind of game and you have
hundreds of bullets flying around the
scenes you're obviously going to want to
check for collisions against bullets but
bullets shouldn't collide with other
bullets or bullets shouldn't collide
with the world or bullets shouldn't
collide with it they should only collide
with you know other other game entities
and that's where these physics layers
can come in this is what is going to
determine what could hit other things so
it's very important that way for
determining yeah again what can hit
other objects or what can and also for
speeding up your simulation because if
you put everything in the same layer
everything can hit everything else and
that is a little quite often exactly
what you don't want to do all right so
now we've got a rigidbody defined let's
go back in here and create a sprite like
so we will go use our trusty icon like
so and really that's it so you've
created your rigidbody you've applied a
sprite to it and done now I run it and
kaboom there you go you've created your
first physical object it's really that
simple which is kind of cool
and that's Chi
the extent of it to be honest however
there's a lot more to going on but
that's that's how you define physics
entities in Godot you create the nd you
apply whatever the entity is going to be
like in this case my sprite is a child
of that entity so when my physics body
is updated it will update the position
of its children which in accordance here
is our sprite now what you might be
wondering is where did that gravity
value come from why did it fall like
that what if I don't want gravity in my
game which is actually quite common
let's say you're creating a top-down
pool game you wouldn't want all your
balls falling for no particular reason
well these are set in your project
settings go on in here and you scroll
down you shall find physics 2d settings
which have your default gravity and your
default gravity vector vector is
basically saying that gravity applies
along the positive Y axis so as gravity
is applied your Y position is
incremented which makes sense because
this is Y at 0 this is y at screen
height so if you wanted it to go up
instead you could turn this to a minus 1
if you want it for some reason gravity
to go left you could switch this to 1
and 0 okay so oops 1 and press Enter and
0 and press Enter we'll sit down and we
run and it did not work not really sure
why you thought gravity victor
I should have worked
maybe
you do gravity in the x-axis alright
that makes for a particularly bad
demonstration because I am not entirely
certain why that happened
I should have applied so anyways I'll
come back to that later I'll probably
put us a comment exactly why that didn't
work because that is where you control
your setting also you saw that the
gravity amount at 98 saying that it
moves gravity or gravity is applied at
98 pixels per second again working in
pixels makes things a lot simpler so
yeah that's the basics of dealing with
the kinematic object now let's let's
look at a static in the same scene now
let's go ahead and so route selected and
let's just add us attic body so that's
something to collide with I'll tell you
right up front this isn't going to work
so don't be really disappointed when I
press play and it doesn't do what what
you want but don't worry I will show you
exactly why at a later point let's load
in our icon alright so once again a
static body is not going to move so
gravity is not going to be applied to it
it is going to sit there this one is
going to come and fall in an ideal world
hit it and respond in an auto world not
it's going to pretty much just go right
through it to be honest so let's check
so you can see our static body is not
moving that is the point of a static
body it is just a thing in the world
that you can hit whereas our kinematic
body is obviously moving so now that's
done let's now make it so that it
collides and in order to collide we're
going back to our collision things again
the exact same thing we did collisions
earlier it's what we need is a collision
shape we need to be able to tell the
physics engine how this thing is shaped
so go back to our rigid body here just
go ahead and we apply that either
collision shape 2d or polygon 2d and
we'll start with a shape because we
start off we're a pretty square
looking thing we've got slight corners
here but for the most part we're a
square so we just added this collision
shape onto our rigid body now we just
need to come over here and define the
shape so to go over to shape now for one
there's a bug here never pick line shape
for some reason you pick line shape
Godot gets really angry goes on strike
for a little while doesn't ever come
back so yeah don't select that it seems
to be a bug by the way if you're the
good developers listening to this it
seems to be a bug with line shape 2d
don't pick it so we're going to go back
to our rectangle shape now we do is
define that shape so it pretty much oops
bugger undo that define that shape so it
covers our object like so now we come
down to our other guy over here and
static make sure it's a static body and
not the sprite but the static body
selected we then we just go ahead and do
the exact same thing
sure what I'm doing here let's go ahead
and create our rectangle shape
position it roughly all right like so
now we go ahead and run this boom and
there you go there there is how
collisions are now handled in in Godot
by the physics engine it's really that
simple you just basically create either
your rigidbody your static body or your
kinematic body you give each one a
collision shape and that's it now one
thing you might notice here though it's
first off my precision wasn't that great
and that's why they're not they're not
directly on top of each other here so if
you wanted that to work better you would
have to hear that let's fix that a bit
oh yeah collusion shape
on
and over here
a bit better now when they hit it will
actually hit now a lot of times though
you'll have shapes that aren't quite so
se square and then in that case what you
want to do often is actually use a
convex polygon so what I'm saying is
more or less you wanted to find the
outline shape of it using polygons and
thankfully and this is something that's
often quite difficult in other things
because you got to come up with the damn
polygons to figure this out in the first
place in a Godot it's really simple
let's go ahead just delete a collision
shape right here go back to our static
body and we're going to instead make a
polygon that goes around all the edges
and that is by creating collision
polygon alright now this guy works a
little bit different now you'll see up
here you have this little pen now using
the pen you can define the boundaries of
the collision so let's do that and now I
just come down here and I go thick thick
thick thick thick thick thick yes I
don't have to sit click every time I
click do I at this point I kind of do
it's a compulsion click click
click click click ok click click click
and click they go so now we've created a
bunch of polygons that are actually
going to define the more precise
collision mesh than what we had with
just a straight rectangle so now we go
ahead and run the simulation it's going
to behave a little bit different see
because the two surfaces are different
now so more or less it's exactly the
same as you did with collision but
fortunately we could tell there's a
bunch of tools set here like this this
polygon definer here is going to be a
better name than a polygon definer but
this collision mesh builder that's what
we'll call it for creating your
collision polygons it's built in it's a
tool that's right there so if you have
complex sprites that's all that it takes
to handle them and let's now go back and
zoom out a bit let me show you the
effect of a couple of these properties
so we're back to our original engine
couple things let's make it let's make
it a lot heavier
you
all right and let's make it a lot bigger
actually you know what if you put really
stupid values in you're just going to
make the world not happy all right let's
go 300 and we'll keep 300 why are you
not editing 300 enter and we'll put our
weight at 115 enter oh so they're linked
okay now we run it not really that
exciting let's change our restitution or
bounce amount up so now it's going to be
bouncy oh and at a value of one more or
less you're going to go off with equal
force that you came in at this
administration is not going to show you
friction very well because of the fact
that there's no surface to really slide
on let's turn our bounce down to say 20%
and go ahead and run that and now you'll
see it bounces back up a little bit and
let's change this up to 0.5 you'll see
it bounces off a little bit more there
you go and then each contact will be
simulated there you go and at the same
time now I can also come back in here
grab this guy and sorry grab this guy
and click sleep oops here it's now
asleep and we run it and nothing happens
this allows you to turn it off and on in
code so you can just as easily just grab
a reference to the rigidbody 2d and turn
it to not sleeping you know so go
actually go ahead and do that is there a
script attached anything yet no so let's
go ahead and go
I start using better names
I'd say set process oops
it's true get rid of this guy oops
you're all these things and I will go
Funk process Delta and if input thought
is key press key underscore space ah
self dot is sleeping oh that's set
sleeping sauce ah
so now nothing I hit the space bar and
nothing alright it's not turning into
the greatest demonstration ever is it
hold on one second
you
alright I'm back I actually have no idea
what actually this issue is my my script
just wasn't being called for some reason
so when I deleted my object created a
new script created the exact same code
it worked again
so I'm guessing some kind of a bug that
for some reason that that script wasn't
hooked up properly but like I said I
just went ahead and recreated the same
thing exactly the same and then I use
this code here so as you can see you can
turn set sleeping to false and then it
runs so if you want to do a similar
problem it might just be in your best
interest to just recreate your code I'm
not sure exactly what just went wrong
there but as I said it the the the ready
College is not being called for that
script attached to that that node so I
don't know what happened there I just
deleted it and recreated it and it works
just fine so leave that one as a
head-scratcher but anyways back to the
topic at hand the sleeping then can turn
on and off your physics entity so
rigidbody right here by default is set
to sleeping is on we come back here is
your game like so I press the spacebar
and sleeping is off okay so so actually
I guess I should toggle this to X that
way and go ahead and run that and then
now spacebar will turn it on and off we
go
uh so sleeping is very handy if you need
to have things that are being simulated
not simulated simulated not simulated it
allows you to toggle between them I
decreases the processing power
extensively when you do so very handy
handy functionality the final thing
we're going to show here is the
kinematic sprite and we'll use this
exact same simulation as throw one more
guy in here and put him right around
here that will be a kinematic body like
I said kinematic body is often going to
be used for your character and let's go
ahead and we will add a sprite as well
guess which one but you can't see load
on so once again we are going to need a
collision shape or collision polygon to
do the detection I'll just go ahead with
shape because I feel lazy I don't feel
like saying click click click there you
go
collision shape and we're basically a
rectangle
there too about say there all right so
now we have our new kinematic body go
back into a world like so you'll see I
had this guy I'll turn that sleeping off
because I don't want it to be actually
sleeping wake up Susie and go ahead and
run that again see our physics goes on
like normal our kinematic body is kind
of behaving a bit like our static body
but it's not a static body it's just
waiting for input so the physics system
itself isn't going to affect it until we
do something to it so let's go ahead
down to our you know oh I went wrong on
the kinematic body pair of the other way
I might have to change something in the
future apologize if I have to just one
set so let's attach a script to our
kinematic body now we'll call it my
character and create it
you
all right like so okay so if
cause there for some reason it did to me
again each time I'm creating a new
object it's not actually calling the
ready function so I had to delete it and
create it all over again I have a bit of
a bug going on with this project so hold
on just power on through but couple
things to show you here so we created
our kinematic body right here and now I
finally got the script working right for
it and go over here here's the script
very simple but we're just saying yes we
want to handle processing then each time
you're processing we're going to do a
direct move call this move function is
part of our kinematic body 2d says you
see there's right in here for moving and
moving too and also there's a check to
see if it's colliding or something so
then you can in your code check for
collisions and handle them accordingly
obviously you can also check and set a
lot of the collision details as well and
then get the details so you can check if
it is colliding and if it is you can
figure out where it is colliding etc in
your code
I'm not going to handle any of that
right now I don't particularly need to
there's another thing I'm going to show
you here that I use all the time that I
find really infuriating with the way
Kudo is set up is notice that we've got
this compound object made up of these
three different things and this
hierarchy is very important so you
obviously want to move it together and
all of the all the transforms as we've
seen in the past are relative to the
parent so you move the parent and all
the children follow now what happens
when you want to move the parent so I
click over here so I've got the sprite
and collision shape attached to this
kinematic body I want to go ahead and
move this kinematic body yeah so go over
here I grab it and hey bastard you've
selected the collision shape instead and
that gets really annoying really fast
there's two ways you can deal with this
you can first off set it to behind the
parent and behind the the parent so now
when you come here and select kinematic
body and you mouse you get the wrong
thing
alright that's even more annoying that's
what you're supposed to do so that's not
normally the approach I take that's for
doing this your Turing of how things are
shown but what I normally do is I pick
the things that are getting in the way
such as my collision shape well just
defined you don't really need to select
again so just come on up here and hit a
lock on it little for your sprite once
it's defined don't really need to change
it hit a lock so now when you select you
will get the kinematic body because the
other two are locked and if you need to
unlock them simply select them click the
unlock so hand a little trip for
selecting things as a group just lock
the children and then it will give you
the thing you want
so anyways back to our code at hand so
remember the simulation setup so this
guy will fall down and basically rest on
top of this guy now we've added this
this kinematic body here and the ID
again behind a kinematic bodies that you
could directly manipulate it it's not
part of the simulation but it can
participate in the simulation you're
going to see how that works so our code
then simply moves it by 0.1 pixel per
update again this is going to get called
it like 60 Hertz so that's 60 pixels per
second at least and let's go on back
here and see what happens
oops all right that's not a very good
simulation I'm going to fast
let me just lower that down a little bit
to maybe that much and this will allow
us to fall in time our object falls and
rests and our character comes in and
hits it now you notice not much happened
when we hit it you would expect it to
have gone flying or whatever well that's
part of when I was screwing around
earlier let's go back to this guy
remember I see rigidbody
now this should do it okay that's not
the one I screwed around with
all my settings are gone all right so
let's give a very small amount of
balance and there now we're responding
to it
ditto if I go down to our main guy
rigidbody and let's just increase its
mass once substantially and run this you
will now see or why are you not
participating more
okay well anyways first off remember
this this oddity going on right now is
because I haven't defined my collision
boundaries very well so they're
overlapping they're hitting even though
that the images themselves don't I think
it's boiling down to your kinematic body
is not actually participating at all
with the other things so it's colliding
the clinic in the body can collide with
other objects in the scenes but it's not
actually affecting them just kind of
irritating and those are are basically
your your three different sets so once
again your rigid body this is your fully
simulated has full calculations physics
entity your static body stays still
mostly just there to be hit or to
interact with and then your kinematic
body which is there for you as a
programmer to move and it can run around
the physics engine this physics world
and collide with things but that's about
it now let me actually just show you
what scripts on that one so we're moving
now and we'll just do if is colliding
its true and then we'll just simply go
collide I think so so programmatically
you're going to have a lot of times like
if it's colliding with another entity
and then another thing you can do do it
also get what it collided with so this
allows you to say I'll do the collide
with something always it a bullet and
that could be somewhat important
information for your character to
collide with something what was my error
here end of line oops all right so now
go ahead and watch down here and when we
hit collide and we're still colliding
and we're still colliding and colliding
and so that's spamming over and over and
over again eventually they should stop
colliding there we go and it's movement
logic kicks back in the physics object
continues to fall this is actually isn't
updating anymore just isn't clearing out
and that's it that is the different
interactions now there's a bunch of
things I haven't actually covered here
and we're already sitting at 50 minutes
so I'm not going to be covering them at
least at this point in time there's a
few more kinematic things to be aware of
I mean just see if I they're all
together you can have areas or triggers
so you could have part of the map so say
and a level zone you
it's not physically a thing there but
you want to trigger when something
collides with it there is the option of
putting those things in that's your area
2d let me just come and bring it up and
show you area so as it says here general
purpose area detection influences for 2d
physics spelt wrong and this is just the
key things are you can set the signals
or callbacks on a body enter and a body
exit so you can use an area to find
again I trigger a zone so when something
passes through it you can have it call
one of these three signals emit one of
these three signals so you know you
could have the character hits the end
zone the GAMEOVER area the the pocket in
a pool simulation etc kind of handy
there again I'm not going to get into it
in much detail than the other thing that
we've got I don't know where they are
your joints but joints actually appear
to be all under Speidel so that's 3d
only there we go
you've also got joints joints there is a
little bit more complex than we're
getting into here but you have things
like well a joint up like a pin joint so
you could do things like simulate rope
falling around a pivot
you've got damp spring which is for
simulating a springing effect then
you've also got the groove joint this is
useful for making a body slide through a
segmented placed in another I'm not
entirely sure what you're going to use a
groove joint for but there are these
other advanced physical options for
doing slightly more advanced
calculations things like again
simulating a rope or a spring or etc
they are available there the same basic
logic applies though you define it you
create the hierarchy accordingly and
then the simulation just takes care of
it so there's a lot covered there
there's a lot unfortunately we didn't
cover there but as I said we're getting
up there in time I hope that was useful
to you
so a quick recap of what we covered here
first off we did collision detection
collision detection doesn't need the
same physics engine engine at all
essentially what you do is you create a
shape 2d derived object we use the
rectangle shape 2d but there's also
again circle and capsule and then
polygon ones and you use it for just
calculating collisions between two
objects you use the is collide and you
just test the two shapes and the
positions of their parent containers if
there's a collision occurs or not now if
you need a more advanced situation then
you get into the physics engine which we
saw here in physics engine has the three
basic types the static body which you
can think of as a full physics object
sorry the kinematic the rigid body which
you can think of as a full-featured
physical object the static body which is
an unmoving entity in the world but it
can be collided with and interacted with
by a rigid body and a kinematic body and
then finally a kinematic body which
isn't really simulated physically but
can interact in the world which means it
can be moved around by you and it can
collide with physical objects in the
world ultimately this again is normally
like your player ship that kind of stuff
is controlled by a kinematic body where
you are controlling the motion yourself
not letting the physics engines take it
for you but you're still going to want
obviously collide with things that have
physical properties you want to be able
to not run into obstacles be hit by
bullets etc and those are all controlled
by the kinematic body so chemic body
does it the physics engine handles all
the other stuff and that's about the
extent of it you define these things by
making the top level physics entity and
then attaching all the stuff to it so if
you want to have collisions you need to
make sure you add some kind of a
collision shape which either is a
collision polygon which allows you to
precisely define the outlines or it's a
collision shape like we used earlier
with the collision detection if you use
a collision polygon there is tool built
in there that you can define them easily
yourself and then otherwise you just set
up your physical entity that in this
case the sprite that it's going to be
controlled by the physics body and as
the physics body moves it will then move
the position of the corresponding sprite
remember that the controls are in pixel
units so by default gravity is 98 pixels
per second along the gravity vector for
some reason changing the forever
vector did not work we call that one a
bug but it might just be an error on
making I'm not entirely certain there
but that's the crux of it that is
physics 101 in Google and get up the in
the Godot engine I hope you found that
interesting stay tuned for more thank
you very much bye