Rustlang Project: Snake Game

Key Takeaways

hi guys this is tensor welcome to the rough snake tutorial so today we're gonna be building a game of snake that looks a bit like what I'm playing right now now I decided to do another snake game because I feel that snake is actually the perfect program to write given how much information that we've looked at thus far not only is it a really good program to think about right now because it uses all of the things that we've already talked about but it will also help us introduce a few new ideas such as namespaces and error reports alright guys so let's get started here this snake game has multiple different components so it's kind of break them down we have this snake here and I have it just that you know I haven't moving quite slow and the actual rive version will be quite a bit faster the snake game is composed of four main things first one is obviously the snake if our snake eats an apple it will grow by one line and we control the snake by its head when we push an arrow button the head will move up or down or left to right also say for instance the snake is going to the left like it is right now if I push the right key it won't be able to go backwards because if it was it would cause the game to enter a fail stage because the snake cannot actually touch it so if I was to run the snake into itself it will die him over so you have to restart also if the snake hits the wall we die so those are the two main failure states for this game so the second component is obviously the Apple the Apple will appear at random places with this game you notice that the Apple actually appears at the same place every single time we start the game consumed with the snake the snake will appear it at a fixed place every single time we restart the game so our third component are our walls we just want to have these rectangles that go around the entire border of our game board of course there are various other types of snake we could make it so that the snake could pass through the walls but I kind of like this style best and finally we have our game board itself the actual 2d playing that the snake moves along and that the spawns in alright so to get started here we want to type in cargo new and then the name of our game is just going to be snake and we're gonna pass in the - dustbin flag and this will create a binary for us so as per usual we have our simple main dot RS file and you can see here that it's just got a simple hello world program written inside of it what we want to look at right now though is our cargo that um o file and we want to add two dependencies to this the first dependency is R and as in random so this is a library that will allow us to deal with the random numbers for our apple and the second dependency is piston window and this will allow us to render our elements with a UI as well as deal with some of the game logic now notice that we are using these asterisks for the version numbers so normally you'd put the version numbers here if we use an asterisk like this it will choose the latest version so if we go back into our terminal or we can type in card or update here and this will update all of our dependencies in the cargo lock file so now we can come back into our cargo that tunnel file here if we go to the lock file here we can search out the two libraries that we're looking for so for instance if I'm looking for R and you can see here package R and and this is the latest version which is 0.3 point 18 so now I can copy that and I can replace the asterisks here with it or piston window here we can see that our latest version is 0.7 4.0 and we can copy that and put it in our cargo that time o as well now the reason it's important to use static versions is just in case the library actually changes if the syntax changes that our game will not work properly anymore because we will be behind the API now normally libraries try to keep a consistent API but sometimes it does change alright so now to get our dependencies we can type in cargo the old and this will build the entire project as well as bringing the dependencies and compile them and while that's going on we can jump back into main here this is how we actually look at importing external libraries into our main name spacer into our program so we want to type in extern crate so these two keywords here and then the name of the library so brand is one of them and then the other one is our piston window crate and once everything has compiled inside of our terminal here these errors should go away all right so now that our error codes have gone away we can talk about how we want to actually implement the game the first thing we want to do is create a few helper functions so we're gonna create a new file here called drawl dot RS and it's gonna be inside the source folder here with our main dot RS 5 we also want to come back into our main dot RS file and type in mod your all with a semicolon what this will do is it will tell the compiler that we have another namespace or rather another file that we need to connect to our main dot RS file and that is our draw dot RS file here so this will also give us linking in this file so we will check for errors and stuff which is nice which will make writing our code a little bit easier for us now the imports that we want to make inside of our draw file here are piston window inside of it we want to bring in rectangle you run a bringing context and we want to bring in g2d and we can actually see what these things look like they're going peek at definition so our rectangle here you can see here it says contains a definition of a rectangle now our context here is just the struct here and you can see that it has a few fields on it so it has a view port it has a view and as a transform and it has a drawl state so this is what essentially allows us draw 2d content at least it gives us the context to draw the tutee content and then this g2d import is what actually draws it so this is our graphics buffer that's what it stands for is graphics 2d the other thing that we brought in here was the types for color if we peek at this you can see here it's just a type and it's just an array with four elements in it each our type color component you see her color component is an f32 now the first thing we want to do is create a block size constant so we're using the keyword Const constants and rust like many other programming languages require that we use uppercase letters and we need to specify the type annotation that's mandatory with all constants and then of course we set them equal to a value so in this case we want it to be equal to 25 our blocks will scare up 25 pixels or at least by a factor of 25 pixels every single time we create a block and you can fiddle around with this number now next we want to create a function here called to chord and this will take in a game coordinate which will be an i-32 and then we want to return an F 64 so what we're just doing with this helper function is taking a coordinate then we're going to recast it to an F 64 and then multiply it by our block size so we're gonna scale it up based on this number here also we're using this pub keyword what this pub keyword does is it allows us to export this function so this makes this function public to our entire program alright so now let's look at our first major helper function this is also public so reason this pub here we want to draw a block and we're inputting a color here then we're passing an x and a y both are by 32 and we need to pass in the context and then a mutable graphics 2d buffer then we bind this gooey X and the scooty Y and we pass it through our 2 chord function here to convert it by a factor of our block size here and convert it to an F 64 and then we power our rectangle here we pass in a color and then we pass in the actual parameters for the rectangle so this is allowing us to pass in the x value the Y value and then the width and the height then we need to pass in the context transform which we're doing right here and then we need to pass in our G which is a graphics buffer alright so next we want to create a public function called draw rectangle now this is just a slight modification on the draw a block function that we have here and we're still passing on a color and the X and the y the next we're also passing in the width and the height so what this will do is allow us to draw rectangles essentially and the only real difference is that we come into this rectangle here and we just take the block size and we multiply it by the width cast it as an F 64 and the height Casas and X 64 so that we can actually control the size of our rectangle of course we're just going to mainly use this for the size of our board these are our helper functions we may need one more later but that will come later so now let's create a file called snake dot RS in this file we're going to tie most of the logic that we need to actually create our snake all right so here are our imports first we're importing from the standard library collections a type called length list a linked list allows pushing and popping elements from either end basically it's sort of like a vector except it's very easy to get the head or the tail of a linked list thanks for bringing in our context and our graphical buffer again and we're also bringing in the color tight we're also bringing in the draw block function that we just defined here in our draw dot RS file we also want to jump back into our main dot RS file and type in mod snake and this will tie our snake dot RS file to our main dot RS file all right so next we want to create a constant for our snake color and it's an array of four elements each element corresponds with a part of the color spectrum so the first item is our red element the second item is our green element the third item is our blue element and then the fourth element is our opacity so we want to have a green snake so I put this as dot 80 you could put this as one and it would be pretty green and we wanted to have one point zero opacity the next thing we want to do is create an enum for direction so this will handle the direction of the snake as well as how our keyboard inputs interact with the snake so we want the snake to be able to go up down left and right on our screen we also want to implement a method for our enum here so this is the method that will essentially match the directions so that if the snake is going up and I try to hit it down the snake will not be able to go down so the way this works is we have a public function here takes in a reference to self and outputs the direction then we match on a D ref himself and we say okay if Direction is up then pass back direction down if direction is down passback direction up so on and so forth next we want to create a struct real quick for our block type so we just want to have an X and a Y in here both the by 32 this doesn't need to be public because we're not gonna export it anywhere okay so now we want to create a struct for our snake and inside of our snake we want to have the following States the direction that the snake is currently traveling in we want to have the body of the snake which will be a linked list of blocks and we want to have the tail which will be an option block so this is important because we want to have our tail be a actual value when we eat an apple because when we eat an apple then the tail doesn't actually get deleted when the snake moves forward now we want to create an implementation block for our snake so that we can create methods we're gonna create a function called new or a method called new this will take in an X and a Y value and output our snake and we'll say here create a mutable body which will be a linked list of blocks and we'll use linked lists new to create it then we'll use this pushback method appends an element to the back of the list so essentially what we're doing here is we're setting up the default snake so when the game restarts our snake is going to have a length of 3 our first block being x and y our second block being an x plus 1 and then our third block being Y and then X plus 2 so our snake will be horizontal with the x and y coordinate it will also start out moving in the direction right and the Terr will be none so it will be exactly three blocks long and it will be moving to the right body equals body so we're just using that shorthand to just say body equals body because we're already using the name body here and our field is also called body and then tail we're setting to none by default we want to create a function called drawl so this will take in a reference to self the context and our graphical buffer and then we will iterate through our list so we'll say for block inside of reference to cell table body call our draw block function on each of the blocks of the snake with our snake color inside of it so this will render out a green snake now we want to create a head position function here so this will take a mutable self variable and then our output a tuple of a 32 and we'll find the head of our snake by using this self dot body dot front method and you can see here that it actually says provides a reference to the front element of the list or none if there is not it now we're also using this other method on top of it it says moves the value V out of option B so essentially what this does is it helps us get rid of the option enum without having explicitly write some error handling so then our return will just be head block X and head block Y we're going to create a move forward function this will take in a mutable snake reference then it will take in a dir which will be an option with a direction inside of it first we'll match on dir to get the option away from it and not just some D then we want to set our snake direction to D otherwise we're gonna pass back none we're gonna say let last X and last Y which will both pi32 eco our head position so we're gonna call this method here to get the front of our snake and then we are going to match on our actual snake direction we're going to bind it to this new Brock variable if we're going in direction up then we're going to create a new block and this is going to end up on the head of our snake we're going to move forward in the negative y axis the reason why this seems like it's inverted way it works is we have origin here and as you go down this is actually the positive y-axis for instance if our screen is only 600 pixels in height then we need to go down 600 pixels and that would be be like 600 so if her snakes going up in that case it's actually going downwards across the x-axis so that's why we're decrementing this value by negative 1 / actually moving downwards we're moving up the y-axis in this case now left and right are as you would actually imagine them for left we're subtracting 1 and then for right we're adding 1 we're going to push this new block into the front of our snake so like I said before when our snake moves we're actually removing the last block and adding a new front so we're kind of matching here to get our new block the block that we're going to add so if we turn right for instance then the block will be on the right of the snake but if we're moving in and say the up direction then the block will be on the front of the snake so self dot body and then we push this into the front of our list and then we look at the back block so let remove block here you call self dot body pop back which will pop off the back part of our length list and then we use that unwrapped method again so that we don't have an error and then we set self dot tail equal to some remove block all right so the next thing we want to do is actually write a method that will allow us to take in our snake or a reference to our snake and then get a direction so get the direction the snakes moving in all right so you notice here that we're getting an error here that says can I move out of the barbed content now this is happening because we want to actually implement copy and clone for our direction enum so we're gonna write derive copy prone and we also want to do this for our block here we want to implement clone and debug so debug is mainly so that we can just debug it if we want to but the clone tray will allow us to clone the item when we need to use it you'll see here that the error goes away because that's what we're doing here we're actually cloning a direction now we also need partial EQ because we want to be able to do equivalence easier all right so we want another method this one's called next head this will take in a reference to self it will also taken an option direction called dir and then it will output a tuple I'll by 32s so we'll say let had x and y equal i thirty twos and then we'll get the head position using our head position method up here then we'll say okay where we have a mutable moving direction and we'll get the snake direction with this then we're gonna match on the direction that we're passing into this method so if we have a direction some d for instance then we're going to set this moving direction here the one that we got from the snake to the direction that we're passing in to this method then we're going to match again on this new moving direction if there is a new one or the old one if it's the same return back these coordinates now this is just to help us find the head a little bit better because as we're moving around and as we're hitting keys for instance if we turn then the head will actually be in a different place than we expect it to be so this will help with accuracy finally we have two more methods we want to create could another public function called restore tail this will take in a reference to our meat a bull snake then we'll create a brach which will be based off of our tail which will clone we're going to use this unwrapped method as well to deal with the potential for errors and then we're going to push our clone tail into the back of our body so basically you remember the tail doesn't get rendered unless we eat an apple so if we eat an apple this method will be run and the tail will be pushed into our linked list body this is actually the method that being with our snake growing in size finally our last method and the last actual line of code that we want to write inside of our snake namespace is this method called overlap tail so this will take in our snake it's a reference to a snake and then it'll take in an X and a Y and then we will pass back a boolean so create a mutable value then set it to equal to zero then we'll iterate through our body our snake body and we'll check to see if x equals blocked out X and if y equals bracket X so in other words if our snake is overlapping with any other part of its actual body then we'll return true otherwise we're going to increment CH then we're going to check if CH equals the length of our snake body minus one so basically what we're doing with this part of our method is checking to see if our snake is actually over passing the tail so the the back of the snake itself hey you have the snake rotating in a circle if the tail and the head overlap in the same block there actually is a moment there where the head will actually be in that block and so will the tail and we don't want this to cause a failure state because that tail should also you know we'll just move as soon as the head actually occupies that block so there's a moment there where it's a little ambiguous and we want to make it consistent so in this case this is what this part of the function is doing so that's it for a snake file here now we want to create a file called game as with our other files we want to come into our main file and just type in mod game do you link it up with our project then we want to import all of the piston window here so that's why we're using this ass it's saying okay everything inside of this namespace we want to import then we have piston windows types color and we want to go into our random so remember we brought in that random library we want to get out thread RNG here it allows us to create a thread local random number generator seeded by the system so essentially we're using our operating system to create a random number and we're also bringing in this RNG here which is actually a tree and see here it's a random number generator tree then we also want to bring in our snake direction and then the snake itself so the direction he Nam and the snake struck and then we want to bring in our draw block and our draw rectangle functions so we want to create three constants food color this will be red so 0.8 and it will have an opacity of 1 and we want to create border color which will be completely black so each number will be point zero zero point zero zero and point zero zero with an opacity of one and then we want to have our game over screen which will be 0.9 so it'll be red again it will have an opacity at point five so we'll still be able to see through it now we also want to create two other constants ones called moving period and this is essentially the frames per second that our snake will move at and then our restart time is in one second when we hit a failure state with our snake this will pause the game for one second before resetting it and if you find this to be too fast you can fiddle around with it the one I showed you before was 0.5 so twice a second where as this is moving ten times a second all right now we're going to create a new struct called game this will have a snake in it then it will have food exists this will be a boolean so food exists on the board and we don't need to spawn more and then we'll have the food x and y coordinates and we'll have the width and the height of the actual game board then we'll have the game state so this is a boolean so then we'll have the wait time which is this restart time up here where you want to make an implementation blog for our game so we can create some methods here we're going to create a new method so that we can instantiate a new game this will taking the width and the height of the actual game board itself and then will output a game which were then run the snake new function at 2/2 so up here if this is the origin up here at the corner then to two will be two units out and then two units down so the snake should start somewhere around here if our board was pressed up against this depending on how big the units are of course then our waiting time will be zero so the snake will automatically start moving if it exists will be true so the food will spawn and it'll spawn at this x and y then our width and height are of course the size of the board and then our game over will be false but when the game is running this will be false and then once we hit a wall or we hid ourselves it'll turn to true now we want to create another method called key pressed this will allow us to basically figure out whether or not the user has pressed the key and then react accordingly so key press takes an immutable game itself and then it takes in a key type and let's look at the key so you can see here key has all the different keys inside of it and you can use all these key codes if you want to and we're saying if game over then we want to just quit out of this but if it's not then we want to match on key and if key up then we're gonna go up if key down we're gonna go down at key left we're gonna go left and if key right we're gonna go right then we're gonna check dir we're gonna say if dir unwrapped so we're gonna wrap it from the option enum and we're gonna see if it's equal to snake head direction and its opposite then we're going to quit out of this function so in other words if the snake is moving up and we try to hit down then nothing will happen so that's where this head direction method comes in and then the opposite method which we're calling here is the first method I believe that we wrote and see here that it's our method that's inside of direction here alright so then we're calling this update snake method which we haven't implemented yet before we update the snake that we want to create this public draw function this takes in a reference to our game board takes in the context and it takes in our graphics buffer so first we're going to call self dot snake draw and let this will do is as we wrote it it iterates through our linked list and then drones blocks based on those linked lists then we're going to check and see if food exists if this comes back as true then we're gonna draw a block with the food color and the sell food X&Y and then we're going to come down here and we're going to draw the borders so our first border will be starting at the origin here zero zero and then it will have self width which will be the x-axis so like this across the top here and it will have one depth in the y-axis so to be coming down one unit like this and then we pass in the context and then the buffer then our next border will be starting at zero and then self height which will be down here somewhere and it's self height minus one and then we go across the South with so around here then we have our zero zero again and this one will come down the y-axis so it'll go from the origin all the way down to the lower left corner and then finally we have our self with minus one so this will go all the way across and then all the way down and it will be the border across the bottom and finally we run another check and we say ok if game over then we want to draw our game over screen so this will cover our entire screen all right so now we're gonna make an update function the pass in our game stayed here as a mutable game state and then we're gonna pass in a time so the time that's passed as an f/64 they're gonna say waiting time plus equals delta time so we're gonna iterate our waiting time and if the game is over then we're gonna say if waiting time is greater than restart time restart the game and this is a method that we need to write yet otherwise we're just going to return and if not self food exists so in other words if the food does not exist and we're going to call this add food method if self our waiting time is greater than moving period so that 0.1 second then we're gonna update the snake alright so now we're going to check and see if the snake has eaten and we're gonna pass in mutable game state here so we're gonna find the x and y of the head using our head position method they weren't in check if the food exists and if food x equals head x and if food y equals head y and if the head overlaps with our food then we're going to say ok food doesn't exist anymore we're going to pass back false and then we're going to call our restore tail function so in other words our snake is going to grow one block so now we want to check our collision with this method so check if snake arrived pass in our reference to self and then a option of direction here we're going to pass back a boolean so if next x and next y equals the next head so in other words we're gonna look and see the new snake head then we're going to check and see if that snake head overlaps with the tail and as i explained before there is a moment where that head will overlap with the tail and then will return false if we go out of bounds at the window then the game will end and it will restart after a second now let's actually add the food add food this is the method that we were calling up here we take in mutable game state and then we create an rng element and then we call our thread RNG here so our RNG maker who we want an X and our Y and we call our generation of range for the exit will be from 1 to the width size minus 1 why it will be 1 and this should be height so there will be r1 and then to the height minus 1 and then we'll check and see if the snake is overlapping with the tail so we're only doing this because we don't want the snake to overlap with our apple then we will set our food X&Y here and then we'll set so food exists to true all right so our update snake function will take in the mutable game state and then a direction option direction and we'll check if self check if snake is alive with the direction in it and if it is then we move the snake forward and then we check to see if it's eating something if it's not then our game over becomes true and then we set the waiting time to 0.0 so in other words we end the game if it's not true and the snake stops and we reset our waiting time we wait a second and then we restart the game and to do that we have to make a restart function here here's our restart method it takes an immutable game state then we just say ok so I'll tie game is a new snake some time waiting time is 0.0 some thought food exists equals true and we spawn this food at 64 and then we say game over to false now this is very similar to our new function the reason why we don't call the new function is that we don't want to render a new window every time the game resets let's go in here and setup the game and let's get it all finished alright so here are our imports we want to import all the piston window you also want to import the color type from piston window and we want to import game game we also want to create one more helper function so real quick this is going to be very similar to our to cord function here except we don't want to return an F 64 instead we want to return au 32 you can see all this function does is it calls our to cord function and then cast the result as u 32 and then returns it back then the only reason why we want this is so that we have a little bit more precision for specific things and we'll actually get to that when we actually use it you also want to bring that function into our we want to set up our back color and we're gonna set this up to be a kind of gray so if we set this up to like one one one and one it'll be a just a pitch black but 0.5 0.5 0.5 and then one this one Mike red point five blue point five and our green point five and then blue point five and then it will be sort of a darkish gray so now let's delete this println hello world all right so first we want to get the width and the height I'm gonna set them by default to 20 and 20 and then we're going to create a mutable window which will be a piston window and they're gonna say Windows settings equals new then we're gonna create a snake game then we're gonna say to chord u32 width we do 20 times 25 and this will give us 500 and then the other one they were going to be 20 by 25 and so our window will be 500 by 500 with 20s we could do 25 by 25 or 30 by 30 and he would also come out fine so if we do 30 30 our window will be 750 by 750 so this this will create our game window then we're going to call this escape on exit so this will basically just say if we hit the escape key while the game is open it will exit the game we want to build the actual window with this build method and we're gonna add this unwrap function so that we deal with any errors that might come along so now we want to create a new game so we're gonna call game new with our width and height in here and the width and height remember they were changed based on this to chord you 32 so we're gonna use a wallet binding here and we're gonna say some event equal window next and let's peek at the definition of window next here's next event so this will actually clean up the window so every time the snake moves it will clean the window I'm gonna say if what some button on the keyboard so if if somebody presses a button then we're going to call this press args and we're gonna say game dot key pressed and we're gonna pass the key in otherwise we're going to say windowed drawl 2d so it'll actually draw the 2d window we're gonna pass in the event that we got here we're gonna pass in C and G which is context and our G 2d graphics we're gonna clear the window and then we're gonna draw the game and then we want to call our event update here and we're gonna pass in another anonymous function so that's what these are these two pipes these signify anonymous functions and we're going to run game update with our our DT so this is Delta time and seconds you can see an argue is just piston window or updated args so this is mostly part of the library and that's it guys our game is finished now we can see if there are any errors so we can run courier and we'll check and we see here that it actually finishes compiling so now I can run cargo room and hopefully we should see a snake game and there we are so now you see it's a lot quicker than the one I was showing earlier looks like the snake is a little greener than earlier and we have these red apples and so yeah we can scale the window as much as we want and kind of do a bunch of other things I was thinking about doing text in this original version but I decided against it because rendering text and piston is a little bit different than rendering other things alright guys well I hope you enjoyed this tutorial I know it was a bit long and I know I kind of had to rush a bit so that I would fit everything in it's kind of a large program I will be uploading the rest snake to github so that you guys can check out the codebase if you'd like if you enjoyed this tutorial feel free to subscribe and like if you have any questions or comments by all means ask them in the comment section below or on one of the various social media networks that we are attached to and if you disliked it then you know by all means download it as much as you'd like alright guys we'll have a good night