Making a Space Shooter Game (SpriteKit : Part 2 : Swift in Xcode) Video Lecture | Swift in Xcode: The Complete iOS Development Guide - App Development

everybody welcome to part two of how to
make your own space shooter game with
Swift in Xcode today we will be dealing
a lot with contact and collisions and
physics so let's go ahead and get
started all right so this is what we're
going to accomplish I have a player he's
putting out bullets and these bullets
can actually affect every enemy and kill
them and then when we hit the enemy
ourselves we are going to die and move
to another scene so let's go ahead and
get started so let's open up our Galaga
one die Xcode project as I improperly
named it for some reason we did a head
over to our game scene dot Swift and
inside of our game scene dot Swift we
are just going to say a struct so we're
going to build this structure and this
is also right outside of your game scene
class so we're going to build this
structure right up here that is go
actually going to call each of our say
if we have our enemy right down here
we're going to call our enemy and give
it a specific integer and this will
allow things to collide later on so
let's go up here into our structure and
we're just going to call this structure
name physics category and it's out of
this physics category we need to say
static let and this will be our enemy
equal our : u int32 so this is going to
be basically a 32-bit integer which
means there's going to be 32 zeros equal
equals 1 so in in binary this would mean
we'd have 32 zeros and the last one of
these zeros would be 1 it's pretty
simple and then down here we need to say
static lept this will be our bullet : u
int32 equal 2 which again would make
this equal I'm getting ahead of myself
which again with this would actually
make it equal 0 0 0 0 0 and this would
be 1 right here so it we're just turning
on different ones and zeros in order to
actually get the enemy and the ball
to collide and for our last person we
should just say static let this will be
our person so this is going to be our
main guy that we want to keep alive and
we want to say this was a uint32 equals
three and again it would basically be
the same thing as this just with the
third one turned on correct me if I'm
wrong in the down in the comments
sections down below but I believe that's
how it's supposed to be all right so now
that we have our physics category all
set up we need to go down here to our
game scene and first thing we need to do
is add physics to our person now our
person or our player should go I should
have called this player actually static
lit and this will be player just to not
confuse things so we say static let
player uint32 so down here we want to
add our physics body to our player and
this is going to allow us to add physics
on to our player so in order to do this
we just say player dot physics body it
already has a physics body but we need
to edit it so player dot physics body
equals SK physics body open parenthesis
and this is going to be rectangle of
size and this will just be our player
player dot size so we're basically just
grabbing the size of our player that's
already there and putting it inside of
our physics top body alright so now that
we actually have our physics body on to
our player if we were to build and run
this right now we should see some
physics being applied to our person but
not the physics that we want we don't
want any gravity affecting our person so
in order to fix this you just say player
dot physics body dot affected by gravity
will he be equal to false so we want to
just turn that off so now if we were to
build and run we should get our player
just automatically he's going to be in
the same way that we were doing before
so now that we have that on let's go
down here in down to our player again
give him a category as we just created
right up here so we're giving him one of
these integers that we created right up
here and we're gonna put it right in
down here in
to our player so we can say player dot
physics body dot category bitmask
will be equal to physics category will
be created up here the structure right
up here
physics category dot player so we're
giving him this physics body now we can
go down here again and we can say player
dot physics body contact test bitmask is
equal to physics category dot enemy so
this is basically saying we want to
check if we're colliding with the enemy
because we don't want to touch the enemy
or else we'll die that's basically what
it's saying now go down here and we want
to say player dot physics body dot
dynamic will be equal to false this will
just make it so things don't exactly
affect it the way we want to all right
and now we want to go down here to our
spawn bullets and we're gonna add a
physics body onto it so we can go down
here and we also want to do this right
before we add our child onto our scene
this way everything that you see is
automatically going to be put inside of
the bullet anytime it's added to the
child so I'm gonna make sure I did that
up here yep it's right all before this
self dot add player so now we need to go
down here inside of our spawn bullets
and say bullet dot physics body equals
SK SK physics body open parenthesis and
this is going to be rectangle of size
and again we're gonna say bullet
dot size now go down here and we're
gonna add some more bullet dot physics
body dot category category bitmask
will be equal to physics body dot and
this will I mean physics category
physics category dot bullet so there we
have it now we have our bullet connected
with this integer that we have right up
here then we need to go down here and
we're going to say a bullet dot physics
body dot collision bitmask or actually
this will be a count contact
contact contact test bitmask will be
equal to our physics a category dot
enemy so we're gonna make sure that the
enemy is not touching this and then
lastly we need to go down here and say
bullet dot effect physics body that's
affected by gravity will be equal to
false so the bullets don't go flying off
to into the never land so now if we were
to build and run this right now but you
would actually see that our bullets
they're reeling there they're fine but
they're also avoiding our person which
is not fine so in order to fix this we
need to go down here to our bullet and
we need to say bullet dot dynamic bullet
dot physics body dot dynamic equal to
false I keep just wanting to say bullet
dynamic and that is not right so now we
need to build and run this real quick
and we could and now you will see that
the bullet is not interacting with our
person in in any way now the diff we
want this to be different for our
enemies so down here in our enemies we
need to say enemy dot physics body
equals SK physics body open parentheses
rectangle of size and this is going to
be enemy dot size again and then go down
here and enemy dot physics body physics
body dot category category bitmask
equals physics category dot enemy so
we're playing him again with those
numbers that we have up there so now we
have enemy and then enemy dot physics
body dot contact test bitmask
so again we're testing who is this
person colliding with and what happens
when we collide with him so we can say
contact bit mask and we want him to go
with the physics category dot bullet
like so and then we lastly need to say
enemy
or there's a few other things enemy dove
physics body that affected by gravity is
equal to false and lastly we need to say
enemy dot physics body dynamic will
again be equal to true this time so now
if we were actually to see this real
quick we'll see some bullets bouncing
off of him and we'll see the person
bouncing off of him so we were to
building around this you will see boom
they're bouncing off that is exactly
what we want this is not exactly where
we want we will fix this in just a
moment so now let's head back to our
project and we can go down here to our
spawn bullets and I actually did
something a bit wrong in the first part
of this whole section we need to say
bullet that position equals CD point
make that is perfectly fine we want to
make the action part of this is not fine
so we need to go down here and we say
let action action done equal SK action
dot remove remove from parent so this is
going to remove our bullet from our
scene and last thing down here we need
to go to our bullet and we say bullet
dots Run action and this is going to be
SK action dot sequence and this is going
to be we're going to apply the action so
we say open bracket close bracket like
that and inside of this action we want
to first do our action and then once
this action is done once it has reached
that positive 30 we want to say action
done and then remove it from our parent
and also it's missing in other
parentheses so now if we were to build
and run this we will actually get things
to look a bit more normal
as things weren't really deleting it up
there before now things are deleting and
we will and you can see that these
enemies aren't coming down at weird
angles anymore which is just how we
wanted it now down here inside of our
enemies we want to do the exact same
thing so as this action is moving we
want to go down here and say let action
done equal SK
action and also I forgot you don't need
this part right here inside of our
bullet we need to take this part off
right here that says repeat action
forever as we are finished that right
there so now go down here and we could
say let action done equal SK action
remove from parent and then enemy dot
run action and this will be SK action
dot sequence open print open bracket
close bracket and inside of those
brackets we can again put our action
coma and then action done and end those
off with the parenthesis and everything
so now if we were to build and run this
we will see again it's gonna be the
exact same thing that we were just
noticing before except you have that
contact and everything is perfectly fine
now we want to actually take these
contacts that are happening and make
things happen so in order to do this go
down here to your class game scene and
right after a SK scene right up here we
need to get a comma and we are going to
add SK physics contact delegate so we
want our scene to delegate what happens
when we interact when two objects
interact now alongside this delegate
that we just added we actually get a new
function out of this as well and this is
known as did did begin contact so
basically what this is doing is you can
see up here player dot physics body
contact test bitmask equals physics
category enemy so this is going to say
trigger this did begin contact and then
we're going to run some functions off of
this contact so if I were to actually
just right in here NS log hello
and also we forgot one last thing this
is crucial I spent hours trying to
figure out why on earth my my stuff
wasn't working this is super crucial we
need to save physics world dot contact
delegate equal self very crucial or else
your contacts will not work properly so
now if we were to building
this right now we would actually get our
contact delegate calling all of all of
these functions it keeps saying hello
anytime we get some objects hitting as
you can see right there so there you
have it that is how this did begin
contact works so now we want to take
this did begin contact and apply it to
our people so instead of saying NS log
hello we want to actually take what
objects are hitting each other and do
stuff with them so we can easily save
our first first body colon equals SK
physics body and this will be equal to
our contact dot body a now our body a if
you don't know where that I'm getting
that from is it's right inside of this
physics body contact that we have inside
of our function so we're basically
taking the first body that hits in the
second body that hits and doing stuff
with it so we can save our second body
will be again will be : sk physics body
equal to our contact body b this time
then now down here we want to say if our
first body dot category bitmask is equal
equal to as this is a comparison
statement so if our first body dot
category bitmask is equal equal to
physics category physics category dot
enemy and our second body so and and
ampersand ampersand and our second body
we want to say second body dot category
bitmask
is equal equal to our physics category
dot bullet then we want stuff to happen
and also i forgot to add some
parentheses around this as we will be
putting this all as one okay so now we
have these if statements and now inside
of this if statement we want to call a
function and we're going to create this
function right now and we're going to
save func
a collide para collision with bullet so
this will be called any time our
collision happens with our bullet and
then we're gonna add some notes or SK
Sprite nodes into this so our first node
will be our enemy and this will be our B
an S case bright node and then comma and
this one will be our bullet and this
will be our s case bright node as well
and then add some open curly braket and
then hit enter and close curly bracket
now first off we're just gonna put an NS
log in there and make sure that we have
everything set up and then inside of
here we want to say collision with
bullet and our enemy will be equal to
our first body
node and this will be as an SK sprite
node so we're taking this node as our
first body and we're playing plunking it
in as an SK sprite node now the reason I
have to do this is because if I were I
can't call just the bullet that I
created because it's it's specifically
called inside of this function right
here and this is also really important
to game development as you want to call
more and more people you need to create
more and more objects as well and that's
not going to play well if you just have
one variable that's outside of your
function up here so that's why you need
it this inside of one function and build
it over and over again now this bullet
will not be referenced so we need to do
a extra special way of referencing those
bullets or those enemies so we need to
say collision with bullet and this will
be first body node as SK sprite node and
our bullet will be equal to our second
body dot node with our as in SK sprite
node so now if we were to build and run
this you will see that when we get these
button once these things collide we will
get our hello being called so as soon as
these collide we're getting hello being
caller
as we exactly wanted now instead of it
just saying hello which is kind of
boring in a game we need to say our
enemy to remove from parent and our mmm
all right this will be our bullet don't
remove from parent so now if we were to
build and run this right now we would
get our enemy and our bullet when they
collide they disappear so as you can see
the bullets when they hit they're off
and on that's and that's because when
you're actually referencing this it
could be either the first body is the
catagory doublet mask or the other body
is the catagory definite mask so what
ever did you fix this you actually want
to just copy this whole if statement
right there inside of those parentheses
we're gonna click enter and we're gonna
add that right afterwards and then right
in the between here we want to say
straight line up twice and this is going
to say if the first body category it up
mask is true or if this one's true then
we can build and run this right now or
actually this one we're we need to
actually replace our enemy and this was
the whole reason I did this inside of
our first body dot category bit mask we
need to say physics body category dot
bullet and we're basically just
switching these around so if there's a
if the category is bullet or if the
category is enemy then we want our
people to die if that's a correct term
so now if we were to take this and now
you will see that no matter what the
bullets are hitting and they are
automatically killing all the enemies
there is no more context going on now if
you want I want to actually shrink down
how fast these bullets are going so
let's go up here to our iron spawn and
I'm just gonna set the timer to three so
every three point three seconds we get a
bullet being called and we also want our
bullet to go a bit slower so in order to
do this I'm going to go up here to my
bullet and inside of the action I'm
going to make the duration just
0.8 and now if we were to building on
this just tweaking these things myself
you of course can make this however you
want to make it however you like it but
I'm going to make mine a bit slower as I
like that so now as you will see we have
no more bouncing bullets and we have our
enemies dying every time the bullet hits
now another thing that we want to happen
is we want to our score to go up scoring
awesome so now we need to save our score
equals something actually simple that's
why I cheered so a var score will be
equal to a integer so go up here to your
game scene and we'll save our score
equals an integer open parentheses close
parentheses and then we need to go down
here and we're gonna say collision with
bullet so anytime this collision happens
we want our people to die and also our
score to go up and right now we're just
gonna NSLog our score as well any time
are we get a hit just so we can see
what's going on so we can say NSLog open
quotation mark close quotation mark and
inside of this we need to say your score
so we're going to reference our score
anytime this is built so if we can build
and run this right now so now if I just
killed that person we should see our
score going up like so so now that
that's done we need to add this onto a
label so our people can see it so we
need to say VAR UI label or we need to
actually create this right outside of
our did move to view function so it is
not just it's not private it's universal
so we need to save our and this will be
our score label is equal to a UI label
open parentheses close parentheses now
we can go down here and we're going to
add this label onto our scene by simply
saying score label dot text will be
equal to open parentheses close
parentheses open or slash open
parentheses close parentheses I keep
quotation mark quotation mark slash open
parentheses close parentheses and inside
of those we need to say
score so we're adding the score as our
text so now we needed to
programmatically set the size and you
just need to say score score label
equals UI label open parenthesis and
this is going to give us a frame so
we're going to set this frame as a cg
rekt so we need to say cg rekt the cg
rekt and this will just open parenthesis
and inside of this we want to have the X
Y width and height so our X Y value will
just make it actually our self or will
make it 0 0 our width but this will just
put it right in the corner we'll deal
with the X&Y value in just a minute our
width will be equal to and we'll say 100
and our height will be equal to 20 now
we need to say with our score label
score score label dot background color
will be equal to and we're just gonna
make this a UI color dot black color or
actually we need to say UI color open
parenthesis and we're gonna add an RGB
I'm just gonna make this a light gray
color so the red will be 0.1 0.1 0.1 and
our alpha will be equal to a 0.3 as we
want this to be kind of invisible now go
down here and inside of our score label
we can also say score label dot and this
will be our text color and this will
make our color a UI color dot white
color and lastly we just need to add
this on to our scene so we just say self
dot view dot add sub view and this is
different than adding a child this is
adding a sub view which is going to be
our score label so just type that in so
we're adding this UI label view that we
have and we're adding that on to our
scene so if I were to build and run this
right now you will see that we have our
label right up here and right now our
score is zero so we're not really
getting anything out of this so in order
to get something out of our label we
just need to put two
go down here to our did collision with
bullets and instead of this NSLog we
want to say score label the text will be
equal to open quotation mark close
quotation mark slash open parentheses
close parentheses and this will be our
score so now if we were to build around
this we will see our score going up as
you should see there you have it one two
three four five of course you will want
to edit this yourself you could easily
go up here and you can make this like a
nice red color or anything that you want
I'll make it dominant red right now so
now we have a redden nice red color and
now lastly we want this to be collided
with our person with our enemy so now we
need to create another function and this
will be collision collision with person
so when we collide with a person again
we want this to be an enemy and this
will be our s case as an SK sprite node
and this will be our person as an SK
sprite node so now we have this done we
can automatically go up here to our did
begin contact and when these did begin
contacts we can go click on this if
statement just copy and paste that and
we want to say else if so else if the
first body category bitmask equals
physics category dot and this will be
our yeah we'll say enemy as our first
one and our person as our second one or
a player meant to call it player our
player as our second one and then again
we need to replace these so they are
just around so our first body will be
equal to our player and our second body
will be equal to our enemy yeah that's
exactly how we want it and then now
inside of the stiff statement we want to
say collision with person and our enemy
at this time will be equal to our first
body dot
dude and our person will be equal to our
second body dot node and again this will
be as an SK sprite for SK sprite node
for both of them so put that in there as
SK sprite node and inside of this
collision we can easily just say enemy
dot to remove from parent and then we
want to say a player dot remove from
parent or this will be this will
actually be our person dot remove from
parent and then we also want to switch
scenes so this is actually I'm going to
quickly do this we're not gonna mess
with a game over scene just yet
so we need to say file new file new file
and this is going to be a go into your
user interface or inside of your
resource we need to go into a resource
and inside of our resource we will have
an SK sprite kit scene go ahead click
we're gonna create is going to be my
scene F CKS I might want to rename this
let's go ahead click on that and this
will just be end scene dot s KS the SK s
means sprite get scene if you didn't
know and now we're gonna go over to our
end scene s KS open up our sidebar right
over here and over here you should see
like a hexagonal pyramid thing and our
name of our scene will just be end scene
so now we have this name already made
for it now if we were to go into our
game scene dot Swift when we have a
collision with person we want to remove
our person as well as the enemy and then
we want to say self dot scene or self
dot view dot present scene and we want
to present the scene that we just
created so we want to say SK seen SK
seen open parenthesis file named and
this is going to be our end scene so now
we're presenting our SK scene with file
named end scene so now if we were to
build and run this you should see that
have our end scene created like so so
now I'm gonna collide and boom we head
on over to our end scene so that's it as
you can see the label was also there so
if you want to delete that label you can
also just go back to your collision with
person and it's a score label dot remove
from super view now if you were to build
and run this we should see as we collide
with our person boom it's removed that
is it for this tutorial
that's it for this tutorial if you
enjoyed it be sure to hit that like
button down below and if you want to see
more tutorials like this for me in the
future be sure to subscribe down below
anyway thank you all so much for
watching and I will see you in the next
one