Placeholder Image

Subtitles section Play video

  • COLTON OGDEN: Good morning, good afternoon good evening,

  • depending on where you are.

  • We are currently based in Massachusetts in the United States.

  • But I know we have many viewers all over the world.

  • This is CS50 on Twitch.

  • My name is Colton Ogden.

  • And today we're going to be taking a look back

  • at game programming, which is what I usually program in.

  • Last week on Friday we did HTML.

  • Today we're doing games in LOVE and Lua.

  • And if you don't know what those are, we'll go over them.

  • But they've been used in many streams before.

  • Today we're going to look at a pretty famous game.

  • If you grew up in the 90s or used computers in the 90s

  • you probably had or at least used a Windows machine.

  • And on many Windows machines, there was a game called Minesweeper

  • and it looked something like this.

  • Let me transition to my computer.

  • And Minesweeper has had many incarnations over the years

  • and certainly not just limited to Windows machines.

  • But this is what Windows '95 Minesweeper looked like.

  • So you have this grid of tiles.

  • And we've talked about 2D tile grids before on stream, particularly

  • with snake as a good example, that snake was

  • based around the sort of 2D grid idea.

  • But you have a grid of these blank tiles that all start off unrevealed.

  • And you click tiles individually.

  • And when you click on a tile, it basically

  • tells you how many bombs are adjacent to that tile.

  • And it considers also diagonal offsets relative to that square.

  • So not just up, down, left, or right but also whether there's

  • a tile in the diagonal direction.

  • And so through inferring based on what you see,

  • what numbers you see when you reveal tiles,

  • you can get a sense of where the bombs are.

  • And if you can happen to reveal every tile on the map except for the bombs

  • you win the game.

  • And you get a certain amount of points, as you

  • can see up at the top of the screen.

  • I believe on the left here, this may be the points and on the right

  • would be the timer.

  • I'm not 100% sure.

  • But in any case, that is the game that we will be talking about today.

  • So let me just read off some of the chat here.

  • And everybody let me know if you can hear me, if everything sounds good.

  • We had a network change, although that shouldn't affect this stream.

  • But I did have to rewire everything up to make sure that it worked.

  • So shout outs to everybody who joined the stream early.

  • So, sashka32, bellocures, lewie0416sdo, that's

  • a name that I haven't memorized yet.

  • I'm not sure if you are a first timer or if you've actually been here before.

  • Mkloppenburg, thanks for joining.

  • You and I chatted briefly in the chat beforehand,

  • saying that you really like the code review idea.

  • So we are going to be doing a code review episode or potentially

  • more episodes in the future.

  • Moididie, thank you very much for the follow.

  • So what we're going to be doing is, we'll be soliciting

  • and we did this on Facebook, where we essentially

  • are soliciting folks who are interested in us reviewing their code.

  • And so I'm trying to think offhand.

  • I don't have a Bitly URL.

  • It'd be cool to have a Bitly URL or something.

  • Let me see if I can really quickly do that.

  • So if we have a--

  • just go to Bitly.

  • So a Bitly is a URL that allows you to shorten the longer URLs.

  • So we have a form.

  • Essentially here's the gist of the idea for the new program.

  • So you have a GitHub repo or a gist, those two.

  • We're formally saying gist or GitHub repo

  • is public URLs for your source code.

  • Sashaka32, you didn't get a haircut.

  • You're right.

  • I promised I was going to get a haircut on this last Sunday.

  • Couple of things happened.

  • So firstly, we had a blizzard here.

  • And it was kind of a pain to go out in the blizzard in super cold weather,

  • super freezing.

  • And especially because I would be getting a buzz in super freezing

  • weather, I was like, no.

  • I'm not going to do that.

  • And then I tried to get it yesterday and the person that cuts my hair

  • wasn't working yesterday.

  • So I kind of shafted myself a little bit.

  • But I'm going to say, I will do my best to get it done

  • by Friday if not over next weekend.

  • But yeah, I screwed that one up.

  • Anyway, the code review idea.

  • So the code review thing is something where you, if you're a Twitch viewer

  • or otherwise if you're on YouTube or whatnot,

  • you can submit to us your source code for some repo or a gist.

  • And we'll take a look at it and on stream, David and I

  • will grade your code sort of in the same way

  • that we do with CS50 students at Harvard,

  • where we just take a look at your style and your design.

  • So basically, how well is your code formatted and then how well

  • have you engineered your application?

  • Do you have duplication of code?

  • The dry principle, those sorts of basic things.

  • Like is your code well engineered, well designed?

  • Does it look nice?

  • To sort of give you some feedback if you're

  • a beginner or an intermediate programmer and you

  • want to make sure that you're on the right track, we can do that for you.

  • And it would be a cool bit of new content for the Twitch channel.

  • So what I was going to do was, I'm going to the CS50 Facebook group.

  • I'm going to try and get that URL so I can post it in the chat

  • here for everybody who's actively watching right now.

  • Let me just-- I don't want to take too much time on this.

  • But this is a cool idea.

  • I think it could make some great content.

  • Let me get the URL.

  • Going as fast as I can here.

  • OK.

  • Bitly, here we go.

  • OK, create.

  • Long URL.

  • OK.

  • This is going to be--

  • copy.

  • Actually, let's make it--

  • how do I edit this?

  • Customize.

  • So This is going to be CS50 Twitch code.

  • What's the best way to do this?

  • CS50 Twitch code review.

  • It's not really that long of a URL.

  • But I'm going to put in the chat now.

  • So bitly/CS50twitchcodereview.

  • Let me just make sure that that works.

  • Bitly, CS50 Twitch code review.

  • Yes.

  • OK.

  • Cool.

  • So that's in the chat now.

  • So if you go to that URL you can submit your code, your source code.

  • So the form is going to expect a GitHub repo or a gist, a GitHub gist, which

  • is another GitHub feature that lets you basically put your source code into one

  • file that you can share publicly.

  • Ideally the code basis should be somewhat small and manageable so

  • that we don't have to spend too much time grecking through a massive code

  • base.

  • We're not going to bug test, so this isn't like, fix my bug.

  • Although maybe that's something that we can

  • look at in the future for a different bit of content.

  • But this is going to be more like, grade my style.

  • Like, how good does my code look?

  • How well engineered is it?

  • Definitely use it for that intended use case.

  • So I'm going to transition back to my screen here.

  • That's all done.

  • Let me make sure that I'm caught up with the chat.

  • So that was mkloppenburg, Martin posted in the chat about that.

  • So if you're curious what he's referring to, that's what the URL is.

  • Submit that link if you want a chance to have your code reviewed on stream.

  • And we may not be able to review everybody's source code,

  • but we'll take a look.

  • We'll definitely try our best.

  • So thanks so much.

  • [INAUDIBLE], thank you very much.

  • Doing a great job.

  • Appreciate it.

  • Bellacura says hi.

  • Tuxman, let's Minesweep today.

  • And tuxman I think also posted about the source code thing.

  • So tuxman's already in.

  • So follow tuxman's example, join the CS50 review initiative.

  • LightOfHell1 says hello.

  • What technologies will you be using for this, says zakillapotato.

  • And how in-depth will you explain what you are doing and why?

  • Fairly in-depth.

  • I would say probably not as in-depth as prior streams that covered the basics.

  • But we're going to be using two technologies today.

  • So the first technology is called Love 2D, or Love.

  • And it's a framework, a game framework that you

  • can go to love2d.org to download.

  • And the language that it uses for you to actually write your programs

  • is called Lua.

  • And it's a scripting language similar to JavaScript and Python

  • in some ways and kind of its own thing.

  • But download that if you haven't downloaded it already

  • and you're curious and you want to follow along.

  • We've used it in a bunch of streams so far.

  • It's a great 2D game development framework.

  • And we will be using that and covering--

  • I'll be explaining some of the basics as we go along, but not tremendously.

  • Especially because today's game is a little meatier than some of the games

  • that we've done recently.

  • So great question.

  • Never used Lua.

  • Is it worth watching if I'm primarily focused on web development?

  • Again by zakillapotato.

  • If you're interested primarily in web development,

  • you may not get a ton of value out of this particular video.

  • In the future we'll be doing more web development

  • content such as CSS and JavaScript.

  • So it's CSS next week, JavaScript probably the week after that

  • or at least the weeks after that.

  • Bootstrap coming after that.

  • Love and Love 2D are in the context of game development

  • and pretty separated from web development.

  • So it kind of depends on whether or not you have a casual interest in games.

  • But yeah, that is a great question, good consideration.

  • Ultimately all of learning how to program

  • kind of comes together and is useful.

  • But I wouldn't blame you for ducking out of today

  • and maybe watching a future stream on maybe CSS or Bootstrap or JavaScript.

  • But to sashakan's point, always helpful to explore different areas, exactly.

  • Lua has multiple web frameworks like Sailor and Lapis, says tuxman.

  • Oh yeah, interesting.

  • So I guess if you're doing a transpiled approach, so taking a language like Lua

  • and transpiling it to JavaScript, which is common to transpile languages

  • back and forth on the web.

  • For example, CoffeeScript is a transpiled language.

  • It's very similar to Python.

  • And people program in CoffeeScript and then transpile that to JavaScript.

  • So you could do something like that with Lua, it sounds like.

  • I actually haven't dug into Lua web development too much at all.

  • So I'm not familiar with either Sailor or Lapis.

  • But I believe tuxman's much more familiar with that area than I am.

  • Babbox says, what is the deadline to submit code for the code review stream?

  • I'm working on tic-tac-toe using Python, the one discussed on CS50 Beyond.

  • We don't have a specific deadline.

  • So what we're going to do is have a stream next week,

  • next Friday on the code review.

  • And then if people like it and it's a good stream

  • we'll probably do multiple of them.

  • So I would say deadline, next Wednesday try to get it

  • if you want us to look at it and get it onto the first code review stream.

  • I would say try to get it to us by next Wednesday.

  • But like I said, we may end up doing multiple videos, multiple code review

  • videos.

  • Zakillapotato, your hairstyle rocks.

  • Thank you very much.

  • I appreciate it.

  • It's getting a bit over overwhelming now.

  • Adamantium, what's up?

  • Good to see you.

  • Meowcat, hello.

  • Zodiac, what's up?

  • Zodiac, good to see you as well.

  • Pudavodatel, hi from the Ukraine.

  • I'm here for the first time.

  • Yeah, I don't recognize the username.

  • So thank you very much for joining us.

  • I hope I didn't butcher your username too much.

  • [INAUDIBLE] got the XD.

  • LightOfHell1, will David appear today?

  • Physically no.

  • I don't believe he's in Cambridge so he probably

  • won't be making a physical appearance.

  • But I would pay attention to the chat.

  • He will probably make a chat-based appearance.

  • TheTronBot, hello.

  • Good to have you with us.

  • Bilty URL is there indeed.

  • Coldmind, finished week one of the game dev course.

  • Loving the course so far.

  • Awesome, thanks so much.

  • I really appreciate that.

  • Week one, week one, week one.

  • So week zero was pong, week one was--

  • what was week one?

  • I'm blanking.

  • Brain fart at the moment.

  • I apologize.

  • But yeah, I remember it starts to ramp up a considerable amount.

  • My favorite lecture, again, the Mario one which I think

  • is week five or week four.

  • Let me know how-- oh, Flappy Bird.

  • That's right.

  • Of course, of course, of course.

  • Yeah, that one's good.

  • So it's nice because it introduces you to sprites and other cool things that

  • get some graphics involved as opposed to just line graphics

  • and shapes and fonts like we've done for some of our streams.

  • Anyone have any idea why running Love 2D on a VM

  • would actually have a higher FPS than my host machine?

  • Graphics drivers, I'm going to assume.

  • If it's not the software, yeah.

  • It's weird because it depends.

  • Like a Mac drawing API like Metal and stuff,

  • or Vulcan, which is a Windows one, if it's done enough in software

  • and then if you--

  • it's kind of complicated.

  • It's a little bit weird to predict because even that,

  • I would imagine that VMR would try to translate that

  • to the most efficient graphics API for your host operating system.

  • But I don't know.

  • It's hard to say.

  • My instinct would be that it's compiling--

  • that it's using a drawing API that's more efficient in the simulated VM

  • than is used natively on your host operating system.

  • But I have no data to say whether that's true or not.

  • Packopandas, how do you style your hair?

  • Asking for a friend.

  • It's mostly volumizing hair gel, a little bit of pomade,

  • and then hairspray.

  • And then drying the hair with all of those in it at the same time as well.

  • Yeah.

  • Zero indexing the weeks in a Lua course?

  • Yes.

  • I should have one indexed them.

  • That's a good point, actually.

  • Although we do use Unity, to be fair.

  • So there is a little bit of zero indexing involved.

  • Getting 60 frames per second on my Windows machine

  • and it's saying about 200 or 300 FBS in my Ubuntu VM.

  • Yeah.

  • I don't know.

  • That's a good question.

  • And especially using Ubuntu, I have almost zero experience.

  • I mean, not zero strictly speaking.

  • But I have very limited experience with Ubuntu and Emulation.

  • So I'm not sure.

  • That's a good Stack Exchange question, though.

  • And yeah, to mkloppenburg's point, you could

  • be having your Windows machine frame locking

  • and then your Ubuntu is unlocked.

  • And maybe your Windows machine is actually getting 600 frames per second

  • but your Ubuntu machine is getting 200 and looking as if it's getting more.

  • [INAUDIBLE] says, like the hair, too.

  • Sludgebeard, which is a great name, where are you taking the course?

  • EdX, Vsync, or refresh rate?

  • Yeah, those are related.

  • OK.

  • So awesome.

  • So we caught up with the chat.

  • And so Minesweeper, again, just to restate what we said earlier,

  • we're going to be making a version of Minesweeper.

  • We may or may not have the ability to make the entire game in one stream.

  • We'll try.

  • And if we don't get it finished by today's stream,

  • we'll get it finished next Monday or Tuesday.

  • But we'll take about three hours today, three, maybe 3 and 1/2

  • depending on how far we get, depending on how long we anticipate having

  • left by the time the stream is over.

  • I have never coded Minesweeper before, so this is sort of a blind run for me.

  • I have thought of the algorithms and done a little bit of research

  • into how people have done it, but I have not actually implemented this myself.

  • So this is from scratch for all of us together,

  • which is going to be exciting.

  • So it's a grid-based game.

  • So we already have that fundamental foundation

  • built upon from prior streams.

  • That will be easy.

  • We'll be doing things fairly well-engineered today just because it's

  • kind of a larger code base.

  • I say, let's just actually start diving in and get some code up and running.

  • And I'll be paying attention to the stream here.

  • I can actually type back into the chat today, unlike last week,

  • where I didn't have that functionality.

  • So I'm going to--

  • and let me know if this is a good size, if everybody can see everything

  • appropriately.

  • Everything is running at 720.

  • Should look great.

  • I'm going to create in my Streams folder, which is just

  • an arbitrary folder on my computer, I'm going

  • to create a sub folder called Minesweeper.

  • And this will be my folder in which I hold my source code for this Lua

  • project.

  • Love 2D expects that you have everything in a folder

  • or you have a main.lua somewhere in a folder.

  • That's your starting point.

  • I'm going to use VS code, so that's my text editor of choice.

  • It's a highly recommended text editor.

  • It's a really cool text editor.

  • It has a lot of features, a lot of great plugins, lot of great out

  • of the box functionality.

  • But you could use something like Adam or Sublime Text as well if those appeal

  • to you.

  • And I'm sure there are other text editors that are competitors

  • that I don't even know about.

  • I'm going to create a new file called main.lua.

  • For the regulars in the stream or the folks that have watched prior videos,

  • this is all kind of old hat.

  • But this is more just to help bootstrap the folks

  • that are brand new to the stream.

  • I'm going to create a comment block.

  • This is how you create a comment block in Lua.

  • I'm going to say Minesweeper, author, and email.

  • And so there's a few functions.

  • And we've looked at all of these before.

  • This is just part of programming a game in Lua in Love 2D.

  • I'm going to say, love.load.

  • i'm going to say love.update and love.draw.

  • And for good measure, I'm also going to say love.keypressed

  • just so we have that basic foundation.

  • These are all functions that Love 2D expects to exist in your main.lua.

  • It calls love.load once the beginning of the game.

  • It calls update every frame.

  • Get past this DT parameter, which controls basically your frame rate.

  • It controls your interpolation of movement and transformations

  • across different frame rates, rather, so that you

  • can do consistent movement between two machines that

  • are running at different speeds.

  • And then draw, it will basically do everything that's in the draw function

  • after update every frame.

  • So update and draw both happen every single frame.

  • Part of the game loop.

  • This thing called a game loop that Love 2D manages for you, something

  • that often you'll have to manage yourself.

  • NACLEric, caught the beginning of a 650 stream.

  • Nice, nice.

  • And Putevoditell, thank you very much for the host.

  • I appreciate that very much.

  • So yeah.

  • The game loop is sort of this infinite loop

  • that manages drawing and updating and taking an input.

  • And it does this usually once every sixtieth of a second.

  • So that's the frame rate.

  • Bevignite says, there's no mouse click only key press.

  • We will be doing mouse as well.

  • We'll basically be looking to see where their mouse is.

  • So we have to check to see where it is on the grid, which we can do

  • with love.mouse.getcursor, I believe.

  • It might be getposition.

  • And then we will also be doing mouse click as well.

  • This is to bootstrap us into getting a basic application up and running.

  • So I can do something like if key is equal to escape, then love.event.quit.

  • We can bootstrap our application up into something a little bit

  • more sophisticated with defining our own function for checking for input,

  • which we looked at in a prior stream.

  • Essentially Love 2D doesn't let you check

  • for single key presses outside of main.lua,

  • which is a problem if we want to check for single key presses

  • in a separate game state, for example.

  • Which we will probably end up taking a look at by the end of the stream.

  • Now I can run this application, which is cool.

  • And then it gives me a window, a black window.

  • And if I press escape, it'll actually let

  • me quit the application because they defined this bit of code

  • here that says in my love.keypress function, which is again,

  • a function that Love 2D provides you, and it

  • gets this key value for every single key you press, it gets that key value.

  • So we're basically just checking, if key is equal to escape,

  • the string escape, which is how Love 2D organizers

  • its symbolization of the different keystrokes on your keyboard.

  • If the key is equal to escape, then we'll just call love.event.quit.

  • That's Love 2D's way of quitting the application in code.

  • Let's actually figure out how we want to lay this out.

  • So in Minesweeper, and ours may not look exactly

  • like the Minesweeper that's here but it'll look similar,

  • we have all these squares.

  • And depending on where the squares are--

  • or sorry, depending on how the square is interacted with,

  • so whether it's unpressed, whether it's pressed,

  • and whether it's blank, a numerical square, or a bomb,

  • it has a different look.

  • So you can see that the squares that are unpressed look more three dimensional

  • and that's just because they have a little bit of lighting applied to them.

  • And we can probably do that ourself using something fairly simple.

  • What I want to do is, I want to use Push today, which is a virtual resolution

  • library.

  • And so if I go to something that we did before, like for example, not Snake.

  • I guess we didn't do that with Snake.

  • Did we do the Space Invaders?

  • We did.

  • So I'm going to copy the Push library.

  • So if you're curious, the Push library if you're doing this completely

  • from scratch--

  • I can't type for some reason.

  • Ulydev Push.

  • So Ulydev is the name of the user on GitHub that created this library.

  • So it's a library for Love 2D that basically

  • lets you simulate using a virtual resolution

  • no matter what your window size is.

  • So you can see here, this is kind of what that effect looks like.

  • You have this large--

  • this on my actual computer might be, I don't know,

  • 800 pixels tall and 400 pixels wide.

  • But it's looking as if it's maybe only 30 pixels wide and 30 pixels tall.

  • Because using a virtual resolution, it's basically

  • drawing to some tiny image the Mario information,

  • the little simple sprite graphics.

  • And then it's stretching that image to fit a native resolution raster, so

  • something on my actual screen.

  • So it's basically the equivalent of taking something that's 30 pixels

  • and turning it into 800 pixels but it maintains the look of it,

  • the crisp look of it.

  • It doesn't blur it or anything like that, which you can often

  • have happen if you're stretching a texture with filtering applied to it,

  • but you could even simulate in Love 2D if you wanted to.

  • But we're going to do this using the Push library.

  • We're going to get the same effect so we can draw a small 2D-looking grid

  • of stuff, of sprites.

  • And have it fill our window no matter how big our actual window is.

  • And have it look nice and crisp and retro.

  • And I already have-- you can download this library.

  • It's just a push.lua file from the GitHub repo if you type Ulydev Push.

  • I already have it on my machine from a prior stream.

  • So I'm just going to copy this push.lua and I'm

  • going to put it into my Minesweeper folder here inside of a lib folder.

  • And this is kind of conventional if you're doing any sort of development

  • and you have a library, someone else's code that you use.

  • You'll typically put it into a lib folder like this.

  • So that's all I have in my Minesweeper repo here.

  • I'm going to just test that this is working.

  • So we're going to be a little bit more well-engineered today

  • than we are in some other streams just because this is more of a larger code

  • base that we're going to be working with, or at least

  • a more rich set of code and logic.

  • So I'm going to create a source directory.

  • And in that source directory I'm going to create

  • a new file called dependencies.lua.

  • What this does is it basically allows us to store

  • all of our libraries, references to libraries, references to assets,

  • to sounds.

  • If we were to do sprite sheet splitting up,

  • this would be a good place to do it.

  • Just basically any resources that you're using in your game,

  • if those are libraries or artwork or sound, anything like that.

  • So I can say push equals require 'lib/push'.

  • This is relative to main.lua.

  • And what this is doing, is it's importing the push library

  • and assigning it to this push variable.

  • And this push variable is global to our entire game.

  • So regardless of whether it's in one file or another file,

  • we can use push anywhere, assuming that this

  • file itself has been imported in our game, which we're going to do

  • by just saying require dependencies.

  • So now this module, our main.lua has access

  • to push, that push symbol that we created earlier.

  • So in here, now that I have reference to push,

  • I'm going to say push setup screen.

  • Now what it expects is, it expects some references

  • to some resolution variables.

  • So a virtual width and a virtual height and then our actual window

  • within window height.

  • It's going to map the two together.

  • So I'm going to do a another file in my source directory.

  • I'm going to create constants.lua.

  • Another convention which is nice to adhere to,

  • especially if your game ends up being very large and have a lot of constants.

  • Something like Minecraft, for example, which

  • might have a ton of different constants for the different block types

  • in the game.

  • Or some other game, you can extrapolate that to pretty much anything.

  • I'm going to define a few constants in here that

  • are important to my game functioning.

  • So I'm going to say arbitrarily that I want my virtual width

  • to be 384 virtual height 216.

  • I don't know remember if this is the exact resolution I'm going for,

  • but it's something very similar to this.

  • It's like a 1920 by 1080 ratio that looks very similar to the SuperNintendo

  • era.

  • That sort of nice resolution.

  • So virtual width, virtual height.

  • But window width, I want this actual window on my machine to be 1280 by 720.

  • I want this to actually be a 720p window that looks

  • like it's from the SuperNintendo era.

  • So this is how you get that effect.

  • In my main.lua I can now, inside of push setup screen--

  • sorry, one more thing we need to do, we need to require source/constants.

  • And remember, we're importing this inside of main, this dependency.

  • So we get access to all of these things within main.

  • So constants, in this case.

  • So now I can say virtual width, virtual height, window width, window height.

  • And if we do that, we have to do a couple of other things.

  • So I have to say, push begin.

  • And then push finish.

  • Actually, offhand I don't recall whether it's push start or push finish.

  • We can easily change that.

  • Just to make sure that we are actually rendering everything

  • at the correct virtual resolution, I'm just

  • going to print something to the world.

  • I want to say, hello, Twitch in a love.graphics.print statement.

  • Run the game, and dependencies is not found

  • because what I did is I said require just dependencies.

  • This needs to be require source/dependencies.

  • Again, this is relative to where main.lua is.

  • Dependencies itself is within this source directory.

  • So I'm going to run this again.

  • And the method is not begin.

  • It is start.

  • So push start.

  • I always get those two confused.

  • And then now that we have everything running,

  • I'm drawing a 12 pixel font to the screen.

  • So by default, Love renders a 12 pixel font.

  • And it looks like it's actually pretty large on the screen.

  • So that's the result of the virtual resolution at work.

  • And it says, hello, Twitch.

  • It looks a little bit blurry.

  • So I'm going to make a small adjustment in my dependencies.lua.

  • At the very top I'm going to say, love.graphics.setdefaultfilter.

  • And what this does is, it just says, for every resource that you import

  • or you generate whether that's a font, whether that's a text,

  • whether that's a sprite, anything that's art or font related,

  • make sure that you do no filtering on it.

  • You just use what's called nearest neighbor filtering.

  • So it just basically ends up scaling it up or scaling it down

  • by sampling specific pixels and not interpolating pixels, which

  • is how you get bilinear, trilinear filtering, that sort of thing

  • and therefore that blurriness.

  • This will just make it look completely crisp and completely pixilated

  • no matter how big or how small we make it.

  • So if I re-run this, you'll notice that--

  • and it may be hard to see on camera, but we do indeed

  • have a much more crisp font.

  • There's no interpolation of pixel data.

  • Now, this font isn't ideal because it's an alias font, right?

  • Whoever designed this font assumed that it would be used for smaller use cases

  • and it wouldn't be blown up, it wouldn't be enlarged,

  • and it wouldn't be set to nearest neighbor filtering, right?

  • So what we need to do is, we need to choose

  • a more appropriate pixel-based font that doesn't get alias.

  • Aliasing is basically like somebody blurring the edges

  • with making the edges a lighter color or transparent.

  • That's essentially what aliasing is, getting rid of the jagged edges.

  • And that's why our text looks a little bit blurry, even though it's not.

  • It's because somebody who designed the font made the edges blurred.

  • Or if the font is generated, if that particular font,

  • that glyph size is generated, it's being aliased in the process.

  • On dafont.com, which is an excellent resource for getting fonts -

  • I'm going to zoom in just a little bit here - we can go to--

  • looks like they got rid of the menu.

  • If you go too zoomed in, the pixel bitmap section

  • here is excellent for that sort of thing,

  • for the retro pixilated font look.

  • I'm just going to choose an arbitrary one, just to get us up and running.

  • Let me see here.

  • The actual Minesweeper uses this LCD sort of font.

  • It might be hard to see, actually.

  • If I zoom in just a little bit, you can see it just a little bit better

  • there, this font here.

  • So I'm not sure if I'll spend time actually looking for a font like that.

  • But that would be cool if you were designing

  • your own version of this, that would be a design consideration to look at.

  • And the developers of the game made that design consideration

  • because to them, it looked like a bomb defusal type thing.

  • So this is an interesting way to look at or to at least contemplate

  • user experience and making your users feel like they're in the game.

  • And actually, this is a cute image.

  • I didn't see this earlier.

  • There's a soldier using an actual metal detector

  • on top of a texturization of the Minesweeper game.

  • So just basically taking it, putting into the real world.

  • Anyway, somebody's doing it here, too.

  • I'm not sure if that's real or not.

  • But yeah, that's the font that you could consider using.

  • We're not going to do that.

  • We're just going to use a simple bitmap font.

  • So let's pick something.

  • This one's kind of nice and simple.

  • This one's public domain.

  • So we'll use this one.

  • It's called Poco.

  • So it downloads a zip and then it'll download a ttf file usually.

  • I'm going to copy that ttf file into the folder in which I have the stream

  • source code.

  • I'm going to create a fonts directory.

  • Just paste that right into there, poco.ttf.

  • I'm going to go back here.

  • I'm going to go into my dependencies, which I'm already in here actually.

  • Now what I like to do when I'm writing a game like this,

  • I consider fonts and graphics and sounds all to be assets.

  • And I put them into global tables like this.

  • So g fonts with a lowercase g is short for global.

  • This is a good convention and it's often used in game programming.

  • You'll see it a lot in lower level languages, for example,

  • C++ or Java than Lua just because in that particular instance,

  • you need the readability.

  • And there are a lot more uses and easy uses of global variables.

  • But in this case, I'm using a global table called g fonts.

  • And I'm going to set an index to, it was called Poco, I believe.

  • And I'm going to say love.graphics.newfont.

  • I think that's what it was.

  • And then fonts/poco.ttf.

  • And we have a guest today with us here.

  • So he's getting his stool set up there.

  • So this is Rodrigo.

  • What's up, Rodrigo?

  • How are you.

  • RODRIGO SANCHEZ: Hi, everybody.

  • Let me just grab my coffee.

  • COLTON OGDEN: So Rodrigo has been on stream before.

  • So he played at least Mario.

  • Did you play Zelda with us as well?

  • RODRIGO SANCHEZ: Yeah, I did.

  • COLTON OGDEN: I didn't remember 100%.

  • And what are you going to be doing tomorrow?

  • You want to share with the stream?

  • RODRIGO SANCHEZ: Sure, yeah.

  • Tomorrow we're going to be doing a game of 15,

  • which is kind of weird to explain.

  • But essentially you have, say, 16 titles.

  • COLTON OGDEN: We can probably pull up an image, actually.

  • RODRIGO SANCHEZ: Yeah, it might be easier to show a picture.

  • COLTON OGDEN: So, game of 15.

  • And it has the name also, I think 15 puzzle is what a lot of people

  • also call it.

  • But it looks something similar to this.

  • RODRIGO SANCHEZ: So this is what it looks like when it's solved.

  • The numbers are usually scrambled in some way that's solvable.

  • And then you're just trying to shift tiles down to the right,

  • up, or to the left in order to make them in this configuration

  • where everything's from 1 to 15.

  • COLTON OGDEN: And you'll be doing this in Python?

  • RODRIGO SANCHEZ: Yeah.

  • We'll be doing it in Python.

  • COLTON OGDEN: So it'll look something probably similar to this, then.

  • RODRIGO SANCHEZ: Yeah.

  • It'll just be text on the terminal.

  • Nothing too fancy.

  • COLTON OGDEN: This kind of looks like a ridiculous--

  • Oh, is this actually a CS50?

  • This is a CS50 image here.

  • So this is from--

  • which year would this have been from?

  • It's in sig one with netbeans, hacker315,

  • it was probably several years ago.

  • But this is game of 80, which is insane.

  • RODRIGO SANCHEZ: Game of 80, oh my gosh.

  • COLTON OGDEN: That's crazy.

  • And this is a solver, too, I think.

  • Maybe not.

  • I'm not 100% sure.

  • Let me get you mic'ed up though, just so that you're audible on camera there.

  • RODRIGO SANCHEZ: I don't know how long I'll be in, but--

  • COLTON OGDEN: OK.

  • RODRIGO SANCHEZ: --be at least for more than a few minutes.

  • COLTON OGDEN: OK.

  • Well, if you're only going to be on for a few minutes,

  • we maybe don't necessarily need to mic you up.

  • RODRIGO SANCHEZ: I'll be in until Greg needs me or something.

  • COLTON OGDEN: OK.

  • So let me go ahead and I'll just mic you up just so it sounds OK.

  • This receiver's almost out of battery.

  • OK.

  • Where are the other batteries at?

  • For the sake of time, I'm not sure.

  • We don't have batteries around here.

  • RODRIGO SANCHEZ: That's all right.

  • COLTON OGDEN: Well, you should be able to hear Rodrigo pretty well on camera.

  • RODRIGO SANCHEZ: Let me see.

  • People are saying they like your hat.

  • Oh yeah, and Bhavik Knight says, game 15 is not

  • solvable from any random position.

  • That's exactly right.

  • And so we'll talk about tomorrow how to randomly generate

  • the board so that it is solvable.

  • COLTON OGDEN: Nice.

  • Well, I'm excited for that.

  • That'll be fun.

  • In the meantime, let's continue here with Minesweeper.

  • So I explained, I think I talked to you about it in advance

  • because we chatted earlier outside of stream.

  • RODRIGO SANCHEZ: I can be your rubber duck.

  • COLTON OGDEN: I appreciate that.

  • Sometimes I need one of those.

  • But this is Minesweeper.

  • You're probably familiar with it.

  • You've probably seen it.

  • So we're going to implement a version similar to this.

  • I don't know if it's going to be this big of a grid.

  • But we can probably start off with maybe a 10 by 10 or a 15 by 15.

  • And we could expand.

  • Because our code will probably be fairly flexible.

  • We can make it even maybe a random size, which would be pretty cool.

  • RODRIGO SANCHEZ: That'd be fun.

  • COLTON OGDEN: Rigo seems chill, says sludgebeard, Rigo is indeed chill.

  • Spidey27, limit test sounds fine.

  • [INAUDIBLE] 2017 was the last time it was live, says tuxman29.

  • Cool, cool.

  • Sick toque.

  • Not sure what that means.

  • Do you know what that means?

  • RODRIGO SANCHEZ: Not sure.

  • COLTON OGDEN: Sick toque.

  • Maybe that's a type of hat.

  • Is that what your hat?

  • RODRIGO SANCHEZ: It's supposed to be a pseudo winter

  • hat where it's actually R2D2.

  • I'm a huge Star Wars nerd.

  • COLTON OGDEN: Oh, nice.

  • I didn't even notice before.

  • RODRIGO SANCHEZ: If you look at me from a distance

  • it's like, oh, nice winter hat.

  • And then you get up close and it's like, whoa.

  • You're a droid.

  • COLTON OGDEN: So I guess that is the name of a hat, a toque.

  • RODRIGO SANCHEZ: Yeah.

  • It was a gift, so I'm not super familiar.

  • COLTON OGDEN: So the last thing we were doing

  • before you came in was, we were getting a font up and running on the game.

  • So we have just a window right now.

  • Just in, we got the nearest neighbor filtering set up.

  • We have text rendering, we have virtual resolution with the push library.

  • All cool, fun stuff.

  • Now we're going to actually change because if you notice,

  • the font is aliased.

  • It's the default Arial font, which isn't designed for this use case.

  • So it has sort of semi-transparent pixels used on it, or grey pixels,

  • rather.

  • And so what we're going to do is, I went on to dafont.com,

  • got a font that's meant for retro sort of bitmap, pixelated look.

  • It's not aliased, essentially.

  • And I created a new font object here in my dependencies.lua.

  • So within main.lua I can now, because I made g fonts a global object,

  • go into main.lua and say, love.graphics.

  • What I'm actually going to do, so I'm going to do it after push.setupscreen.

  • Love.graphics.setfontgfontspoco.

  • And I capitalized that, right?

  • I did.

  • So now what I should be able to do if I run this is, this will look different.

  • It will be a different font when I run the game.

  • And it is indeed.

  • And now the font itself, if you specify a size that's

  • non-standard for that font, so if we go back to dafont.com,

  • we can see that that font is designed to be used at 10 pixel size.

  • So I believe the default size for the font is 12 or 16 pixels.

  • But what we need to do is, we need to make it a multiple of 10.

  • So it can be either a single multiple, in which case it's 10 pixels,

  • or it can be 20 pixels, 30 pixels, 40 pixels.

  • If you don't specify the proper multiple,

  • it will alias because it's going to try and stretch it out or stretch it

  • down to a size that it's not intended to be drawn at

  • and cause some aliasing as a result of that.

  • So we're going to go over to dependencies.lua.

  • I can pass in a second parameter to the function love.graphics.newfont.

  • And then if I save that and re-run it, it is indeed, if you look at it,

  • not aliased anymore.

  • It's a bit small so we may end up deciding

  • that we want to use a larger version of it,

  • let's say 20 pixels, and then re-run it.

  • And so it looks something like that.

  • That's arguably a little too large.

  • So instead, I'm going to render it like that.

  • Now if we're using this just for a score,

  • which essentially is probably going to be the only use for it,

  • I can simulate this by saying, maybe 000.

  • And if I re-run this, that looks a little bit tiny.

  • So for the score, I might actually decide

  • that I want this to be at 20 pixels, re-run it, and that looks OK.

  • Now what I didn't realize is going into this

  • was that the font is actually vertically margined.

  • So there's some extra padding at the top of that font glyph.

  • So it's rendering at 00, the top left.

  • But it looks like it's getting pushed down a little bit.

  • So I kind of don't like that.

  • I might want to choose a different font for that purpose, for that reason,

  • to circumvent that.

  • This pixeled font has a pretty cool little number glyph set.

  • So I might actually do that.

  • So I'm going to download pixeled.

  • We'll do the same thing that I did before.

  • Open that up, copy that over to my stream.

  • So dev, streams, Minesweeper, fonts, pixeled.

  • And then I can go into here, create a new font object called pixeled.

  • Love.graphics.newfont, fontspixeled.ttf at size and what's the font size?

  • It was also 10 pixels.

  • So in this case I can say 10.

  • Might need to make this one 20 as well because it'll

  • be the same size as the poco font.

  • Render that.

  • We need to actually set that to be our default font.

  • So I'm going to say pixeled here instead of poco.

  • And again, that has margin.

  • So you know what it is?

  • No, there's no margin.

  • I screwed up the virtual resolution.

  • So what I need to do, I'm going to say list of 16:9 resolutions.

  • So earlier I decided on 384 by 216, I believe it was.

  • Right up here.

  • But apparently that's not a 1920 by 1080 perfect resolution.

  • So going to zoom that back out just a little bit.

  • So if you render at a non-16 by 9 resolution,

  • you're going to get some either vertical or horizontal padding,

  • the black padding depending on.

  • And we can't tell that it's black padding because we are rendering

  • our game with a black background.

  • We could do, for example, love.graphics.clear at 0.4.

  • Oh, OK.

  • In that case it also did it.

  • Am I just going crazy?

  • I may be going crazy.

  • No, I'm not.

  • So 384 by 216 is a 1920.

  • Did I just get unlucky and choose two fonts that were both vertically padded

  • by quite a bit?

  • That might be what it is.

  • That's strange.

  • For you, for personal use, pixel mix.

  • Can't use that because I don't think I can technically use that on stream.

  • I might be able to.

  • I like this press Start to play one.

  • I use this quite a bit.

  • So I'm going to do this one again.

  • It looks like I already downloaded it.

  • Let me just make sure that I'm not going crazy.

  • And then JHarvard, dev, streams, Minesweeper, fonts.

  • I'm going to call this one start.ttf.

  • Go back in here.

  • Print 000.

  • Let's create yet another font.

  • We'll call it start.

  • And notice that I have this table that I'm

  • storing just an arbitrary number of these fonts, which is kind of cool.

  • So you can have as many different fonts as you want in your game.

  • As long as you just choose the default font is when you draw,

  • that's the only thing that matters.

  • You will use this a lot if you design UIs that have different fonts.

  • You'll need a table that stores.

  • And this is why we use a table, because you

  • want to make a reference to potentially multiple different fonts.

  • I like Rodrigo's thinking face, says twintowerpower.

  • I like that.

  • OK.

  • So let's go ahead and set the default font to start.

  • See if this does the same thing.

  • OK.

  • So we just got unlucky and I chose two fonts

  • that happened to have some vertical margin, I guess, at the top of it.

  • And it led me to hypothesize that I had chosen an incorrect virtual resolution

  • because off the top of my head, I thought of 384 by 216.

  • But I was correct.

  • That's actually a 16:9 resolution.

  • That's important because, again, it needs

  • to map to the aspect ratio of your actual resolution, 1280 by 720.

  • So essentially what that means is, 384 divided by 216

  • should be the same thing as 1280 by 720 in order

  • to avoid the horizontal and vertical margins.

  • If I were to run, for example-- and I might actually

  • have to have terminal up.

  • But if I were to do Python, we can also do

  • Lua, but if I say 1280 divided by 720, and this is

  • Python 2 so this isn't going to work.

  • So Python 3.

  • So if I say 1280 divided by 720, that gives me 1.77777 infinite repeating.

  • This is the same thing as 16:9 aspect ratio.

  • That's that number, that constant number.

  • And then if I do 384 by 216, you'll see that that is the exact same number.

  • So those numbers being the exact same means

  • that the window's, assuming that you have them at the same resolution,

  • it'll fit perfectly.

  • The virtual resolution raster, the 384 by 216 raster that you're drawing to,

  • when stretched out, will completely fill and preserve

  • the balance of pixels, that 1280 by 720p window.

  • However, if I were to go into my virtual resolution, for example,

  • and change this to something like 340 by 216 and I run this,

  • you'll notice that on the left and the right

  • I do have some vertical bars to offset that difference in ratio.

  • And that is why it's important if you don't want those vertical bars in order

  • to keep your rasters at the same constant, 1.777.

  • That should be the result, the quotient between your width

  • and your height of your dimensions.

  • So yeah.

  • Fun stuff.

  • OK.

  • Let me just make sure that I can read the chat and keep up with it.

  • Out of bands, array exceptions, says tuxman.

  • Yeah, that only takes a few times before that

  • starts to get a little bit stressful, a little bit overbearing.

  • Randy says, these are not droids you're looking for.

  • These are not the droids you're looking for.

  • Star Wars reference.

  • 1223 in Nepal says, [INAUDIBLE],, I love all CS50 live streams.

  • Awesome.

  • Thank you so much for tuning in.

  • Bhavik Knight says score in time.

  • 11Lewie, you can name the table indices.

  • Yeah.

  • Yeah, you can do that in a lot of languages.

  • It's the same thing in Python, for example.

  • If using a dictionary, that'd be the same thing

  • as using a string as your key and then whatever value you want.

  • RODRIGO SANCHEZ: You can even use numbers or whatever you want.

  • COLTON OGDEN: Yep.

  • Exactly.

  • Yeah, you can use-- and there's some languages that let you,

  • if you have hashable objects, you can have

  • objects act as your keys, which is very cool and kind of crazy.

  • I don't think Lua is one of those.

  • I don't remember offhand if it is.

  • It's kind of an esoteric use case, too.

  • [INAUDIBLE] says, funny bits of programming.

  • So we've come a long way.

  • We have we have some text in the background.

  • I'm going to darken this color, just a little tiny bit in the background.

  • But we're not going to use just pure black.

  • We're going to keep it kind of a different color, kind of this dark

  • gray.

  • This'll be our background.

  • What I want to do is, I want to start sketching out the game, the grid,

  • the 2D grid that will act as our Minesweeper grid, I guess.

  • The things that we can actually click and then reveal them on the screen.

  • So let's do a faux score and timer at the top, which

  • is what we've done in the past.

  • So I'm going to print.

  • So at the top left I'm just going to say,

  • we'll assume it starts at 120 seconds.

  • So it'll count down from 120 going down to zero.

  • And I'm also going to love.graphics.printf.

  • And printf is what allows us to format the printing so we can center things

  • or align them.

  • In this case, we're going to right align them.

  • I going to say love.graphics.printf0000.

  • Eh, just zero for now.

  • And then we want to right align this.

  • And so printf if you're using it in your aligning something within some bounds.

  • It'll start at zero.

  • It's going to also start at zero height.

  • It's going to take up the virtual width as its center, its alignment zone,

  • you can sort of think of it.

  • And then I'm going to not center align it but right align it.

  • And then if I run this, you'll see.

  • And it's somewhat difficult to see on the stream there.

  • But I do have a zero on the right side of the screen at the top right.

  • And that's going to be where we have our score, the user's score as they play.

  • Cool.

  • So that's working.

  • Well, we'll wire those together at some point in the near future.

  • Now, what I want to do, let's go back to Minesweeper.

  • The actual graphic and let me zoom in just a little bit here.

  • I want to have a few things happen.

  • So there are a few things we can look at that are fairly simple, especially

  • if you've watched prior streams.

  • One thing is we're going to need tiles.

  • We're going to need two separate tiles it looks like,

  • at least two separate tiles.

  • So we have one tile and this is a pretty poor resolution to be looking at.

  • But we have a tile that is unrevealed.

  • So it's this tile here.

  • So in this case, you can see that it's a little bit three dimensional-looking.

  • And the way they accomplish this was they

  • chose a center color of some sort of pale gray.

  • They used a lighter color for the left edge and a darker color

  • for the right edge.

  • A very simple way to get a three dimensional look for your game.

  • Now what size would this be?

  • This would probably be maybe 10, 12 pixels.

  • If you use an eight-pixel font we could probably achieve this.

  • Let's try 12 pixels.

  • So what I'm going to do is, I use a program called Aseprite, which I like.

  • And Aseprite is a drawing application.

  • So kind of similar to Photoshop, kind of similar to something like GIMP.

  • It's used mainly just for drawing 2D sprite work for games like this.

  • To answer pudavodatel, are you sitting or standing?

  • We are thankfully sitting.

  • I wouldn't want to stand for three hours.

  • Tuxman, can you use emojis?

  • RODRIGO SANCHEZ: We were talking about table indices.

  • COLTON OGDEN: Oh, sure.

  • Probably not.

  • Probably not in Lua.

  • Maybe in Swift, because I think you can do that in Xcode,

  • you can use emojis in the actual programming language.

  • Not in this programming language.

  • Greetings from Germany.

  • Love your video, says sensotouch3d.

  • Thank you very much.

  • Appreciate it, senso.

  • [INAUDIBLE] says, think this channel is cool.

  • Definitely need to fill in some info below the stream with links, schedule.

  • I agree.

  • I'll take a look at doing that as soon as possible.

  • We have to kind of formulate a lot of that stuff.

  • But yeah, you're absolutely right.

  • We want some behind the scenes video.

  • Show us what it takes to stream.

  • I would watch it.

  • It would be cool, says [INAUDIBLE].

  • Yeah.

  • We could potentially do something like that.

  • I'll ask David and our production team if there'd

  • be something they'd want to do and we could maybe do something like that.

  • Have like a stream of the stream going on in the background.

  • Little bit of stream-ception.

  • Back to the thing here, I'm going to create a new sprite.

  • And it's going to be 12 by 12 pixels.

  • So let's do that.

  • So this is going to be very ultra tiny.

  • Can I zoom in like that?

  • I can.

  • Ultra tiny.

  • Even though this looks large right here, it's actually

  • going to be a very small drawing.

  • I'm going to choose this pale gray.

  • Like we said earlier, we need a pale gray, a light gray, and a dark gray.

  • So I'm just going to fill this in and I can actually do this with the fill tool

  • here.

  • I'm going to go to my pencil.

  • I'm going to choose a lighter color.

  • So I could choose white, but that's a little obnoxious.

  • I'm just going to go up to here and choose that.

  • And then again, it was kind of like this on the left going down.

  • And then a darker gray, so something like this on the right.

  • And you can kind of see that, actually, in the preview here.

  • It may be a little bit difficult to see, but when it's shown at smaller scale,

  • it really does look quite three dimensional.

  • Now, I'm going to save this as a PNG.

  • Not a PCC, a PNG.

  • I'm going to go.

  • And it's already set to stream.

  • In our tic-tac-toe stream, we made our Xs and circles from scratch.

  • I'm going to go up to streams, into Minesweeper.

  • And I'm going to create--

  • it looks like I don't have the appropriate folder here.

  • I'm going to save it in here and then I'll move it in the Finder.

  • I'm going to say, this will be tile.png.

  • It'll just save it as a PNG.

  • So if I go back to my Finder, notice that we do indeed now have a tile.png.

  • And now, what you see here illustrates what filtering is.

  • So we saw very clearly in our actual Aseprite program

  • when we were doing the sprite artwork, that it was crisp, you know?

  • We saw the individual pixels of our 12 by 12 image.

  • But Mac OS and Windows OS, I believe, by default

  • apply filtering to all image previews just so they look kind of nice

  • as you're looking through all your stuff.

  • But when you're looking at something very small like this, like a 12

  • by 12 pixel, it looks blurry.

  • It looks like it's actually at a higher resolution than it is.

  • And this is what filtering looks like versus nearest neighbor

  • or point filtering or no filtering.

  • So this is a perfect illustration of what that is.

  • Now what I said before is I'm going to move this.

  • And what we generally want to do is have a separate folder for your graphics.

  • So I'm going to go ahead and I'm going to take tile.png,

  • put that in my graphics folder.

  • I now have a tile that I can draw on the screen.

  • To illustrate that this looks OK when drawn in a grid,

  • I'm going to, in my main.lua, do a simple loop.

  • I'm going to say 4y gets one until 10.

  • Do, just put a space there before the end of that.

  • Actually going to put a space between push start and the rest of the code

  • just for style.

  • This is a nice thing I like to do stylistically, just

  • to illustrate semantic difference between the different things you're

  • doing in a large chunk of code.

  • So splitting out the fact that we're starting

  • with the push rendering and then the font rendering,

  • and then separately our loop that's going to draw all of our tiles.

  • And then separate from that, the actual closing

  • of the push block, that's a nice way to space out your code.

  • Makes it easier to read and understand what's going on

  • and to separate things semantically in chunks.

  • So for y, it's 1 to 10.

  • This is a nested loop.

  • I'm going to say 4x is 1 to 10, do.

  • And what I'm going to do is draw this.

  • So I'm going to say love.graphics.draw.

  • And we have nothing to draw yet.

  • So that's another thing that we want to do.

  • I'm going to go into dependencies.lua and I'm going to say G textures.

  • And so typically you'll hear 2D graphics referred

  • to as textures or rasters, in this case, textures.

  • So I'm going to say, G textures is equal to, and we'll call this tile.

  • And we'll say love.graphics.newimage.

  • And this is going to be graphics tile.png.

  • So just loads that tile.png that we created from our Aseprite.

  • And we put it in a folder.

  • Just going to load it from disk in that graphics

  • folder just like it does with the font file, the ttf file, as well.

  • I'm going to say love.graphics.draw, G textures.

  • And I'm going to say tile.

  • I'm going to say--

  • and we have to draw this at a particular xy location.

  • So I'm going to say x - 1, actually no.

  • I'm just going to draw it at x, actually.

  • I'm going to say x times, and then in constants.lua I'm

  • going to say tile size equals 12, right?

  • Try to take magic numbers out of your source code as much as you can.

  • You could say we're using it here, debatably.

  • But this is just to illustrate something.

  • We will get rid of this.

  • But we will not get rid of, for example, the tile size.

  • We're going to use that a lot.

  • I'm going to say tile size, y times tile size.

  • And that should actually just work right off the gate.

  • And if I run this, you indeed can see that we have sort

  • of a Minesweeper-like grid being drawn.

  • And it's offset a little bit because we're drawing this not at 00,

  • we're not starting at 00 because we're actually starting the xy rendering

  • at one.

  • Notice that y and x start at 1, they don't start at 0.

  • So I'm actually drawing relative to the top left.

  • I could say x - 1 times tile size and y - 1 times tile size.

  • And what this will do is, this will actually

  • drive, based on the top left corner.

  • And this is nice and clean and flush with our window.

  • But it obscures the timer that we put earlier in our actual grid.

  • When we get to the game itself, when we lay everything out

  • the way we properly want to, it's not going to be at the very top left.

  • It's going to be kind of shifted down, kind of centered in the game world.

  • So, yeah.

  • Looks kind of nice already, right?

  • RODRIGO SANCHEZ: I like it.

  • COLTON OGDEN: Very simple, too.

  • Just a very simple idea.

  • Something that you see a lot in sprites and in UI.

  • Just make the far left edge of something a light color,

  • it's kind of in the same palette as your central color.

  • And then make the far right a darker version of that same palette.

  • Let me make sure that I caught up.

  • Is CS50 available somewhere?

  • The CS50 website is all about some event and that is it.

  • And then looks like, yeah.

  • Tuxman kindly put in cs50.edx.org.

  • Got to go.

  • Thanks for the great stream, as always.

  • Learned about better folder hierarchy from my future project.

  • Awesome, thanks tuxman.

  • Appreciate you tuning in.

  • Glad that you were able to pull something away from today's stream.

  • Cool.

  • So we have our grid being drawn.

  • We have a little bit of a tutorial on drawing some basic sprite stuff.

  • That's not the only tile that we want, though.

  • Because if we look at the image here, we can see that when we do click a tile

  • and that tile has been depressed, it's actually

  • very similar to our other tile.

  • But it doesn't have a light edge any longer.

  • Now what it has is just a dark left and top edge and then

  • nothing on the right and the bottom.

  • And so it's very simple.

  • We can do the same exact thing that we just did.

  • I'm going to go back to Aseprite.

  • I'm going to copy this.

  • Going to draw this here.

  • So keeping the left edge intact, and then I'm

  • going to take this dark color that we used before.

  • I'm just going to make that the left edge just like that.

  • And then I'm going to save that.

  • Not what I wanted to do.

  • Whoops.

  • I'm going to save that.

  • I'm going to reapply.

  • I'm going to command shift save that to create a new image.

  • And I'm going to call this tile depressed, like that.

  • And actually, it saved it again here.

  • So it didn't actually overwrite the file in our graphics folder.

  • But even still, you want to watch out for accidentally doing something

  • like that.

  • So tile depress, put that in the graphics.

  • I'm going to go ahead to delete that.

  • Now you could put those onto a separate sprite sheet.

  • Sorry, you could put both of those together onto one sprite sheet.

  • But given that they're so small and we're only

  • going to really have two separate tiles, we're

  • going to see that we're actually going to draw

  • everything else on to these tiles.

  • We're going to basically draw the tile and then layer

  • on top of that some text or an icon.

  • There's no real need or reason for us to go

  • through the effort of creating a sprite sheet.

  • And then additionally, splitting that sprite sheet in code.

  • We can avoid doing that in this case.

  • A 3D-looking unimpressed grid would do.

  • Not sure what you mean, because that was kind

  • of the goal of what we just accomplished,

  • Bhavik, if you want to elaborate on what you mean by that.

  • OK, so cool.

  • What I'm going to do now is I'm going to--

  • let's test to make sure this actually works.

  • So I'm going to create a grid.

  • I'm going to create an empty grid.

  • I'm going to say 4y is equal to 1 till 10.

  • Do 4x is equal to 1 do.

  • And then I'm going to say table.insert into grid in another empty table.

  • I'm basically creating a 2D table here.

  • And then I'm going to say, table.insert into grid y, which

  • will now exist by the time this happens, because we

  • will have just inserted a table.

  • I'm going to insert into that either a one or two.

  • So in this case, math.random, two.

  • And another important thing that we should do,

  • actually, is seed our random number generator.

  • So going to say, math.randomseedos.time.

  • If you're not familiar with what this does,

  • this just seeds our random number generator with our OS time

  • to always be different every single time we start the game.

  • So this means our random number generator will function differently

  • every single time we play the game.

  • So we've created a 2D grid here.

  • Every single index.

  • So this is going to be mapping to our actual tile grid.

  • Every single index in our 2D grid is going to be either a one or a two.

  • And so what I can do down here is, I can say grid at yx is equal to one

  • and this or gtextures tile depressed.

  • RODRIGO SANCHEZ: And underscore instead of the hyphen for tile depressed?

  • COLTON OGDEN: No, no.

  • Because what we're going to do is I'm going to go into dependencies.

  • But I haven't done this yet.

  • I'm going to create another index here called tile depressed.

  • And this is not really a formal convention.

  • I would say I've seen it more than I've seen this for indices, at least

  • in the context of Lua.

  • But my experience might differ from your experience.

  • I'm not sure whether there's a formal standard for this.

  • But I typically like to use hyphens to be my indices for tables in strings.

  • And I'm going to say love.graphics.newimagegraphics tile

  • depressed.

  • And underscores are more of a convention for actual files.

  • So there's kind of a dichotomy here, which

  • you could argue could lead to a source of bugs for people assuming

  • that it will be underscores or for developers even

  • assuming it'll be underscores.

  • But there's semantic value, I guess, in knowing that that's

  • the table key versus a file.

  • So maybe that's OK.

  • But in any case, I have this implemented.

  • And now if I render the game and it's all randomized,

  • you can see that we do have a grid of tiles

  • and we do get this nice faux 3D look, right?

  • You get that tile.

  • We sort of tricked our mind into thinking that that's lower

  • or that tile is higher than that tile on the left.

  • So very simple things that add up to make

  • a pretty nice-looking UI for our game.

  • Now, do we have any more comments that we should read?

  • RODRIGO SANCHEZ: Just some chatting.

  • COLTON OGDEN: OK.

  • Cool, cool.

  • So, Bhavik-- or, sorry, Bellocure has kindly pitched my game dev course.

  • Hevron is saying, that looks amazing.

  • Bhavik's saying, cool.

  • I agree.

  • This is super cool.

  • And I want to say, I have never implemented this before.

  • I just happened to know these puzzle pieces

  • that I've picked up from working on this game, working on this game,

  • working on this game.

  • Making observations about the game that I'm trying to implement.

  • And then actually orchestrating that in code.

  • And you can sort of predict how things are going to look and behave

  • the more experience that you get.

  • And so I went into this knowing what the outcome of this would be.

  • But even I, looking at this, I'm like, wow.

  • This actually looks pretty cool.

  • I think this is pretty awesome.

  • One thing we could do, we could actually darken

  • the background just a little bit, just a shade

  • to give it even more of a 3D look.

  • So I think I might do that.

  • I'm just going to sample this color here.

  • And then I'm going to bring this over just a little bit.

  • And then fill that in.

  • Save it.

  • And what that will have done is it actually

  • created a new tile depress there.

  • I'm going to replace that one there, re-run the game,

  • and now we have an even more exaggerated three dimensional look to our grid.

  • So cool.

  • I'm enjoying this so far.

  • This is moving along.

  • Now it's not centered, which is kind of a problem.

  • So what I probably want to do is take care of that.

  • So why don't we go ahead and do that.

  • So in order to center it, what we basically want to do

  • is effectively start drawing it at the x point that

  • is the half point of our virtual width minus the total size of the grid.

  • So we take this whole virtual width, we subtract from it

  • the total width of this, which will give us this space here.

  • Then we divide this space by two, start drawing at that on the x-axis,

  • and that will have the effect of drawing this grid.

  • Is that the case?

  • No, we actually have to divide this by two as well and shift that to the left.

  • I might be getting myself confused here.

  • No, that should be right.

  • Yeah, that's the margin.

  • Yeah, that's the margin.

  • That should be correct.

  • I could be mentally having a little bit of brain fog at the moment.

  • But we're going to try that.

  • So I'm going to say, local.

  • We can actually pre-calculate this.

  • So I'm going to say local padding is equal to virtual width

  • minus the total grid size, which would be--

  • so another thing we should do, and actually this is important,

  • grid size or rather, grid width.

  • And this will be 10 and then grid height will also be 10.

  • And we can change this.

  • The way that we're actually creating this right now,

  • we can have this be programmatically centering.

  • Because we're going to take this into consideration when we actually

  • figure out the margin of our game or the padding of our game grid.

  • So I can say, virtual width minus grid width times tile size, right?

  • So that'll be the number of tiles and the width of the tiles.

  • Sorry, the size of the tile which is 14 pixels and then multiply that

  • by the number of tiles in the grid.

  • So that'll be the number of pixels wide that our grid is in total.

  • So I'm going to say--

  • and this will actually still--

  • because of the order of operations work the same way as the parentheses,

  • but it lets us kind of keep track of what

  • we're doing a little bit easier here.

  • So I'm going to say virtual width minus the grid width times tile size.

  • And then I'm going to divide that by two.

  • And this will actually be more appropriately named as left padding

  • or left offset, I should say.

  • So this will be, again, our padding between the grid

  • and the virtual width's difference of that.

  • And then divide that by two.

  • And then if I say left offset plus where we want to draw the x and then I render

  • this--

  • oops, I screwed that up.

  • OK, so that's not working.

  • Virtual width minus the grid size.

  • Is it this?

  • No, that's the same thing.

  • OK, so we have the--

  • let me just make sure I'm thinking about this correctly.

  • We have the virtual width.

  • We need to take the difference between the full grid, which will be something

  • like, what, 140 pixels?

  • Wait.

  • We have virtual width minus that.

  • RODRIGO SANCHEZ: Each tile is what?

  • How long?

  • COLTON OGDEN: Wait, does it actually need to be virtual width minus that

  • and then we're minus that?

  • That's what it is, OK, I think.

  • I might be incorrect.

  • It looks roughly correct.

  • Basically, I was taking the--

  • if we were to get rid of that--

  • wait, am I not dividing it by two anymore?

  • RODRIGO SANCHEZ: No.

  • COLTON OGDEN: So the virtual width, these always

  • gets slightly-- depending on what problem you're trying to solve

  • can get a little bit hairy.

  • So we're taking the grid or rather our virtual width

  • minus the grid, which will be that amount, right?

  • So virtual width minus--

  • let's figure this out.

  • That divided by two, right?

  • So will that work?

  • There we go.

  • OK, got it figured out.

  • So the virtual width minus the grid's width in total.

  • And then we divide that whole thing by two.

  • So I was dividing it by two before actually

  • subtracting it, which was causing it to behave inappropriately.

  • That is completely centered.

  • You can tell based on the untitled right here.

  • And then I can draw this, shift it down on the y as well.

  • I'm just going to make this arbitrary.

  • So top offset, I'm going to say that's, let's say 40, 40 pixels.

  • And then I can say, top offset plus that.

  • Cool.

  • So now it's completely centered, everything looks pretty good.

  • Now what I want to do is to be able to choose a tile with the mouse, which

  • is what Bhavik Knight said before.

  • And let me just make sure I'm keeping up with the chat here.

  • Rodrigo nods approvingly.

  • Windows fine for programming?

  • I see many developers use Unix-based systems

  • and it confuses me a little bit.

  • Yeah, Windows is fine for programming.

  • Unix tends to make it a lot easier to program in certain contexts.

  • But I mean, game programming is often done on Windows machines.

  • You can program a lot on just Windows machines

  • without too much of a headache.

  • But I would say, I think it's a little bit easier to get into programming

  • and to be productive and to get bootstrapped in a Linux or Unix

  • environment just because there's a lot of tools to easily get set up,

  • a lot of package managers that make it easy.

  • Mac, for example, with Homebrew you can get set up really fast

  • and it's not really that easy to do on a Windows machine in the same way.

  • RODRIGO SANCHEZ: It's a lot of-- if you're Googling around

  • for help, a lot of the examples that you'll find assume that you're

  • running a Google space system.

  • COLTON OGDEN: Yeah.

  • Agreed, agreed.

  • And it looks like Bhavik Knight-- yeah, Bhavik Knight had the right idea there.

  • Yeah, [INAUDIBLE] had the idea.

  • I was dividing by two at the wrong time, which was causing a problem.

  • Foursunlight says, hello [INAUDIBLE],, Rodrigo, the regulars, and newcomers.

  • Thanks for joining us.

  • JPguy, good to see you.

  • Cool, cool.

  • All right.

  • Let's go ahead and maybe break out some of this into different files.

  • So for example, there is an idea of a grid, right?

  • A game grid.

  • Let's rename this actually to Game Grid because I think grid is just

  • a little bit too generic of a class.

  • I'm going to go ahead and this is going to be a class.

  • So what I want to do is, I'm going to take the class library

  • that we used last time or rather--

  • wait, did we use it last time?

  • Yeah, I think we did.

  • Yeah.

  • No, we didn't use it there.

  • Where did we use it?

  • I forgot offhand.

  • Did we use it in Space Invaders?

  • We did.

  • So it's an unfortunate name, Love 2D class library helper utilities.

  • I'll say use the helper utilities for massive progression.

  • And yeah, it's an unfortunate name and unfortunate acronym.

  • But it's a class library that they use and that is what we'll be using.

  • So here it is.

  • VRLD/ helper utilities for massive progression.

  • Within the Love 2D community, they have some unfortunate

  • naming conventions as kind of a set of jokes and conventions.

  • But that is the library, the specific class library that you want.

  • I have it pre-downloaded because we used it in Space Invaders.

  • I'm going to copy it over to my--

  • where is it?

  • Minesweeper into my lib folder.

  • And so now I have a class.lua in there, so that's

  • going to be my ability to use object-oriented programming classes.

  • If you don't know too much about that, I think

  • the goal is to eventually start doing a object-oriented programming stream.

  • I'm going to find somebody to do it.

  • Maybe me, maybe somebody else.

  • But suffice to say, this will allow us to put together

  • all of the functions and data that make up a game grid

  • and put them into one module.

  • And that's what we're going to do.

  • So in Game Grid I'm going to say-- well first of all,

  • what I need to do in dependencies is say, require rather,

  • class equals require 'lib/Class.'

  • And it's their convention to capitalize class.

  • And it's nice because it kind of almost feels like new syntax in Lua,

  • and the fact that Lua is such an extensible,

  • simple language allows you to do stuff like that.

  • We'll say game grid class.

  • This block comments is not terribly useful,

  • but this might be where you include a description of how

  • the class should behave.

  • I'm going to say game grid equals class.

  • And notice that I made it a global variable by not specifying local.

  • So again, in Lua, you can say that something

  • is local, which means that it won't be accessible

  • anywhere outside of its scope.

  • In this case because we defined it at the top level of the scope

  • in this module, it can be used in any function within main.lua.

  • But if you tried to use it, for example, within Game Grid,

  • even though the two can talk to each other, it's not going to be accessible.

  • Veronny, thank you very much for following and theyashbhutoria,

  • thank you very much for the follow.

  • So I'm going to say function game grid init.

  • So the init is sort of the constructor function,

  • the function that will create this object

  • and set it up for whatever it needs to do.

  • In this case, it will need a self.width.

  • Let's assume that it takes a width and height.

  • It'll take a self.width equals width and a self.height equals height.

  • Self refers to if we have a specific instance of game grid,

  • in particular game grid object, that particular game grid's width should

  • be set to however we pass it with in a constructor for it, height

  • and the constructor for it.

  • And again, we can probably do an object-oriented programming tutorial

  • in the future.

  • So if this kind of goes over your head a little bit, I apologize.

  • But kind of just take it.

  • Think of it as this game grid, the game grid class defining what a game grid is

  • and what functions that game grid can use.

  • And then if we were to go in main.lua, I can specifically

  • create an instance of game grid.

  • I can say, for example, local game grid equals game grid width and grid height.

  • And this right here, this is just one instance of game grid.

  • But we could create as many as we wanted to just like this, right?

  • And they all take the same constructor, the same game grid constructor.

  • This is the same thing as the init function right here.

  • Notice that it takes a width and a height.

  • These take a width and height and it creates a unique game grid

  • for each one of those lines of code.

  • So yeah, that is basic object-oriented programming, I guess.

  • It gets a lot more complicated than that that's

  • in a nutshell it's essentially just what objects and classes are.

  • This is a class, this is an object, and a class

  • is kind of like a blueprint and an object

  • is a specific implementation of that class.

  • So in any case, we're going to be able to define all of the behavior,

  • including the drawing and updating of our class within the game grid

  • class itself.

  • I could say a game grid update.

  • And game grid render.

  • And what this will allow us to do is put all of the code

  • that we essentially put in main.lua to do all of the drawing

  • and updating for our grid, or rather, just the drawing.

  • I can take this and I can instead say something like game grid render

  • right here.

  • Defer the rendering to the class itself right in here.

  • So I can say now, for one until and we don't want to use 10.

  • We want to use self.height and self.width.

  • And all the rest should be pretty good.

  • Now, top offset no longer exists in this current scope.

  • And that is left offset.

  • So what we probably want to do is make those constants.

  • Well, actually, no.

  • Top offsets is not going to be a constant.

  • But what we can do is we can say self.leftoffset.

  • We keep it as a variable within the game grid itself.

  • You can also argue for-- oh no, because it maintains its own rendering logic.

  • So we want to actually keep the offset within this class, probably.

  • So I can say take this bit of code here, delete it, bring it over here,

  • copy that there.

  • We do still have virtual width, grid width,

  • and tile size references within this module

  • because these are global constants.

  • We put them into the constants file.

  • They can be accessed within any module.

  • So our game grid can make references to those variables of all those constants.

  • And then now this works fine.

  • The left offset is no longer a global variable.

  • It's a member variable.

  • This has a specific reference to its left offset.

  • It's calculated it at the beginning of its instantiation.

  • It calculates it as soon as the constructor is called.

  • After it gets the width and then it gets the height,

  • it figures out what its left offset should be.

  • And actually, this should not be width grid width.

  • This should be self.width.

  • But virtual width and tile size are always going to be the same.

  • It's just the actual width is going to be different.

  • And then after that, we're going to make top offset a constant.

  • So I'm going to say, top offset.

  • Put this in here.

  • Top offset is equal to 40.

  • I'm going to get rid of that in main.lua.

  • And then this is fine.

  • This is fine.

  • We're rendering the game grid in here.

  • So if I were to run this, we have an issue because again, it's a new module.

  • We're not actually requiring it anywhere.

  • We have to do that first before we have access to it.

  • I'm going to say require source/gamegrid just like that.

  • And now it indeed works.

  • All of the rendering logic and everything is included within the grid

  • itself, within the class itself.

  • This object has a reference to its own functions, its own data.

  • We don't need to keep this in main anymore.

  • That should be one of your goals when you're implementing a game,

  • keep everything outside of your main.lua.

  • Try to defer as much logic as you can into different modules.

  • Keep those modules as small as you can.

  • What this gives you the ability to do is separate your concerns a little bit.

  • It allows you to think in smaller chunks at a time.

  • You don't have to mentally parse a ton of information.

  • And if Rodrigo and I are working on a game together, I can say,

  • Rodrigo, I want you to make this game grid class

  • and this is how it should behave.

  • It should have a render and update function.

  • I'm going to focus on just the architecture of the game.

  • I'm just going to focus on main.lua right now

  • but I want you to do the grid by yourself.

  • And now he has the ability to do that because the grid is all

  • taken out of our main.lua.

  • So that's probably the most valuable aspect of it,

  • especially if you're working on a team of people.

  • But even if you're working by yourself, the mental assistance

  • that you give yourself by separating things out and making it more modular

  • is helpful in and of itself, and can boost your productivity.

  • Let me make sure that I didn't miss any comments here.

  • Never played Minesweeper, actually.

  • How does it work again?

  • Sure.

  • So we'll end up implementing this ourself.

  • But essentially you have a grid of these tiles that start off completely empty.

  • And when you click on a tile, what it does

  • is it recursively checks all of its neighbor tiles

  • and sees if those are a number.

  • If they're are number, then it stops recursively iterating through the board

  • and opening tiles.

  • If it's just an empty tile like this, it checks all of its adjacent neighbors

  • and does a recursive, are those a number or are they empty?

  • And opens all of those up and those all open up their neighbors

  • until, again, they reach a terminal point.

  • It's the base case for your recursive algorithm, right?

  • The base case is that it's a number.

  • And that's pretty much it.

  • And then if you click on a bomb, which is what these numbers refer

  • to is, how many bombs are near me?

  • So it takes into consideration all your tiles, whether they're diagonal or not.

  • So you can you can surmise that because this tile, for example,

  • right here is a one, that means that there's one bomb neighboring that tile.

  • The only tile unrevealed is this diagonal tile right here.

  • So we can say with 100% certainty this tile is a bomb.

  • We know that's a bomb.

  • There's no way that cannot be a bomb, right?

  • And same thing for this two here.

  • This two, because there are two tiles neighboring

  • it that are unrevealed, only two tiles that are unrevealed

  • and because this number is a two, meaning

  • that there are two bombs neighboring this tile,

  • we can say with 100% certainty that both of these tiles are bombs.

  • This three, same idea.

  • This three, it only has three neighboring unrevealed tiles.

  • Three bombs, therefore, all of those are bombs, right?

  • And so that's the gist of the game.

  • That's the game loop.

  • Your goal is to--

  • using, is it induction?

  • Deduction?

  • The Difference

  • RODRIGO SANCHEZ: Deduction?

  • COLTON OGDEN: Deduction.

  • I always get these two confused.

  • You're supposed to surmise whether tiles that you haven't clicked on are bombs

  • or not.

  • And you're essentially trying to find bombs, you're sweeping for bombs.

  • It's just a number game.

  • It's similar to Pick Cross, which is another number game.

  • Using number hints you figure out which tiles you can pencil in or not.

  • RODRIGO SANCHEZ: I like twintowerpower's rule about playing the game.

  • COLTON OGDEN: You press the grid and hope the bomb goes off, I think.

  • That's a good heuristic for playing, yeah.

  • Lot of greetings going around.

  • Others are saying hello.

  • JPguy was saying hello to everybody.

  • Yawn.

  • Cool.

  • Unpress all the mines without triggering the bomb.

  • [INAUDIBLE] thinks the naming funny for the library we referred to earlier.

  • Cool.

  • Give it a little hug.

  • Go online.

  • Yeah, that's true.

  • You can probably find a version to play online really easily.

  • How about on next stream we try to build a game called Dangerous Dave?

  • Fun little game to play.

  • Lots of childhood memories.

  • Dangerous Dave.

  • Hopefully my safe search doesn't give me any issues.

  • OK, interesting.

  • Dangerous Dave.

  • So it's kind of like a simple platformer.

  • And you collect gems and you find the door?

  • Is that the gist of it?

  • RODRIGO SANCHEZ: Looks do-able.

  • COLTON OGDEN: To me that looks like the gist of it, yeah.

  • It's similar to what we do with Mario, the Mario piece set.

  • Little fire obstacles, we could do like a simple platformer at some point.

  • In the spirit of Dangerous Dave or Mario or something like that.

  • Yeah, we could do something like that.

  • I don't know if it'll be the next stream but I'll definitely

  • keep it on the docket, for sure.

  • Thank you for the suggestion.

  • You don't have to deal with one huge file of codes, says [INAUDIBLE]..

  • Yeah.

  • And that's a big headache.

  • You don't want to do that.

  • It's a pain just trying to look through and seeing where problems are

  • and tracing them back and forth.

  • Much easier to look module by module and then

  • get an easier understanding of what you're dealing with as a whole,

  • holistically.

  • RODRIGO SANCHEZ: At least for [INAUDIBLE]..

  • COLTON OGDEN: Yeah, yeah.

  • Encapsulation, collaboration.

  • Yep.

  • Exactly.

  • Grids corner is three neighbors, edge is five neighbors.

  • There is eight neighbors.

  • Bummer, man.

  • Yeah, essentially that's-- yeah, for a corner you would only have-- well,

  • for a corner you would have three neighbors in the corner, yeah.

  • Five neighbors and an edge and eight neighbors anywhere else.

  • Yeah, that's correct.

  • Cool.

  • All right.

  • So again, just because I love seeing this.

  • This is our grid.

  • What we should do is, first thing that we should do is plant bombs, right?

  • So what we can do is, each grid, therefore, each index in the grid

  • needs to have a reference to whether it's a bomb or not.

  • It needs to know that.

  • It needs to know that piece of information.

  • Because if we're going to need to check each tile individually,

  • hey, are you a bomb?

  • If not, then also if we've discovered you, we need another attribute.

  • Have I clicked on you?

  • Are you visible, right?

  • So if you're a bomb, you may be a bomb and invisible.

  • If you're invisible, maybe you're not a bomb.

  • So maybe you have a number of bomb neighbors

  • that it's all going to be hidden initially.

  • But each tile does know how many bomb neighbors it has.

  • So it needs a reference to that as well.

  • And that number is going to be hidden until we click on it and unreveal it.

  • So we have a few variables, flags that we want to keep a reference to.

  • Now the game grid itself isn't going to maintain a reference to this.

  • This is going to be each individual index in the grid, right?

  • That's going to be an actual tile, right?

  • And so what we can do is we're going to need to create another class.

  • We're going to need to create a game tile or a grid tile class, right?

  • Let me go ahead and do this.

  • Grid tile class.

  • This is again, useless comment block but it's a good habit

  • to get into when you want to actually fill this out with a description

  • or with some information about how to use the class.

  • I'm going to say, grid tile is equal to class

  • just like we did with the game grid.

  • I'm going to say function grid tile init.

  • Function grid tile update.

  • I'm not sure if we're going to need update.

  • We will probably want render.

  • So the grid tile will defer all of the rendering.

  • This is another nested deferring of functionality.

  • We're taking from main, we're deferring the rendering of the grid

  • to the game grid class.

  • But within the game grid class, we're then

  • deferring the rendering of each tile to the grid tile class.

  • So things kind of trickle down and they defer.

  • And then you eventually do get these spider webs of functionality.

  • But this, again, it's easier to go down and see things at a more granular level

  • and separate your concerns or your worries

  • rather than have to grok through a tremendous body of code.

  • You can sort of isolate the problem a little bit more easily.

  • RODRIGO SANCHEZ: It's like a company.

  • COLTON OGDEN: Yeah, it is.

  • It is.

  • Essentially, yeah.

  • It's like having a president that defers to vice president or maybe a CEO

  • or board of directors that defer to a CEO, CTO, COO.

  • Those have teams.

  • The CTO might have a technical team.

  • The CEO might have a marketing team or a financial team.

  • Those might have interns, they might have full-time staff.

  • Those might be managers, which have interns, which have full-time staff.

  • You do get this hierarchy a lot in the real world.

  • And it maps well to games for the most part.

  • Now there are people that say that object-oriented programming is horrible

  • and we should use functional programming.

  • We should use other paradigms.

  • We should use logical programming.

  • But however you can think of the problem and solve it

  • more easily, that's essentially a step in the right direction.

  • Whatever gets your software done better and faster, better also

  • being bug-free, more maintainable.

  • Faster isn't always necessarily the best thing.

  • Maintainability is also very important.

  • Whatever gets that done ultimately is good in my opinion.

  • So what we want to do is render the actual tile.

  • And now the tile is going to maintain a reference to its xy.

  • So what we can do is I can say, it's going to need a reference to it's xy

  • because it's going to need a reference to--

  • is it necessarily true?

  • It might not need to reference it's xy, actually.

  • We might be able to get away without doing that.

  • It will minimally need whether it's a bomb.

  • So what we can do is, we could just set it in here.

  • So bomb.

  • So if the bomb is equal to, rather, better naming is bomb.

  • Self.isbomb.

  • So we've made it a Boolean variable, is, we've semantically changed its purpose.

  • So self.bomb could be anything, but self.isbomb,

  • now we know that that should be a Boolean expression.

  • And we'll just set that to the value of whatever is bomb is.

  • So in the constructor for the grid tiles,

  • we're going to actually determine whether something's a bomb or not.

  • I'm going to say self.hidden or rather, is hidden is equal to true.

  • So every tile, when it first gets created,

  • is going to be hidden by default so that players of the game

  • have to click that tile before it gets visible.

  • And then we're going to say self.bombneighbors, something

  • that you should not do in real life.

  • Self.bombneighbors is going to be equal to, let's say zero for now.

  • RODRIGO SANCHEZ: And a convention that I was introduced to was,

  • just like you did, bomb or isHidden for Booleans for counter variables,

  • kind of like num bomb neighbors or something like that.

  • COLTON OGDEN: Yeah.

  • We could do that, too.

  • Num bomb neighbors.

  • So it's a good semantic clarification of the variable.

  • So self.numberofbombneighbors is equal to zero.

  • And now what that's done is that's taken this away from ambiguously

  • being a verb to being a noun.

  • So now we know this is actually a noun 100%.

  • So number of bomb neighbors because we set that to zero.

  • And so what we can do now--

  • RODRIGO SANCHEZ: Bomb neighbors could be a function.

  • COLTON OGDEN: Yeah, exactly.

  • It could.

  • It could.

  • Something that maybe recursively detonates all of your neighbor tiles.

  • Wouldn't work in this game, but you could think of something like that.

  • So grid tile render, this essentially will outline the code, more or less.

  • But what is it going to do is it's going to basically say, if self.isHidden,

  • then we just want to draw the unrevealed tile, right?

  • So I can say love.graphics.drawgtextures and what this

  • should do is be given an x and a y.

  • Because we're going to call this from main.

  • We're going to call this from the grid.

  • We're going to offset this value in a nested for loop within the grid class

  • and pass in this value as an offset to this

  • so that this knows where to draw at the correct location.

  • So I'm going to say g textures tile and this is going to be just a plain tile.

  • And then I'm going to draw this at xy.

  • And then else, if it's not hidden, I want

  • to say if self.isbomb then love.graphics.drawgt

  • exturestitledepressedxy.

  • And then on top of that, I'm going to say love.graphics.drawgtexturesbombxy.

  • So we're doing two draw calls here.

  • We're saying, first draw the tile depressed.

  • And then on top of that, draw the bomb.

  • And so what we need to do is we need to actually draw the bomb sprite, right?

  • So let's go ahead and do that.

  • I'm going to say what we should probably do is draw all the numbers, too.

  • So in here what I can do--

  • what we could have done this whole time, actually,

  • is just draw the bomb onto this and save it separately.

  • So I might actually end up doing that.

  • And we can make it one draw call that way.

  • I'm going to just--

  • let's just draw a bomb here.

  • So I'm going to say boom, boom.

  • Boom, boom, boom, boom.

  • So I'm a terrible sprite artist but hopefully this works OK.

  • We want that.

  • So it's probably something like that.

  • And normally I would do that and then I would probably

  • make this a lighter color.

  • That's too light.

  • And then I would say probably something like that.

  • And then maybe like a bright color, like a red or an orange.

  • Yeah, something like that.

  • So it kind of works.

  • You can see, you get the gist of it.

  • Maybe even for a little bit of decor here

  • we can put a little shiny thing like that.

  • So you can tell kind of what it is.

  • But that's going to be our little bomb image.

  • It looks almost like a pouch more than a bomb.

  • But you get the idea.

  • Would it make more sense--

  • RODRIGO SANCHEZ: There's a little shout-out in the chat.

  • COLTON OGDEN: Would it make more sense if I did something like this, actually?

  • If I did like that?

  • Does that look more like a bomb?

  • RODRIGO SANCHEZ: That looks way better.

  • COLTON OGDEN: OK.

  • Cool.

  • So that's an actual bomb.

  • I'm going to save that in graphics.

  • I'm going to save that as bomb.

  • And I'll read the chat here in just a second.

  • Bomb.png.

  • I'm going to erase all of this stuff here.

  • Sort of overwrite it.

  • And I think it might be easy just to ultimately draw

  • all the numbers as separate sprites.

  • OK, cool.

  • Go ahead and figure out where I left off.

  • OK.

  • So [INAUDIBLE] is saying, the React Redux course you did last year

  • helped me a lot.

  • Now I'm working as a React name developer full-time.

  • Thank you a lot.

  • Oh, that's awesome.

  • So that was Jordan's course.

  • So Jordan Hayashi did a React native course on edX.

  • Super cool course.

  • Talked about React with the React basics, JavaScript,

  • advanced JavaScript, and then React Native.

  • So it's super cool that you got a job, [INAUDIBLE]..

  • And then also that you were able to conduct a workshop, that's incredible.

  • So awesome.

  • Congratulations.

  • Good job.

  • Keep working hard.

  • I think it's mobile.edx.org.

  • I believe that should be the course that you want to link to.

  • Oh, wait.

  • Is that right?

  • Mobile.edx.org?

  • Sorry, cs50.edx.org/mobile?

  • Yeah.

  • Sorry, my apologies.

  • Oh, yeah.

  • And Martin kindly tossed in the chat there.

  • Yeah.

  • I screwed up.

  • Ignore my link.

  • Mobile.edx.org is not anything.

  • That's a fictitious link.

  • It's fake news.

  • I'm going to now segue from drawing the bomb.

  • What I want to do is I want to draw all of the letters that

  • make up the tiles that have been revealed already.

  • So let's go over to here.

  • I'm just going to go ahead and choose a random color.

  • So and this may be terrible.

  • So let's go ahead and do something like that.

  • RODRIGO SANCHEZ: That's pretty good.

  • COLTON OGDEN: Something like that.

  • Thank you for your encouragement.

  • Much appreciated.

  • RODRIGO SANCHEZ: It's better than the bomb.

  • COLTON OGDEN: Yeah.

  • I think that's OK, right?

  • It might be slightly off-center.

  • No, even if we shift it to the right, then it'll

  • be off center on the right side.

  • So it's fine.

  • But that's OK, because this is also dark.

  • OK.

  • If I do this, then move that one over like that.

  • RODRIGO SANCHEZ: I think even though it looks strange in the zoomed in version

  • in the smaller version, when you shifted it to the right it looked centered.

  • COLTON OGDEN: When I shift it to the right in the smaller version?

  • RODRIGO SANCHEZ: Yeah.

  • I was looking at the preview.

  • COLTON OGDEN: Like that?

  • RODRIGO SANCHEZ: But it's kind of hard to tell.

  • I don't know.

  • I think either way it looks kind of off.

  • COLTON OGDEN: I think this looks OK.

  • For the sake of speed we'll go through this.

  • And I'll just call this 1.png.

  • And then deselect.

  • And I want to make these all different colors.

  • So let's go ahead and just erase this.

  • So two was red, I believe.

  • No, two is green.

  • Two is green.

  • So I'm going to go ahead and choose green here.

  • What does the two look like?

  • OK, something like that.

  • So I'll say like--

  • this is going to be terrible.

  • RODRIGO SANCHEZ: Got to start somewhere.

  • COLTON OGDEN: Yeah.

  • So let's see, how does that compare?

  • So it looks like it goes around like that.

  • Goes like that.

  • Great.

  • RODRIGO SANCHEZ: I mean, it's definitely legible.

  • COLTON OGDEN: Yeah.

  • It's legible.

  • I mean, it looks a little bit like trash.

  • RODRIGO SANCHEZ: It looks like a circle, like a cobra.

  • COLTON OGDEN: It does a little bit, yeah.

  • There.

  • That's a little bit better.

  • RODRIGO SANCHEZ: Yeah.

  • That looks a lot better.

  • COLTON OGDEN: OK.

  • RODRIGO SANCHEZ: This one seems more shifted down.

  • COLTON OGDEN: It does, yeah.

  • I don't want to spend too much time on it.

  • RODRIGO SANCHEZ: That's good, though.

  • COLTON OGDEN: I'll try shifting it up.

  • There we go.

  • RODRIGO SANCHEZ: Looks a lot better.

  • COLTON OGDEN: Cool.

  • And then I need to--

  • I'm not an artist at all by any stretch of the imagination.

  • And I'm sure that that's very clear.

  • But if you are a single developer working by yourself,

  • you will sometimes have to do something like this.

  • And so using simple techniques that don't

  • require you to be super artistic like the three dimensional technique

  • we looked at earlier, that's kind of a good way

  • to make your game look good without going too crazy with the artwork.

  • Emulating things that you see that are fairly simple, that's kind of the best

  • way to go about it I think.

  • Three's red.

  • So we'll do that.

  • OK, so how does that look?

  • I mean, I know what the number three looks like.

  • But for the sake of emulating the sprite artwork.

  • It's acceptable, right?

  • RODRIGO SANCHEZ: Yeah, yeah.

  • COLTON OGDEN: Do I want to shift it up?

  • Does that look better?

  • RODRIGO SANCHEZ: To the right a little bit.

  • COLTON OGDEN: We'll go with that.

  • We'll take that.

  • If I were doing this appropriately--

  • [CLAPPING]

  • --I appreciate it.

  • What I would be doing is ensuring that all of these glyphs are the same size

  • and therefore could be centered uniformly.

  • But I'm not doing that just for the sake of speed, just because we have--

  • oh, crap.

  • I saved the wrong one.

  • Shoot.

  • RODRIGO SANCHEZ: Uh-oh.

  • COLTON OGDEN: So what I'm going to do, yep.

  • RODRIGO SANCHEZ: And you can save the other one.

  • COLTON OGDEN: Save that and then redo that.

  • And then that's it, right?

  • OK.

  • And then save that one as three.

  • RODRIGO SANCHEZ: The magic of undo.

  • COLTON OGDEN: Undo is a beautiful thing.

  • OK.

  • I apologize if this is a little bit slow.

  • RODRIGO SANCHEZ: Actually, people are commenting that they like this.

  • COLTON OGDEN: Oh, OK. cool.

  • What do I-- so I need four.

  • What does four look like?

  • Four is like a purple, it looks like.

  • I can't really tell.

  • Well, we'll go with that.

  • So I'll say this is four.

  • And then four looks kind of like-- so they do like the--

  • RODRIGO SANCHEZ: Are they doing the corner?

  • COLTON OGDEN: It's going to be something like this.

  • RODRIGO SANCHEZ: You're doing the nine four.

  • COLTON OGDEN: Yeah.

  • Yeah, exactly.

  • Looks kind of like trash.

  • I mean, it looks actually pretty similar to theirs.

  • Maybe I will get rid of this.

  • Move over here.

  • Go like that.

  • I'm OK with that.

  • I think that looks OK.

  • It's not great.

  • It's not perfect. it's not beautiful.

  • But it works, right?

  • RODRIGO SANCHEZ: Yeah, I think that looks good.

  • COLTON OGDEN: Does that look OK?

  • That looks good.

  • OK.

  • RODRIGO SANCHEZ: And give some more personality.

  • COLTON OGDEN: Yeah, exactly.

  • Trash sprite work for the win.

  • What does a five look like?

  • Let's see.

  • So five is like a burnt orange or like a dark, dark red.

  • So I'll do that.

  • So go here.

  • And get rid of this.

  • I already used this color.

  • So I can just use regular orange.

  • So it'll be five.

  • So five looks like, OK, it looks basically like an S in this case.

  • So I'll do something like that.

  • That looks actually, that's actually really hard on the eyes.

  • RODRIGO SANCHEZ: The color?

  • COLTON OGDEN: Yeah.

  • It needs to be darker.

  • RODRIGO SANCHEZ: I think theirs was a lot darker.

  • COLTON OGDEN: That's hurting me a little bit.

  • OK, we'll do something like this.

  • That's better.

  • Starting to get light-headed looking at that color.

  • OK.

  • I mean, you could just use that as is.

  • It's not fancy.

  • It doesn't have any fancy glyph work on it.

  • But it works, right?

  • You can tell that's a five.

  • RODRIGO SANCHEZ: Do you think the bottom and top should be thicker?

  • Like two lines, maybe?

  • Nah.

  • COLTON OGDEN: Probably not.

  • It looks pretty similar to the other one.

  • Just has a smaller resolution.

  • So we'll do that.

  • Yeah, that should be fine.

  • Something like that or like that or like that.

  • RODRIGO SANCHEZ: I think it looks fine.

  • COLTON OGDEN: You think it's good?

  • Cool.

  • So that's five.

  • RODRIGO SANCHEZ: How many are in it?

  • COLTON OGDEN: There are eight, I believe.

  • RODRIGO SANCHEZ: Great.

  • COLTON OGDEN: OK.

  • We're getting there.

  • What is the-- this is someone else's version, too.

  • That's different.

  • Different version of it.

  • Where is a six?

  • Come on, six.

  • There's a seven there.

  • Oh, six.

  • OK, so six is kind of like a blue green.

  • Holy crap.

  • RODRIGO SANCHEZ: Wow.

  • COLTON OGDEN: That is--

  • RODRIGO SANCHEZ: --illegible

  • COLTON OGDEN: That an insane-- that looks like a map.

  • RODRIGO SANCHEZ: Yeah.

  • I was about say, like Civilization.

  • COLTON OGDEN: Looks like Florida a little bit.

  • Man, OK.

  • That's insane.

  • That's some next level Minesweeper right there.

  • I mean, if we did the algorithm correctly for generating the map--

  • RODRIGO SANCHEZ: We should be able to.

  • COLTON OGDEN: We could theoretically make this and it would work just fine.

  • It to be kind of slow during the initial.

  • Because what we're going to have to do is we're

  • going to pass over our entire grid.

  • And the grid, it's going to basically need

  • to check every single tile for a bomb.

  • And it's going to check every tile for how many bombs are around

  • that tile to give it the number.

  • RODRIGO SANCHEZ: The question is whether we would trigger a stack overflow.

  • COLTON OGDEN: Doing what?

  • RODRIGO SANCHEZ: Like, if the map got big enough, right?

  • The number of tiles.

  • Or not?

  • COLTON OGDEN: Oh, for the recursive.

  • RODRIGO SANCHEZ: Oh, wait.

  • The map isn't recursively generated.

  • It's just checking.

  • COLTON OGDEN: The map's not recursively generated, no.

  • RODRIGO SANCHEZ: Unless it just so happened that there were bombs every so

  • often and so you ended up taking the entire map or something.

  • I don't know.

  • COLTON OGDEN: Yeah, and even then, I don't think

  • that there would be that many calls.

  • Like if you multiplied--

  • I mean, I guess it could theoretically be a stack.

  • RODRIGO SANCHEZ: It would be very unlikely.

  • COLTON OGDEN: Yeah.

  • But theoretically I could see it happening, yeah.

  • All right.

  • So six will be a sort of a weird greenish blue color I think.

  • This color.

  • Maybe?

  • So six.

  • This might be actually a little bit too dark.

  • RODRIGO SANCHEZ: Their six looked pretty light.

  • COLTON OGDEN: We'll try this.

  • Looks like a G.

  • RODRIGO SANCHEZ: G.

  • COLTON OGDEN: Move that over here.

  • RODRIGO SANCHEZ: The four and the six.

  • COLTON OGDEN: That's a pretty good six.

  • RODRIGO SANCHEZ: That's better.

  • COLTON OGDEN: I'm proud of that six.

  • I'll say that.

  • K, come on.

  • Six, there we go.

  • Let's go ahead and make seven.

  • What color was seven?

  • Seven was like a--

  • RODRIGO SANCHEZ: Well, you did the six in the seven color, I think.

  • So you could do the seven in the six color if you wanted.

  • COLTON OGDEN: I'll do this as a seven.

  • Why not?

  • RODRIGO SANCHEZ: Seven should be--

  • COLTON OGDEN: Not like that.

  • Try that one more time.

  • And then boom, boom, boom, boom, boom.

  • It's too slanted.

  • RODRIGO SANCHEZ: Honestly, I draw my sevens like straight.

  • But that actually looks-- that's a good.

  • Do you want to be consistent with the--

  • COLTON OGDEN: Yeah.

  • Which means I need to start up here.

  • Actually, I can't fit it.

  • Oh, I guess that works OK, Right?

  • RODRIGO SANCHEZ: Yeah, I can see it.

  • COLTON OGDEN: It's a big seven.

  • It's bigger than the other numbers, but I'm not too picky at this point.

  • I kind of just want to finish making the numbers.

  • Eight is-- I guess it doesn't really matter what color we choose

  • as long as it's different, right?

  • RODRIGO SANCHEZ: True.

  • COLTON OGDEN: Can make eight a yellow or something.

  • Maybe something like, yeah.

  • Like bright yellow.

  • RODRIGO SANCHEZ: Like, this is really bad.

  • COLTON OGDEN: Yeah.

  • RODRIGO SANCHEZ: You got really lucky.

  • COLTON OGDEN: I hope it's not painful to look at.

  • I guess it's not terrible.

  • OK, so boom boom.

  • Whoops.

  • Boom, boom.

  • That's a pretty solid eight.

  • RODRIGO SANCHEZ: That's probably--

  • COLTON OGDEN: The best number so far.

  • It's a shame because you probably won't see it that often.

  • Again, apologies to the people on screen that are bored watching me

  • make numbers.

  • RODRIGO SANCHEZ: How to make numbers in CS50.

  • COLTON OGDEN: Yeah, I know, right?

  • Purple, we'll make this nice bright purple our nine.

  • RODRIGO SANCHEZ: That looks really good, too.

  • COLTON OGDEN: It's pretty solid.

  • RODRIGO SANCHEZ: But I thought you said there was only eight.

  • COLTON OGDEN: Oh, right.

  • You can't have nine neighbors.

  • That's silly.

  • OK.

  • RODRIGO SANCHEZ: Such a shame.

  • Looked so good.

  • COLTON OGDEN: I got into a loop, into a routine.

  • OK, cool.

  • So that's good.

  • We did all that.

  • That's beautiful.

  • We made all of our images.

  • For the sake of time, I'm not going to put them on a spreadsheet

  • and then do a programmatic like indexing of the tile table in order to do it.

  • I'm just going to load them all as separate textures.

  • Where do I want to be?

  • I want to be in here.

  • So I'm going to go over here.

  • And then I'm going to, one at a time, index

  • them with the string one, two, three, four, five, six, seven, eight, nine.

  • Although, I could do it with just the number itself and then that way

  • I could index into the table with that number when we look at it.

  • Or I can just two-string it.

  • Actually that's fine.

  • OK, cool.

  • Love.graphics.newimage graphics/1.png and then I'm going to kind of do this.

  • So that will be two, three, four, five, six, seven, eight.

  • Cool.

  • So now we have eight index indices into our grid there.

  • Bomb as well.

  • We got to do bomb.

  • That's important.

  • So bomb is going to be equal to love.

  • Love.graphics.newimagegraphics/bomb.png.

  • Cool.

  • Go over here to--

  • should I run it?

  • So we didn't actually set the thing to bomb, right?

  • So what we can do is, in our game grid, so another one of the things that we

  • need to do is instead of doing this four loop where

  • we draw just a statically-allocated grid of numbers in advance,

  • or rather numbers that map to textures via this ternary statement, what

  • we should do is actually instantiate all of the indices in our grid.

  • So what we can do is I can say, self.grid equals that.

  • And this is basically taking what's in main.lua and putting it into here.

  • And actually, grid is still referenced as a global variable from main.lua.

  • So that's why that's still even working.

  • But now I can say 4y is equal to one until self.height do.

  • And this allows us to actually support rectangular grids.

  • So I can do 4x is equal to one self.width

  • because now those numbers are separate.

  • Then I can say--

  • what we also need to do is table.insert into self.grid a new table

  • because it's a 2D table.

  • And then I'm going to do table.insert into self.grid at y.

  • Not a number one or two, but rather a new grid tile here.

  • So I can say grid tile.

  • And then in the grid tile is where I can say

  • local is bomb is going to be equal to math.random2.

  • So a 50% chance in this case, which is way too high,

  • I think, but just for demonstration.

  • And true or false.

  • Yes.

  • And then I'm going to say is bomb right in there in the grid tile,

  • because again our constructor takes in it is bomb variable

  • and Boolean to be true or false.

  • So what I'm going to do then is--

  • and in this particular instance, I'm also going to randomly determine--

  • I'm going to illustrate that not all depressed tiles need to be bombs.

  • So what I can do is I can just make it revealed as well.

  • So I'll make whether it's revealed or not a Boolean, I guess.

  • Or rather, what I can just do is say local is revealed

  • is going to be equal to math.random2 and true or false.

  • So now it's not only a 50% chance that it's a bomb, but a 50% chance

  • that it's also revealed.

  • And then I'm going to say--

  • what I should do is that I should say, local grid tile is equal to this.

  • So the reason I'm doing that is so that I

  • have a reference to this variable, that grid tile

  • that I'm going to add into the table.

  • I want added and then I'm also going to say hidden is equal to is revealed,

  • which is actually the opposite of what--

  • RODRIGO SANCHEZ: It's in.

  • COLTON OGDEN: Yeah.

  • So this should be is hidden.

  • Giving everything it says, in this case it doesn't really matter.

  • Either way we're just setting something to true or false at random.

  • But the semantic of that is important to take into consideration if we're

  • doing something more complicated.

  • Now, this will give us grid tiles that are randomly bombs, randomly hidden,

  • and a mixture of the two, right?

  • So if it's a bomb, then I'm going to draw.

  • Then it's a bomb.

  • Else, right?

  • Because if it's not hidden it could be either a bomb or not.

  • And so I'm going to draw whether it's a bomb or not.

  • And then eventually what I'm going to do is,

  • we're going to have that number attribute associated with each tile,

  • whether it's two, three, four, five, six, seven, eight.

  • And if it's any of those, then when we draw that instead of tile

  • depressed, basically.

  • And draw a bomb if it's a bomb.

  • And then if it is a bomb as well, then it wouldn't be inside render.

  • It would be inside of update or something when we actually click it.

  • If it's a bomb and we discover it, then that's

  • also going to be the trigger for the game over, too.

  • Because when you hit a bomb you get game over and then you get your score.

  • I have not been looking at any of the chat.

  • I apologize.

  • So let's do that.

  • Nine is impossible, yep.

  • [INAUDIBLE]

  • I got into a mental auto-pilot.

  • Wow, there's a lot of chat.

  • OK.

  • RODRIGO SANCHEZ: There it is.

  • COLTON OGDEN: OK.

  • Cool, cool.

  • Slytherin, the audacity.

  • Yeah, adamantium was saying, it is super useful

  • to see the process of making sprites.

  • Yeah, and again, I use Aseprite but there

  • are a lot of other tools like Photoshop and Gimp you can use to make sprites,

  • too.

  • It's kind of up to personal preference.

  • Aseprite is catered specifically to words 2D sprite development.

  • But it's also not free.

  • So you'll want to take that into consideration.

  • RockdayStudios, in my game developer, Godot

  • is an open source 2D 3D game engine.

  • No fees, no lawsuits.

  • Yeah, I've seen Godot.

  • I'm familiar with Godot.

  • Thank you for mentioning it, though.

  • Press F for two.

  • [INAUDIBLE]

  • Do you know what that's a reference to?

  • I'm not sure.

  • RODRIGO SANCHEZ: Forgot what that was.

  • COLTON OGDEN: Apologize.

  • I'm not sure what that means.

  • RODRIGO SANCHEZ: Maybe that's what we were creating the number two.

  • I don't know.

  • COLTON OGDEN: [INAUDIBLE] says, if it's an ad, it's a good one.

  • Yeah, I mean, people should be encouraged to mention technologies

  • in stacks that they like.

  • So no shame in that.

  • I think if somebody does it over and over and over again

  • and if it's something that's obviously a product that's trying

  • to be sold it should be a problem.

  • But I think mentioning Godot as open source is totally fine.

  • And people should feel encouraged to check out

  • those tools, those pieces of software.

  • Cool.

  • Instead of checking every tile, why not add a counter

  • around the bomb object which is hidden for the player?

  • Or was that the idea?

  • Yeah, every tile is going to be pre-calculated

  • so it's going to be cached.

  • Every tile is going to know exactly how many bombs are around it.

  • So when you click a tile and--

  • is that the case?

  • It's going to essentially recursively look at all of its neighbors.

  • If it's a bomb, it's not going to reveal it.

  • If it's another tile with a number that's not a bomb,

  • it's going to reveal that tile, which will then reveal its other tiles.

  • And if it's empty, it will reveal that tile

  • and also trigger the recursive thing.

  • So empty and numeric tiles have the same recursive functionality.

  • But if it's a bomb or an edge, that stops the recursive algorithm

  • from continuing.

  • And also actually-- well, no.

  • Is that the case?

  • Is that true?

  • No, that's not the case.

  • So if it is a number, it doesn't--

  • if it's a number, it's also an ending point.

  • So at a number, the number will stop recursively looking through tiles

  • as well.

  • That's a base case for the recursive algorithm.

  • If it hits a number tile it stops there.

  • It just basically hits a wall at that point.

  • Has anybody seen an eight in Minesweeper?

  • Yeah, I feel like that would be pretty tough to actually get.

  • But I'm sure a lot of people have seen it.

  • We need a puzzle with a small map and huge number of bombs.

  • Yeah, yeah, yeah, yeah.

  • What color were you making?

  • Yeah, troll.

  • Yeah.

  • Brain fart.

  • We need a nine and a zero for the sake of completeness.

  • Yeah, kind of feels like that.

  • [INAUDIBLE] Minesweeper, guys, don't worry.

  • Yeah.

  • Yeah, the extra z layer.

  • 4D Minesweeper, holy crap.

  • Nine not needed.

  • Idea.

  • What are your thoughts on a flag is needed.

  • What's the flag?

  • Do you remember what the flag is for?

  • I've seen it in Minesweeper but I honestly

  • don't remember what it's used for.

  • RODRIGO SANCHEZ: I haven't played it since I was, like, six.

  • COLTON OGDEN: Yeah.

  • If you want to let me know what the flag is for, I actually don't know.

  • 3D would need 26.

  • Oh, yeah it would.

  • It would need 26 indices for a 3D, a three by three by three.

  • Check around the tile.

  • Not nine but a flag, a flag and an exclamation point.

  • People are asking about validators on the web

  • I think validators at the HTML site are still circumventable.

  • So ultimately, you probably want back end validation.

  • Depends.

  • RODRIGO SANCHEZ: [INAUDIBLE].

  • COLTON OGDEN: [INAUDIBLE].

  • I like coming in here.

  • Every time I fail to understand what's happening

  • and that motivates me to go continue my backlog courses.

  • I don't know whether to take that well or not,

  • but I appreciate you coming to join us.

  • If you have any questions along the way, definitely let us know.

  • I would recommend starting out with the snake or the tic-tac-toe streams,

  • though, because those are a little bit easier

  • and they give you a good jumping point.

  • Depends on your audience.

  • I guess it's a bit of a mix.

  • But if your main audience is on mobile, you

  • could go mobile first and make it adaptable for bigger screens.

  • Yeah, they're talking more about the mobile stuff.

  • Press F to pay respect when you overrode the two number.

  • Oh, I see.

  • I see.

  • [INAUDIBLE]

  • Do the bombs get generated after the first click?

  • Bombs get generated at the beginning of the map.

  • So the whole map is completely generated at the very beginning, all the bombs,

  • and all of the neighbors of the bombs get their numbers pre-calculated.

  • And then you just reveal them by clicking on the mouse

  • and recursively revealing tiles.

  • Use the flag to make where you think are bombs, useless.

  • Flag is for marking a bomb that is--

  • oh.

  • So the ability to actually say, oh, I know this is a bomb.

  • To mark it.

  • OK, OK.

  • Yeah, I'll have to think about that.

  • I didn't think about that, actually, earlier.

  • But yeah, that would be smart.

  • And that would actually be pretty simple.

  • All you would have to do is--

  • we'd have to go into a mark mode.

  • And so if they click it when they're in mark mode, it just changes that.

  • Basically turns on a flag skin for an unrevealed tile.

  • So yeah, that's something we could do.

  • RODRIGO SANCHEZ: I'm actually about to head out.

  • COLTON OGDEN: OK.

  • Sure, sure.

  • Well, it was good.

  • RODRIGO SANCHEZ: Yeah.

  • Tomorrow I'll be here for the full time.

  • COLTON OGDEN: Oh yeah, that's true.

  • Yeah, JPguy just said, [INAUDIBLE] can check out chat while you program.

  • But Rodrigo is unfortunately leaving.

  • RODRIGO SANCHEZ: I'm out of time but I'll be back tomorrow.

  • And we'll hit object-oriented programming again a little bit.

  • COLTON OGDEN: OK, cool.

  • RODRIGO SANCHEZ: And switch over to Python.

  • COLTON OGDEN: Yeah.

  • RODRIGO SANCHEZ: You said that we haven't done much Python streaming.

  • COLTON OGDEN: Not a lot.

  • RODRIGO SANCHEZ: So that'll be fun.

  • All right.

  • It's been real.

  • COLTON OGDEN: It's been real, man.

  • Appreciate it.

  • Thank you very much.

  • OK.

  • So I do like the idea, yeah, right click.

  • Right click can set a flag.

  • We can take a look at that, actually.

  • We have another hour or so left.

  • Hopefully we can get all the features done.

  • I mean, we have several more steps to do.

  • This might end up being a two-part stream.

  • And if it is a two-part stream, we would definitely

  • do something like flags and multiple game states and all that sort of thing.

  • We'll see how much we can get finished after this.

  • And I'll commit everything to GitHub.

  • And this will probably, if it is a two-part stream,

  • it'll probably be next Monday.

  • But yeah.

  • Let's go ahead.

  • So the next step we needed to do--

  • oh yeah, we were going to draw the tile being depressed

  • or a bomb, depending on the situation.

  • So OK, so it's looking for grid tile.

  • We haven't added grid tile to our dependencies yet.

  • So let's go ahead and do that.

  • Requiresource/gridtile and it's not quite working yet.

  • So let me see why that is.

  • Oh, you know why it is?

  • It's because we're still doing this bit of code

  • here, which is not what we want to do.

  • We don't want this to happen.

  • What I want to do is I want to draw, rather, I

  • don't want to draw anything with that.

  • self.leftoffset plus-- and self.y offset plus yeah.

  • What'd we do?

  • Would we do it like that?

  • self dot-- OK.

  • We're going to do self.grid at yx, render, right?

  • Because we defined a render function in our grid tile class.

  • So these are all grid tiles now.

  • They aren't just numbers anymore.

  • It does take an x and a y, if I'm not mistaken,

  • right here, which is this x and y.

  • And we can just reuse the x and y that we have here.

  • So self.leftoffset, blah, blah, blah.

  • Wow, that looks great.

  • And, OK.

  • So we have a grid full of revealed tiles now.

  • Is hidden equal true?

  • Oh, you know why?

  • OK.

  • We didn't make is hidden actually a parameter of the function.

  • We just kind of assumed that it did.

  • And it's still not working.

  • So why is that the case?

  • Let me see.

  • Self.ishidden is equal to ishidden.

  • Oh, is equal to one.

  • So this was always getting true because the result of math.random2

  • is always going to be a truth value.

  • So it was always giving us true because the way the ternary statement works.

  • And same thing with this, we need to also set that.

  • So now it works.

  • Cool, awesome.

  • We see some bombs, right?

  • Looks great.

  • I like how that bomb ended up looking.

  • It looks pretty good, pretty good sprite work

  • for somebody who sucks terribly at making sprites.

  • Yeah, I like that a lot.

  • That's super cool.

  • [SPEAKING JAPANESE]

  • It's not difficult, is what [INAUDIBLE] just said.

  • It's not difficult. I appreciate the Japanese in the stream a lot,

  • as somebody who's learning Japanese.

  • I would prefer to see it in an actual kana I think.

  • But we have to set up--

  • I'd have to go to translate.google.com so I can actually type it.

  • So what he just said was--

  • I can just do it on stream, right?

  • Translate.google.com.

  • My computer is set on a different account.

  • It's set so I can type at the operating system level in Japanese.

  • [SPEAKING JAPANESE] It's not set to type in kanji.

  • We need to do that.

  • So [SPEAKING JAPANESE].

  • Let me see what he's typed and I'll remember.

  • There he did.

  • [SPEAKING JAPANESE]

  • So something like that, right?

  • Saying it's not that difficult, though.

  • [SPEAKING JAPANESE]

  • Anyway, try not to spend too much time on that.

  • Pretty basic sentence.

  • I'm not good at Japanese at all, but I read much better than I can actually

  • speak and understand.

  • But yeah.

  • Because the map is generated at the beginning randomly with correct math,

  • turn all tiles hidden and is presented to the player.

  • I mean, everything is going to be unrevealed at the very beginning.

  • We don't need anything specifically math-generated.

  • I mean, in the sense that we will be looping over all the tiles

  • to see how many neighbors they have that are bombs, we will need to do that.

  • And that's sort of like a pre-calculation.

  • But that's all we're doing.

  • Bombs are turned into flags when the game is won.

  • Oh, that's a cool feature.

  • [INAUDIBLE], are you Japanese?

  • [SPEAKING JAPANESE] Would that be how you say it?

  • [SPEAKING JAPANESE]

  • This was the game Windows offered by default. It should not be so easy.

  • I don't know.

  • It's a pretty easy.

  • I mean, all things considered it's fairly easy.

  • I would say it's not terribly easy.

  • [INAUDIBLE]'s got Greek.

  • I know what Greek looks like.

  • I can sort of read it.

  • [SPEAKING GREEK] I don't remember whether that's-- it's been a long time.

  • I used to know the Greek alphabet pretty well.

  • Not any words in Greek, but--

  • [SPEAKING GREEK]

  • I don't remember whether that's L or M, lambda or mu.

  • [SPEAKING GREEK]

  • In this case, it would be [SPEAKING JAPANESE]

  • because the equivalent in English, present progressive tense.

  • Correct.

  • [SPEAKING JAPANESE]

  • JP, do you speak Japanese?

  • Anyway, language divergence.

  • Oh, that's sick.

  • Fluent Japanese or?

  • That's super cool.

  • Curious how many people in here actually speak Japanese.

  • Everyone's going to start coming out and saying, oh, I speak Japanese, too.

  • Oh, I speak Japanese, too.

  • Nice.

  • That's cool, man.

  • I've only been studying hard for maybe a year, less than a year.

  • And on and off.

  • But I can read fairly well.

  • N3 says [INAUDIBLE].

  • Yeah, I'd guess I would probably be N4.

  • I'm much better at reading and writing than I am at speaking and listening.

  • Friend speaks.

  • He passed N1.

  • Learned it with himself without any textbooks.

  • Yeah, that's essentially what I'm doing.

  • I'm using a little bit of textbooks but mostly through actually playing games

  • in Japanese.

  • It's the main reason I wanted to learn.

  • 3DS with Japanese games.

  • If you guys want to practice kanji together, I'm totally down.

  • OK.

  • Sorry, I'm spending too much time on the Japanese tidbit.

  • It's a lot of fun but we should probably make progress on this.

  • So we have the grid here with the bombs.

  • Super cool, super awesome.

  • What we need to do now is make sure that all of the tiles

  • have the number of bombs as their neighbors and that that's correct.

  • So what we need to do is, we need to calculate--

  • once our grid is constructed, basically, we

  • need to call a function called calculate numbers, right?

  • And this will go in here.

  • And what this is going to do is iterate over the entire grid.

  • So I'm doing a 2D iteration.

  • And I need to basically look for every single tile.

  • I'm going to look to see all of the neighbors excluding

  • edges and corners and things like that.

  • [SPEAKING JAPANESE]

  • I'm a native Russian speaker and can speak a little French, as well.

  • Nice, nice.

  • Is asley here?

  • Actually, I haven't seen her in the chat.

  • So I'm kind of surprised, actually, now that I think about it.

  • And I got to remember that it's her birthday on Friday, supposedly.

  • So I need to verify that on Facebook.

  • But we should all remember that asley's birthday on Friday

  • and wish her a happy birthday.

  • Yeah.

  • So what we need to do is iterate over the entire grid

  • and then for every tile, we need to look at all of the neighbors.

  • So in this case, we say check top left, check top, check top right,

  • check left, check right, check bottom left, check bottom, check bottom right.

  • And there might be a more programmatic smooth way to do it.

  • But this is effectively what the logic is.

  • So we need to say, if x is greater than one and y is greater than one, then--

  • and another thing we need to do is say, local num bomb neighbors

  • is equal to zero.

  • We're just going to add one to this every single time that we find a bomb.

  • So what I can do is, I can say if self.tiles at x minus one,

  • y minus one dot, and it would be .isbomb,

  • then num bomb neighbors equals num bomb neighbors plus one, right?

  • So that's checking the top left.

  • So we're minusing on the x, minusing on the y.

  • So that's just that logic.

  • The top is a little bit simpler of a check.

  • It just basically says if y is greater than one,

  • then if self.tiles y minus 1x.isbomb then num bomb neighbors

  • equal num bomb neighbors plus one.

  • So this is the logic involved.

  • And this takes place for every single tile and all we're doing

  • is essentially bounds checking all of these checks of our neighbors.

  • So just making sure that we're not going to the left of the far left edge,

  • to the right of the far right edge, above the top,

  • below the bottom, that sort of thing.

  • So, same thing for the top right.

  • So if y is greater than one and x is less than what would this be?

  • Self.width, then if self.tiles as this is top right,

  • so this will be y minus one, x plus one.isbomb

  • then num bomb neighbors equals num bomb neighbors plus one, right?

  • Pretty simple.

  • We're just checking left, right, up, down in different permutations

  • and that will tell us whether a neighbor is a particular way, right?

  • So check the left.

  • If x is greater than one, I'll just copy this.

  • If self.tiles at y and then this is x minus one.

  • For the right, let's kind of do the same thing but reversed.

  • So if y is less than self.width, then we'll do y and this will be x plus one.

  • Bottom left is going to be if x is greater

  • than one and y is less than self.height, I'm going to do this, do this.

  • So not a terribly exciting bit of code here.

  • But kind of just, this is the core of our pre-calculation.

  • This is basically all we need to do.

  • There's no way to be at the limits, right?

  • E.g., self.tiles negative one or something.

  • Yeah, that's essentially why we're bounds checking,

  • to make sure that when we check to the right of x,

  • that we're less than our width.

  • Because if we are, then we can go up one index

  • and be at the right edge at the worst case, if not to the left of that

  • somewhere, between one and the width, right?

  • That is exactly why we are doing all of these if statements,

  • for the bounds checking.

  • That's the sole purpose of these if statements.

  • Otherwise we could just blindly do this x plus one

  • but that's not going to work when we're at the far right side of the screen

  • because there are no more indices to the right of that, right?

  • So this is why we're saying, if y is in this case, this needs to be different.

  • So x minus one, we're making sure that we're greater than one.

  • Because if we're at one and we do minus one,

  • we'll be at index zero, which is not a real index in Lua tables

  • because they're one indexed, right?

  • So that's effectively why we're doing this.

  • So self.tiles, and this is going to be also y plus one.

  • I have plus one, x minus one.

  • And this is why we're doing less than self.height, right?

  • So check the bottom.

  • So if y is less than self.height, then--

  • and then we can do this.

  • We're just checking x and y plus one.

  • And then bottom right, which is if y is less than self.height and x is

  • less than self.width.

  • And then we would do x plus one, y plus one.

  • Cool.

  • That's good.

  • And then now we'll have a number for this particular index in the grid,

  • right?

  • For that particular tile.

  • So I can say, we've done all of that.

  • Num bomb neighbors shouldn't be at that level.

  • It should actually be over here.

  • Store all bombs we see around tile.

  • Checking on neighbors.

  • This is kind of just to give a sense of what this particular code box is all

  • about.

  • So we're checking all the individual tiles and then at the end,

  • once we've checked all of the tiles, we can then say store number at that tile.

  • We can say self.grid at yx dot, and this would be num bomb neighbors

  • equals num bomb neighbors, right?

  • So now we have that.

  • So what we can then do is say, in our grid tile,

  • so now we're going to actually have that number, right?

  • So we can two string that.

  • Can say if it's a bomb, then we [INAUDIBLE] bomb.

  • Else, wait.

  • Do I have this reversed?

  • I have this reversed.

  • If self.isbomb, don't draw the bomb?

  • OK.

  • So I had that mixed up.

  • I mean, it looked OK but the logic is wrong.

  • So I'm essentially just going to do this.

  • Boom, boom, do a little trade, little switch.

  • Something like that.

  • Cool.

  • Now it's actually accurate.

  • If it's a bomb, draw the bomb, don't draw the depression.

  • I don't know what I was thinking.

  • But yeah, draw the bomb.

  • How does work right now?

  • OK, tiles at 68.

  • So I need to make sure that is OK.

  • 68 self.tiles.

  • Oh, it's not self.tiles, it's self.grid.

  • OK, whoops.

  • So we can fix that.

  • I'll just go over to self.tiles.

  • And make that self.grid.

  • Right, cool, looks great.

  • And then if it's a bomb--

  • so the depressed, this is where we're going

  • to actually draw the color, sorry, the number for that particular tile.

  • So I can say, local num bomb neighbors is equal to--

  • what would this be?

  • Grid tile.

  • OK, this is the grid tile.

  • This will be self num bomb neighbors.

  • Oh, wait.

  • What am I doing?

  • I'm sorry.

  • Brain fart.

  • So now that we have the reference to the number of bomb neighbors, what

  • we want to do is say, draw that tile.

  • We're going to map that to the particular tile

  • that we loaded earlier, right?

  • Which we stored in dependencies.

  • And they all started with a string numerical index here.

  • So it's a string but it's a number.

  • So what we can do is we can say, if self.numbombneighbors

  • is greater than zero, right?

  • If it's greater than zero, then we want to draw one of the number ones.

  • If it's zero, if it is zero, then I just want

  • to draw the depressed tile as it is just by itself.

  • So in here, I'm going to say love.graphics.drawgtextures

  • and then I'm going to say two string, self.numbombneighbors, right?

  • Which is good.

  • Gtextures and then there I can say xy.

  • And there we go.

  • So we have our numbers.

  • Now seeing them all together looks pretty wacky.

  • But in theory, this should actually be working.

  • So notice that there's this one here and it has this one tile next to it

  • that has a bomb, right?

  • And this two here is also kind of right here.

  • I'm guessing this two and this two, these two have to be bombs.

  • And there's no way we can really know right now.

  • What we should do is just always draw them.

  • So just check to see whether our algorithm is working.

  • Get rid of the hidden check here.

  • So I'm going to get rid of this right now for you.

  • Get rid of this.

  • We'll bring it back later but for now, I just want to draw every single tile.

  • OK.

  • Yeah.

  • Wait.

  • This five right here should be a six.

  • Because one, two, three, four, five, six.

  • I mean, these two are working, this three is working, this four is working,

  • this five is not working.

  • But this four is working.

  • This four is not working, OK.

  • Do I have something wrong with my top left?

  • Is my top left messed up?

  • These both are getting their top left incorrect, I think.

  • I don't know.

  • Well, this one is incorrect.

  • There's a one and a two.

  • This two is correct.

  • Four is correct.

  • This four is not correct.

  • Oh, wait.

  • Oh, you know why?

  • Because each bomb may also have a number.

  • So what we need to do is, we need to check

  • to see if this already has a bomb.

  • And if it does, don't even worry about numbers, right?

  • So yeah.

  • The bombs are--

  • I think that might be the problem.

  • I'm not 100% sure.

  • So I'm going to say if self.grid at yx.isbomb, then

  • we're not going to store a number here.

  • And I don't know if this matters.

  • Yeah, I guess this wouldn't matter actually.

  • But we can skip this logic at least.

  • Yeah.

  • I'm going to put all of this inside there.

  • It's at least an optimization.

  • So we'll do it for that purpose, I guess.

  • I'm a little confused as to why that's not working.

  • So whoops.

  • So now it's only going to work if it's not a bomb.

  • If not, self.gridisbomb.

  • Cool.

  • And I don't think that's going to work any better.

  • It's actually the exact same grid.

  • Is it?

  • No, it's not I don't think.

  • Yeah, there must be an issue with my logic because this four up here, right?

  • Oh, wait.

  • No, that's OK.

  • That's fine.

  • So, this five right here, right?

  • This five right here.

  • One, two, three, four, five, six.

  • So there must be a subtle mistake that I'm making,

  • maybe in my conditional logic here.

  • So let me just make sure that that's correct.

  • So if x is greater than one, y is greater than one, OK.

  • X minus one, y minus one, right?

  • Top left.

  • The top, just the y greater than one, right?

  • Make sure that, OK.

  • Y minus 1x, yeah, that's correct.

  • OK, top right.

  • Y is greater than one.

  • X is less than self.width.

  • So y minus one, x plus one.

  • OK, cool.

  • X is greater than one, yep.

  • X minus one.

  • If x is less than self.width, OK, y and x plus one, yep, correct.

  • Bottom left.

  • If x is greater than one and y is, OK.

  • Yep.

  • Yep.

  • Y is less than self.height.

  • OK.

  • OK.

  • If y is less than height and x is less than self.width.

  • OK.

  • Oh.

  • It's this.

  • Yx.

  • Let's try that.

  • one, two, three, four, five, six.

  • One, two, three, four, five.

  • One, two, three, four, five, six.

  • One, two, three, four, five.

  • OK.

  • I think it was just that.

  • It was a silly--

  • I had put x here and y here.

  • Should be reversed.

  • Y goes before x in this case with 2D indexing.

  • Cool.

  • Awesome.

  • Colton, consider all corners and edges first.

  • I don't think that's necessary.

  • Unless you're talking about this, the if statement in my conditional logic.

  • But I don't think it matters what order you check stuff in

  • as long as you check all of them.

  • Live debugging, NACLeric.

  • Yeah.

  • No, that was good.

  • That was a good illustration of what debugging looks like sometimes.

  • But no, this is great, right?

  • Now, let's go ahead and actually render this appropriately.

  • So we can say if self.ishidden then else so love.graphics.drawgtexturestile tile

  • at xy, right?

  • Cool.

  • So the hidden attribute is just random at this point.

  • So it's not really serving much of a purpose.

  • Now, you know what?

  • Another thing we needed to do, I needed to test the emptiness, right?

  • Did we have any empty?

  • I don't even think we had any empty tiles on the last one

  • just because there were so many bombs.

  • So I want to generate a lot fewer number of bombs than we had already.

  • So what I'm going to do, I'm going to set this to 10.

  • I'm going to make it a 1 in 10 chance, effectively.

  • And then I'm going to set hidden to be false always right now.

  • Nice.

  • OK, cool.

  • So that's a little bit more appropriate, I think.

  • And now they're all being shown on the screen.

  • This is cool.

  • I like this.

  • This is fun.

  • This is exciting.

  • Yeah, this is super cool.

  • So now let's set it to be true by default, right?

  • So now they're all hidden.

  • Now, this is where we need to start actually

  • implementing, being able to click on the individual boxes, right?

  • So yeah.

  • We can do this.

  • So what I'm going to do is, this is going to be my update function.

  • So in my update function, first of all, I'm going to add this to main.

  • I'm going to say, in main.

  • So right now I'm drawing the grid here.

  • I also want to update it.

  • So game grid update delta time.

  • Again, delta time is the number of seconds

  • that have passed since the last frame.

  • So it lets you keep things normalized across frame rates, which is cool.

  • I'm going to go into here.

  • I'm going to say, local xy is equal to love.mouse.getposition.

  • And now what I need to do is I basically need to iterate over every single grid

  • tile and say, is the cursor within the bounds of that tile, right?

  • And if it is, I need to draw a rectangle on top of that tile.

  • And the easiest way is to take the offsets

  • and to consideration and then just kind of do it based on--

  • a couple of ways we could do it.

  • So first of all, you need to convert.

  • When you're using the push library, in order

  • to actually get the actual pixels, the proper pixels, you need to do push.

  • And what is this?

  • To world?

  • And then now we can do love.graphics.print x two string x.

  • Y two string y.

  • And I'm going to put that zero and then virtual height minus 16.

  • To world.

  • Pushed to world.

  • Oh, is it to game?

  • Might be to game.

  • There we go.

  • But it's not rendering because I think it's a little bit too low.

  • Let's try it minus 48, let's try that out.

  • No, that's not working.

  • OK, that's fine.

  • Love.graphics.print x to string x, y to string y

  • at zero virtual height minus 48.

  • Oh, that's my bad.

  • That needs to be within the push start, push finish.

  • So that's fine.

  • We can do this.

  • This is a little bit weird.

  • But now you can see it works.

  • We have a virtual resolution, so 384 by 216, again, is our resolution.

  • So we can see that it is rendering.

  • And now the thing is, it's going to need to be I think cast to an integer.

  • I mean, we could do it with floats, too.

  • That's fine.

  • Doesn't really matter.

  • But that's pretty cool.

  • It's going to be important.

  • Let me make sure that I'm meeting everything.

  • If y is less than y height and x, it will enter twice, right?

  • In the state we should be up.

  • No.

  • It won't do the logic twice, if that's what you mean.

  • Oh, levels.

  • I like Bhavik's idea.

  • Level beginner 10 bombs, intermediate 40 bombs, expert 99 bombs.

  • That's cool.

  • Use the check neighbor function, same logic.

  • Abstract check neighbor and use it for a bomb or empty.

  • Oh, I see what you mean.

  • Yeah, yeah, yeah.

  • We could've done that, too.

  • Yeah, that would've been better design.

  • You'd check neighbor, which basically takes an x and y and then does this.

  • The only thing is that what you check and what conditions you check

  • are inverted.

  • And so you would need to pass in negative numbers to get it to work.

  • It's a little bit strange.

  • You could get it to work that way, though, for sure.

  • For checking a [INAUDIBLE],, blah, blah, blah, blah.

  • As an exercise, try and implement it on your own.

  • And actually, to complement that, I'm going to add this

  • to GitHub before I forget to do so.

  • I forgot to add the typing game code, the last bit we did to the stream.

  • And Brenda kindly informed me afterwards.

  • So hopefully I don't neglect doing so again today at the end of the stream.

  • We're going to call this Minesweeper stream, Twitch stream on Minesweeper.

  • Make it public, create repo.

  • Cool.

  • Copy that.

  • Go over here.

  • Exit Python, clear.

  • Where am I?

  • Add it there.

  • Need to go into Minesweeper.

  • Get init, get adstock, get ad first commit.

  • Get remote at origin.

  • [INAUDIBLE]

  • Get remote at origin.

  • That get push upstream origin master.

  • Cool.

  • So that's up and running now.

  • So if you refresh that, boom.

  • Now you have Minesweeper.

  • You can follow along if you want to or add your own logic to it.

  • Currently, the state of it is as such.

  • The next step we want to do is be able to determine whether we're

  • highlighting one of these tiles.

  • So let's do that.

  • So what I want to do is, I kind of want a hover effect.

  • So when I'm hovering over any of these tiles,

  • I kind of want it to show a semi-transparent rectangle.

  • And so I think that's what I'm going to do.

  • I'm going to say self.highlightedgrid equals--

  • rather, highlighted tile, I'm going to set that to--

  • actually, no.

  • I'm going to say self.ishighlighting to false because I

  • don't want it to be highlighting if I'm not, for example, over the grid.

  • Like if I'm over here, I don't want any of the tiles

  • to be highlighted just as a user experience.

  • I don't want them to be like, why is there a leftover

  • highlighted rectangle on the grid right here, you know?

  • It doesn't really make sense.

  • So instead, I'm going to--

  • what I want to do is, I want to--

  • I have to get a reference to each grid tile

  • and check to see within that grid tile if my cursor falls within it,

  • if it's within the bounds of that rectangle, right?

  • So I want to basically do a four y is equal to--

  • well, I just don't want to do four y is equal to one.

  • I want to do x pause, y pause.

  • So for y is equal to one self.height, and again, I have to also do this.

  • I have to do x pause, y pause.

  • And then x pause, y pause.

  • That.

  • I'm going to do a double loop over my grid.

  • And then I'm going to say four y is equal to one self.height do

  • four x is equal to one self.width do.

  • And then this is going to let me go over every single tile in the grid, right?

  • And so what I'm going to do then is say, local tile is equal to self.grid at yx.

  • So that's a reference to that particular tile in the grid.

  • I'm going to do if x pause is greater than tile--

  • they maintain an xy as a reference to their--

  • oh, they don't even maintain an xy.

  • OK.

  • So they maintain an xy relative to their iteration.

  • OK, so it would be greater than--

  • so this would be the offset of the grid, then, the first part.

  • So self.leftoffset.

  • Self.leftoffset plus x minus one times tile size, right?

  • And x pause is less than self.leftoffset plus x minus one times

  • tile size plus tile size.

  • And, we'll do a then first.

  • If y pause is-- just, I'd probably ideally combine this into one Boolean

  • expression, but because it's such a long line,

  • I'm going to actually split it into two checks, one

  • nested within the other one.

  • And this is also form of short circuit logic but bulky.

  • Basically lets me avoid checking y pause if x

  • pauses isn't even worth considering.

  • But we're doing kind of the same thing here.

  • I'm basically saying greater than--

  • and this is vertical offset but it's top offset.

  • Top offset plus y minus one times tile size.

  • And y pause is less than top offset plus y minus one times tile size

  • plus tile size.

  • So in this case, the x of the mouse is within the rectangular border

  • of whatever tile we're looking at, right?

  • So then I can say, self.ishighlighting is equal to true.

  • And then another thing I have to do to make sure

  • that we're not highlighting a rectangle indefinitely after we've

  • gotten outside the bounds of the grid, I should

  • say local highlighting something is equal to false, right?

  • And then at the end of all of this, rather this should be--

  • I basically want to check to see whether at the end of this whole block of code,

  • I want to say, did we find something to highlight?

  • And if we didn't, then self.highlighting should be toggled back off to false.

  • So it's basically going to match this variable

  • up here that we're keeping track of.

  • We're assuming false but anytime that we get a match on a tile,

  • then we're going to set that to true, right?

  • And then what I can do is I can say, if highlighting something,

  • and this isn't a self variable, then self.ishighlighting

  • is going to be equal to false, right?

  • So basically using this, we're keeping track of over this whole iteration,

  • did we find something to highlight?

  • If we didn't, if we're outside the bounds of the grid,

  • let's make sure that we turn off highlighting.

  • So self.ishighlighting should be set to false in that case, right?

  • Which is right here.

  • Highlighting something is equal to true, something

  • is highlighting is equal to true.

  • And then if we are highlighting something,

  • what we want to do is we want to say, self.highlightingtile and we'll just

  • say x is equal to x and y is equal to y.

  • And what this will allow us to do, now down here in the rendering thing,

  • we can say if self.highlightingtile, then,

  • so if we're highlighting something, if we've flagged something

  • as being highlighted, wait, rather is highlighting, sorry.

  • If self.ishighlighting, then what we're going to do is we're going to say

  • love.graphics--

  • no, we're not going to do it in here.

  • That's silly.

  • We do outside the loop.

  • We're going to say if self.ishighlighting, then we're

  • going to say love.graphics.rectangle, and this is going

  • to be a white, semi-transparent thing.

  • So we need to do love.graphics.setcolor21110.1 maybe.

  • So what this is doing is, you have to set that global variable for the color.

  • It's sort of like the marker.

  • And we need to do that before we actually draw the rectangle.

  • Because by default, it's just going to be white.

  • So it's just going to draw a white rectangle.

  • We don't want that.

  • We do want to also revert the color after that

  • to love.graphics.setcolor1111.

  • So love.graphics.rectangle and this is going to be at self.highlightingtile.x.

  • Self.highlightingtile.y, tile size, tile size.

  • And this should also be a fill rect, not a line rect.

  • Now, if I'm not mistaken this should work.

  • Maybe not.

  • OK.

  • Let me make sure that this is working.

  • OK.

  • Self.ishighlighting is equal to true.

  • X is equal to x, y is equal to y.

  • Oh, and then I think in addition to that,

  • we also have to do self.highlightingtile.x plus--

  • or rather we should do--

  • we have to also take the offsets into consideration, which I forgot to do.

  • So this would be top--

  • rather, this would be self dot the width offset, whatever that is.

  • And I apologize if I'm going a little bit fast.

  • We're very close to the end.

  • And we probably won't have time to get to the actual solving the game,

  • unfortunately, or the flags or the game states.

  • But I want to get us at least into highlighting the rectangles before we

  • end the stream.

  • So I'm going a little bit fast.

  • I apologize for that.

  • But we will get this part finished for sure.

  • .leftoffset plus that.

  • And then top offset plus that.

  • OK.

  • That should work.

  • Maybe not.

  • Is it maybe too transparent?

  • Maybe do like 0.3.

  • OK.

  • So something is awry.

  • I have failed in some fashion.

  • So OK, we're going over the grid.

  • For y it's a self.height, self.width.

  • Getting the tile at grid yx, which is good.

  • OK, that's what we want.

  • We are calling update, right?

  • Yep, game grid update delta time.

  • Cool.

  • We have the x position here, so we know about that.

  • So we're basically saying if the x position is greater than

  • self.leftoffset plus--

  • yeah, and there's the x and the y.

  • X minus one times tile size.

  • And x pos is less--

  • oh, wait.

  • Yeah, OK.

  • No, that's fine.

  • OK.

  • X pos is less than--

  • I think it should be greater than or equal to, actually.

  • Less than or equal to, maybe.

  • Maybe not.

  • Because then you'll have edges that are ambiguous.

  • But I guess that's OK.

  • Greater than or equal to, greater than or equal to, less than or equal to.

  • Blah, blah, blah.

  • So I screwed something up here.

  • We got to figure out what it is.

  • Self.ishighlighting.

  • Right.

  • OK.

  • What we should do, we should debug a little bit.

  • I'm going to do a couple of things.

  • So the first thing I'm going to do is, I'm going to go to dependencies.

  • I'm going to create a smaller version of--

  • can I do that with the start font?

  • I guess I probably can, right?

  • Start small is going to be love.graphics.newfont.

  • Fontsstart.ttf at size eight.

  • Actually, I think it said eight-pixel font already.

  • So that's good.

  • So back into our game grid, I can go over here.

  • I'm going to do love.graphics.setfont to g fonts, start small.

  • And then I'm going to set this back to just regular start.

  • So let's try that.

  • Yep, cool.

  • So that's good debug text.

  • Looks a little bit better.

  • Now after that, additionally, I'm going to do love.graphics.print.

  • And then we're going to say highlighting tile to string self.ishighlighting.

  • I'm going to see whether that works, right?

  • Does that actually work?

  • Oh, whoops.

  • That needs to be at this x and y.

  • Whoops, no.

  • Don't delete it.

  • OK.

  • Virtual height minus 36.

  • OK, OK.

  • So it's not even working.

  • So highlighting tile is equal to false.

  • OK.

  • And then just for good measure, I'm going

  • to say highlighting x to string self.highlightingtile.x.

  • And then at y to string self.highlightingtile.y.

  • Break this down into a new line.

  • Wait, where did I put that?

  • Self.highlightingtile, self.highlightingtile, oh.

  • I guess self.highlightingtile probably never got instantiated.

  • That's fine.

  • Self.highlightingtile equals x equals zero.

  • Y is equal to zero.

  • And I apologize, I'm not looking at the chart super in depth right now just

  • because I want to get this finished while we're a little low on time.

  • But I will read all of the comments after we finish this.

  • Promise.

  • Minus 24.

  • Cool.

  • OK.

  • Interesting.

  • So we are getting it but highlighting tile is not being set to true.

  • OK.

  • That's probably the issue.

  • OK.

  • Self.highlightingtile.

  • Self.ishighlighting is equal to true.

  • Wait.

  • If not highlighting something, there we go.

  • Now, the rendering isn't working but it's close, right?

  • You can see the rectangle there.

  • And I can actually probably make it a little bit brighter.

  • So let's go ahead and do that.

  • 0.4.

  • So it's a little bit brighter.

  • There we go.

  • That's cool.

  • Now, the rendering code isn't working for the rectangle.

  • So let's figure that out, too.

  • So something left offset plus self dot-- oh, right.

  • Yep.

  • Minus one times the tile size.

  • One times the tile size.

  • Cool.

  • Now as you can see, we have a visual indication of the tile

  • that we're hovering over.

  • So I apologize.

  • That was a little bit of a long amount of time

  • for a somewhat anticlimactic feature.

  • But it's pretty important.

  • It's a nice feedback to at least know, when I click on this tile right

  • here, for example, or this tile, that's going to be the tile that opens up.

  • And makes the game feel a little bit more immersive, right?

  • It's an important detail.

  • That stream altogether took a longer amount of time than--

  • I mean, I anticipated it might take up to two streams

  • to get this whole game up and running.

  • But I don't know.

  • I don't know.

  • We can definitely get this done by next stream.

  • I would have liked to see it get more finished today.

  • But we have a pretty good foundation.

  • We saw that the bombs are generating.

  • We saw that the numbers are generating.

  • It's great.

  • The next stream will be even better because we'll

  • talk about recursive algorithms.

  • We'll actually get everything solved.

  • Let me make sure that I'm committing everything first.

  • So highlighted tiles, do that.

  • Hit push.

  • We'll say next Monday will be the continuation of this.

  • I apologize we didn't get the whole game finished.

  • It's kind of a larger game.

  • And I always underestimate how much time it takes to interact with the chat.

  • But that's my favorite part of doing this.

  • So I will not compromise on that detail.

  • Let me just go back up to the chat, make sure that I read everything.

  • Ba, ba, ba, ba.

  • About the number of bomb checking, what about a double four looping

  • continuing when you're out of bounds?

  • I'm not entirely sure I understand that implementation,

  • if you want to maybe elaborate on it.

  • Oh.

  • Check out of bounds pause that takes an x and a y?

  • Sure.

  • Yeah, it's something like that.

  • A recursive way to do it?

  • Yeah, you probably don't need recursion for checking

  • just your immediate neighbors, though.

  • But yeah, recursion is how we're going to be

  • doing the actual checking for when you click a button, the actual checking

  • of that, that will be recursive.

  • But the actual instantiation of the game grid,

  • the creation of the bombs, the creation of the indices with the numbers, that

  • doesn't have to be recursive.

  • I guess it could be recursive, but there's

  • no real need for it to be recursive.

  • Oh, shoot.

  • Asley [INAUDIBLE] caught the flu.

  • I'm so sorry to hear that.

  • I know that that can be very brutal.

  • Hopefully you're staying OK.

  • It's an unfortunate timing this week if it is indeed your birthday.

  • So sorry to hear that.

  • Hope you get well soon.

  • Hope you're able to maybe at least watch this later, maybe even on Monday so

  • that you can watch both of them together,

  • the first part and the second part.

  • But thanks for tuning in to at least let us know what's going on.

  • I was very surprised to hear that you weren't joining the stream.

  • So it makes total sense now.

  • Yeah, get well soon.

  • Friday party.

  • Yeah, that's true.

  • Staypeaceful89, hey, everyone.

  • It's been a while.

  • Yeah, it has been awhile.

  • Thanks for joining.

  • It's been a long time.

  • Hope you're able to catch most of this.

  • If not, at least you'll be able to see it on YouTube after the fact.

  • Forsunlight, thank you so much as always.

  • No problem, it's my pleasure.

  • Anytime.

  • We'll do it again tomorrow and the next day.

  • Rodrigo will be joining us tomorrow for a game of 15.

  • And then David will be joining us on Friday

  • for render 50, which is a Python-based source code to PDF application, which

  • is pretty cool.

  • We use a lot for a printing source code and that sort of thing,

  • or rather, I should say for lecture and that sort of thing.

  • Push it, come on, says Bhavik.

  • Well, everything's pushed so you should now be able to see all the changes.

  • CS50 or game development?

  • CS50, didn't know we had the classes.

  • Yeah, it's hard to compete with CS50 proper.

  • But we do have a game development class that I taught,

  • which is cs50.edx.org/games.

  • You go to there, you can go to cs50.edx.org/web and you go

  • to cs50.edx.org/mobile.

  • So games I taught, Brian taught web, and then Jordan Hayashi taught the mobile

  • react native course.

  • All pretty cool courses.

  • Brian's and Jordan's are awesome.

  • Mine is OK.

  • I think I could have done a better job now than I did at the time.

  • But that was my first class, so I think all things considered,

  • I'm pretty happy with how the curriculum turned out.

  • But yeah.

  • You can always do better.

  • JPguy says, thank you for the stream.

  • My pleasure.

  • Bhavik Knight says, great stream.

  • Thanks, Bhavik.

  • I appreciate it.

  • Bellacurious, thank you very much.

  • Thank you, coltonicedream.

  • Much appreciated.

  • Empty tiles unpressed would be recursive.

  • Yes.

  • Empty tiles unpressed would be recursive.

  • That is exactly how we're going to be doing the revealing of tiles

  • in the next stream.

  • It will be a recursive algorithm where the base case is hitting a number tile

  • or a bomb, in which case, the bomb would not be revealed

  • but the number tile would be revealed.

  • NACLEric says, thanks for the stream.

  • These Lua apps inspire me to make an Ascii game.

  • Awesome.

  • Yeah, definitely share it with us if you do.

  • And mkloppenburg says, thanks once again.

  • My pleasure.

  • Appreciate it, Martin.

  • Thanks for joining us.

  • Will Nick start AI on edX?

  • That's a good question.

  • No plans at the moment.

  • But we can maybe talk about that with him.

  • Pudavedatel says, thanks, Colton, very interesting.

  • Thanks for joining and thanks for the follow.

  • Joe, don't be so hard on yourself.

  • You know, I don't see it as being hard on myself.

  • I see it as thinking I could do something a little bit better than I

  • did last time, right?

  • Always sort of being self-reflective and analytical and making better stuff,

  • I see no harm in doing that.

  • Now, saying oh, I'm terrible.

  • I suck.

  • I'm so bad, I think that's negative and that's toxic.

  • You don't want to do that.

  • And that doesn't help anybody.

  • You want to be productive with how you think

  • and how you approach solving your problems.

  • So I think those two are two separate ways of thinking and being

  • hard on yourself, you're right.

  • You don't want to do that.

  • That's bad.

  • But saying, oh, you could've been better,

  • I don't think there's anything wrong with that.

  • I think that's fine.

  • I'm not sure what language that is.

  • Mkloppenburg is speaking to JPguy.

  • Is it Dutch?

  • Since I think JPguy's from the Netherlands, right?

  • That's a good philosophy.

  • I'm only 15 and I want to become a programmer and you inspire me.

  • Oh, awesome.

  • Well, thanks for tuning in.

  • I'm glad that you enjoy the material and the content.

  • And I hope to see more of your stuff.

  • And again, I'm going to pitch it again, so bit.ly/ what was the link again?

  • I don't remember exactly offhand.

  • It was bit.ly-- that's what it was.

  • CS50twitchcodereview.

  • So go to there if you have some source code,

  • if you're a beginner or an intermediate programmer.

  • This is much more for what that is catered towards.

  • But submit your source code to us via a GitHub repo or a gist

  • and we will potentially take a look at it on the stream

  • and tell you what things we like about your style and your design

  • and what things we think might be better.

  • Right, and there's always usually room for improvement.

  • And there's certainly a lot of things that, as a beginner or intermediate,

  • it's good to reinforce good habits as much as it

  • is to point towards bad habits, right?

  • So yeah.

  • That was Minesweeper part 1.

  • So part 2, we'll do the actual recursive finding of bombs,

  • we'll do losing the game, we'll do point totals.

  • All of that stuff will be in the next Minesweeper stream next Monday.

  • So again, tomorrow's Rodrigo, Game of 15 in Python.

  • And then on, Friday David with Render 50,

  • which is another Python app for rendering PDFs.

  • And then Monday, I'll do my Minesweeper part 2.

  • And then I forget, we have a couple of other streams next week.

  • But these will all be posted on the Facebook group, CS50 Facebook group,

  • which is facebook.com/cs50.

  • Definitely follow that page so you can keep up to date with all of our events.

  • Join the CS50 Facebook group, so it's a separate page.

  • The CS50 Facebook group, I always post all of our events.

  • And follow us on Twitter, follow us on YouTube, follow us on Reddit.

  • All that fun stuff, do all of that.

  • It's all good stuff.

  • Lancemagus says, my sauce code is really bad.

  • No way I'm showing.

  • Yeah, don't feel scared to show us.

  • We would be happy to look at it and give you some feedback.

  • And I think especially if you're a beginner to intermediate,

  • I think getting feedback on how things could be better

  • is super vital to help you break habits that might

  • be really hard to unbreak later on.

  • So feel very encouraged and don't be discouraged and don't

  • be afraid of the criticism, because that is ultimately

  • how you can become a better programmer.

  • Spaghetti goes best with sauce.

  • No worries.

  • Cool.

  • Thank you, [INAUDIBLE].

  • Awesome, thank you.

  • Or I should say, you're welcome.

  • Cool.

  • All right, everybody.

  • See you tomorrow with Rodrigo.

  • Until then, enjoy the rest of your evening

  • and take a stab at the source code that we came up with today.

  • See if you can maybe implement your own features,

  • do your own version of the recursive algorithm before we do it next Monday

  • ourselves.

  • That's how you learn, ultimately, much better

  • than you would learn through copying my source code.

  • And solidfury says, peace.

  • Good to see you, solidfury.

  • All right.

  • Everybody, enjoy the rest of your day.

  • Until then, this was 650 on Twitch doing Minesweeper.

  • And I'll see you next time.

  • Bye-bye.

COLTON OGDEN: Good morning, good afternoon good evening,

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it