Heads up!Module 10 is expected to have 12 lessons. So it's not over yet!We will be releasing lessons gradually, one at a time. This allows us to push lessons out to you more frequently and iterate faster on your feedback.As always throughout Early Access, things are not set in stone. We may still go back and make changes to improve the learning experience. This is especially true of this challenge-driven module, which is a format rarely offered by online courses.If you prefer to wait until the complete module is released with all the lessons, keep an eye/ear out for the usual announcement. You can subscribe to course updates by clicking the button in the Stay Tuned section, or join our discord server.
Nathan
Founder and teacher at GDQuest
You went through a dense journey, learning a wide range of programming concepts and techniques that form the foundation of game programming. It's now time to review and put everything to the test.In this module, you will create a twin-stick shooter game demo through a series of structured challenges.
This project is specifically designed to you apply every major concept and technique you've learned in the course so far and to test yourself. It features:
A playable character that can move and look in different directions
Weapons that can shoot magical bullets
Enemies that shoot at the player or follow and attack them
Collectibles that increase the player's gems, health, or equip different weapons
A simple UI that displays the player's health, gems, and equipped weapon
A Non-Playable Character (NPC) you can speak to to trigger a dialogue
A pause screen that appears when pausing the game
A game over screen that appears when the player dies
The project comes in two flavors, a standard version and an extended challenge version:
The standard version is designed to review, validate, and combine many techniques you learned, without adding too much complexity.
The extended version picks up where the standard version ends and adds many optional challenges to push your skills further by fleshing out and refining the game demo. In this version, you will get to add more content and mechanics to the game, like an NPC you can talk to, multiple weapons, items, and more. This variant is more challenging and time-consuming.
This is what the completed standard version looks like:
You'll implement features you can find in many games, be it adventure, action, or RPG, in a way that can scale to small commercial indie game projects. While it looks very different from previous projects, much of the code you'll write will feel familiar.
First of all, a large game project is a different beast depending on the project and team's size.Large projects are generally done in teams with different roles, and much of the code complexity required is for handling collaboration. The resulting code structure can be generic or built to provide failproof tools for teammates to integrate content into the game without coding. This kind of code comes at a cost in terms of clarity and maintainability and weighs down smaller projects.So, a huge project's requirements are likely irrelevant to anything you'll create anytime soon. Learning that now could be counterproductive for your own projects. Once you work with a team, walking that path will be much easier and achievable with the experience you've gained from smaller projects.
What you'll learn
We'll use this opportunity to learn new techniques that tie fundamentals together. You will learn how to:
Decide on the implementation order of features in a game project and break them down into code requirements
Organize the files in a Godot project
Use a scene and a resource to create composable items and make your game more scalable
Create weapons that shoot bullets
Make weapons usable by both the player and enemies
Export the game and share it with friends
Actually, you already know how to do much of this:
You can use an Area2D that moves for a bullet, just like the area you attached to the bouncer in M9
You can use a Resource to make an item customizable, as you did in M8 with the dialogue system
And so on. Much of what you will learn are remixes and new applications of techniques you already know.This is an essential leap in your journey: shifting from primarily following along to taking the driver's seat. This is where you go from learning to gaining field experience, which will make every future project more approachable. Don't worry, though: I will help you along the way with hints, troubleshooting points
The little issues
On a larger project like this one that you're building yourself, you're going to encounter many small issues that arise from the details of how you code each mechanic. This is completely normal and affects every game developer and every project.By now, you've experienced this in practices or when following lessons: a slight change in the code or node structure can make the difference between mechanics working as desired (or at all).As you learned in M5 and M7, when you hit a limitation with your code, you can always refactor it. Making a polished game takes many iterations, time, and experience.
, and checkpoints.In this module, you'll code a complete game demo from scratch, putting your skills to the test by writing all the code yourself. Along the way, you'll review and reuse the techniques you've learned throughout the course.
And yes, this module includes its share of new techniques! Every lesson is structured like this:
We start with an overview of the challenges ahead
We explain a new concept or technique that ties together multiple concepts you learned throughout the course
You apply both past knowledge and new knowledge to solve a series of challenges
We provide a list of questions and answers and troubleshooting points to help you along the way
The lesson ends with a reference you should not copy but that you can use to compare your code against
NOTE:
You should expect to do some research and revisit older lessons to help you solve the challenges. This is a normal part of coding. I will also link to lessons and complementary resources where relevant.
While essential to cement your learning and get out of tutorial hell, this kind of project is something you rarely find in online courses. We have past experience and gathered extensive feedback from this course's predecessor, as well as from working with schools.Still, tuning the difficulty curve for this module is a challenge for us too. Each person taking this course has different experiences, skills, strengths, preferences, and expectations. Some of you feel most at home with math and the more technical aspects of coding, while others thrive with design and coding movement and interactions.If the module is challenging, that's completely normal. You must challenge yourself and push beyond your comfort zone to learn to code independently. Hopefully, the bite-sized challenges scattered throughout previous modules helped prepare you for this.However, if a mandatory part is too complicated and you're feeling lost despite the hints and linked resources, please let us know! First, we are here to help and answer your questions. Second, we'll use your feedback to make improvements for you and everyone else.Don't hesitate to help each other, too!
Nathan
Founder and teacher at GDQuest
The journey continues beyond this module
This project isn't the end of the journey; it's just a significant milestone. You've learned the fundamentals of 2D gamedev (and gamedev in general). You're now equipped to learn specifics or shift focus to 3D if that's what you want to do.After a single run through the course, if you learned to code from zero with us, you'll have an overview and mental map of concepts. This course is very dense, and believe it or not, you've already gone through 1000 pages of textbook material (props to you for the dedication)!It takes lots of repetition and practice to commit this knowledge to long-term memory. That's why we mentioned in the introduction that this course is meant to be done again
New game plus
You don't have to do a second run immediately: this is a living course taught in schools that we will continue to update with new releases of Godot 4. You can revisit it anytime in Godot 4's lifecycle to reactivate your memory, learn new features, or deepen your understanding.
.Actually, it's worth going through any good textbook more than once. You can extract much more value on a second run because you approach it with a new perspective and better understanding of the technology, allowing you to focus more on fundamentals and less on specific syntax and API details.If you've learned a foreign language before, it's a similar process: a language course can give you the foundations to start reading and communicating without getting discouraged or overwhelmed.From there, you can fly independently and learn vocabulary and idioms much faster through real-life communication. That's where this course aims to take you.
I hope you're ready. Brace yourself as you're in for an exciting ride! Everything you learned so far has led to this point.We'll get started in the next lesson by planning the game and breaking it down into manageable parts. See you there!
Use this space for questions related to what you're learning. For any other type of support (website, learning platform, payments, etc...) please get in touch using the contact form.
Question about constructors?EasySpeeds```gdscript
class_name CannonBallSpawner
extends Marker2D
const CANNON_BALL := preload("res://scenes/cannon_ball/cannon_ball.tscn")
const SMOKE_PARTICLES := preload("res://scenes/cannon_ball/smoke_particles.tscn")
func fire():
var smoke = SMOKE_PARTICLES.instantiate()
smoke.lifetime = randf_range(0.5, 0.7)
smoke.emitting = true
add_child(smoke)
var cannon_ball = CANNON_BALL.instantiate()
cannon_ball.global_rotation = global_rotation
cannon_ball.global_position = global_position
add_child(cannon_ball)
```
I am using this to make a cannon ball spawn at the marker2d's position / rotation. I would like to customize the distance that the cannonball can travel based on how long the player holds the button. I assumed that passing a max_distance argument in the .instantiate() and overwriting the ._init() function would accomplish this.10Nov. 12, 2024
Lesson Q&A
Use this space for questions related to what you're learning. For any other type of support (website, learning platform, payments, etc...) please get in touch using the contact form.