Overview of the Develop With Passion® - Gamecrash Bootcamp
The course aims to turn a developer into a games developer in one week. We will cover all necessary content for basic and intermediate 2D games development, and students will develop a game during the course.
Our main focus in the course is two-fold: fundamentals, so that the students learn the proper concepts to build games, and practice, so that they are immediately applied.
The language used will be “C without pointers”, a subset of C that is easy to pick up since we remove the worst obstacle. No previous C/C++ experience is necessary. Programming experience, though, is necessary, be it in Java, .NET, Python, Ruby, PHP, or some other language. We will teach the necessary C-specific things for the course, which will be kept to a minimum. Having good knowledge of programming (statements, conditions, loops, variables…) is the only prerequisite, together with a great motivation to learn to write games!
What you should understand
We will provide a sample program that the student should read and understand easily, in a way that they could modify it easily. This is a basic self-test to evaluate whether the student has the necessary knowledge to take the Gamecrash course.
We will provide the students with some material they should work on before the course: basic C and some geometry.
Prepare Your Computer
Students have to bring their Mac or Windows laptop to the course. We will send them a package at least two weeks before the course so that they can set up their computer with the needed development tools (all free), and make sure their laptop is ok to follow the course. This way no time will be lost in the course.
Prepare Your Game Concept
We will encourage students to think of a 2D game concept, and prepare ideas, graphics, music and sound effects before the course. If they bring them to the course, they will be able to start building the game right way. That way, it will be more personal and exciting to apply all the content learned!
Be sure to prepare character graphics with a transparent background so that they can be used over background graphics. Character animations can also be used (two or more frames for an action). Bitmap sizes should be power of two (pad the borders if necessary).
In any case we will supply stock graphics, etc… so that everyone can also build a game during the course.
Day 1 (Intro: Game Loop & Graphics): (Total 12h30min)
Intro (30 min)
A short intro to introduce everyone and get acquainted before the course.
Basic C (1 hour)
A quick review of the basic C elements that will be used in the course: functions, variables, int/float types, enums, arrays, structs. Students should have worked on this before the course, using the provided materials.
Basic 1-D game (3 hours)
Everyone will write a simple text-mode game in 1-D, to learn the basic concepts of a game loop, user input and interaction, etc… in a way that doesn’t get complicated with graphics, APIs, etc… it will be written in a single module, in the simplest possible form.
Colors, bitmaps, framebuffers, triangles (1 hour)
We will provide an explanation of how colors are stored, how bitmaps are built out of colors, and how this forms the base paradigm for graphics cards and rendering. Also, we will cover how nowadays cards base all their work in triangles.
OpenGL (2 hours)
We will explain what OpenGL is, and how it can be used. We will write a first basic OpenGL app that creates an OpenGL window and paints something basic to it such as a 3-color triangle.
Using bitmaps and textures (3 hours)
We will learn to load a bitmap from a file, and how to use it as an OpenGL texture to paint rectangles with this. With this, we will be able to display 2D sprites on the programs from here on.
Simulation with squares, velocity (2 hours)
The goal in this section is to build an animated simulation, non-interactive, using OpenGL, with several rectangles of different colors moving around on-screen and bouncing off screen borders. There will be a main loop as in the first exercise in the day, although with no, or minimal, user interaction.
Day 2 (Geometry, physics, input & side-perspective game): (Total 12h)
Basic vector math (2 hours)
Basics of coordinates, vectors, vector addition, distance between points, vector normalization, and simple 90º angle algebraic rotation, necessary for collisions.
Geometry: intersection between balls (1 hour)
We will see how we can detect collisions between elements of different shapes, and how we can process that.
Simulation with spheres, collisions (1 hour)
We will build a demo similar to the previous one, using balls instead of rectangles, and checking collisions between them, so that they can bounce off each other.
Newtonian physics (2 hours)
In this part we will see how Newtonian physics can be simulated to get realistic effects like inertia, forces, friction, etc… thus creating a more enjoyable experience. We will prepare a simulation using bitmaps and basic Newtonian physics, without collisions (“seen from above”).
Gravity (1 hour)
We will see how we can use simulated gravity via Newtonian physics for side-perspective 2D-games. We will see how gravity works. We will create an example of a simulation where the different elements are subject to gravity, and where you can trigger elements to move around with some simple interaction.
Physics: collision resolution (1 hour)
Dot product. Solving elastic/inelastic collisions, conservation of momentum and energy. 1D / 2D.
Collisions (1 hour)
Complete the previous simulation with proper collision resolution.
Sound (1 hour)
We will learn how to play simple sound effects, and add them to the moving around simulation. This will start to create an attractive game experience.
Input + moving + jumping + animations (2 hours)
We will see how we can simulate moving around and jumping inside a physical simulation. Character control, collision detection to simulate “being on the floor”… We will create an example of a playable demo where you control one element or character which can move and jump around among other elements. This will already feel like a small game.
Day 3 (Geometry, AI, UI, and top-perspective games): (Total 13h)
Angles and rotations, transformation matrices (1 hour)
We will learn a solid base of the trigonometry required for rotations (angles, cosine, sine, 2x2 matrix multiplication). This way, students will be able to calculate the rotated coordinates of elements. With this, they will be able to rotate objects and paint them rotated.
Top-perspective games (2 hours)
We will build a basic top-perspective demo game using rotations, with simple interactions. Using a spaceship for simple rotational control.
Dynamic entities, shooting (2 hours)
We will start using dynamic entities to create mines and bullets, destroy mines, generate explosions, etc… this logic is key to programming a dynamic game world.
OpenGL tranformation matrix stacks (1 hour)
Using OpenGL’s transformation pipeline for rotation, translation and scaling.
Animations (1 hour)
More advanced animation management will be added to the demo game, so that characters can have properly sequenced animations for their actions (walking…).
Character, enemies, behaviour, AI, state-machines (2 hours)
We will learn the basis to give characters in the game complex behaviors, based on state machines, plans, and similar techniques. Basic pathfinding. We will build a demo game using state-machines for complex behavior.
Clicking and UI, buttons, window system (2 hours)
We will learn how to detect and process both mouse clicks and keypresses, and how to manage this. We will see how to create buttons and a simple window-system to process events from the UI (modes, cursors…).
Graphics effects: particle system (2 hours)
We will do some simple graphics effects so that our games can provide richer feedback to the user: some simple particle systems, so that we can use them for fire, smoke, dust, explosions…
Day 4 (Grid-based games, side platformer, game !polish): (Total 11 hours)
World model: boards, grids, sectors, maps... (1 hour)
We will review different possible “world models” for a game. We’ve used a free-form model for all the exercises so far, but we will be covering the possibility of having a board or grid, or some sort of sectors- or graph-based map.
Tile-based world drawing (2 hours)
We will show how a map can be built & rendered using a tileset. Scrolling around
Music (1 hour)
We will add background music playing. Simply, without streaming/decompression.
Fonts (1 hour)
We will learn how to draw text by importing a font and using it, somewhat similar to the tiles in the tile-based world.
Side-scrolling platformer game (3 hours)
We will put everything together in a quasi-complete game showing all the concepts. Physics, tile-based map, enemies, coins… New concepts: collisions with the map.
Final game polish (3 hours)
We will spend several hours adding all the main final elements, to make sure it feels like a complete game. This will include several theoretical explanations:
Game modes & progression
We will add game-modes support, so that we can have a main menu, start- and end-of-level screens, success/failure modes, etc… each of them with distinctive graphics elements, interaction, and music.
Graphics effects: parallax layers
Theory and math behind background parallax layers for scrolling.
Day 5 (Advanced concepts, pathfinding, AI, levels): (Total 10 hours)
Sample top-perspective grid game (castle) (2 hours)
We will prepare a new game type with top perspective, based somewhat on yesterday’s platformer game, but adapting it to top perspective (no gravity, etc…). We will add specific things such as: doors,
Pathfinding (1 hour)
We will review superficially how path finding algorithms work, such as A* search algorithm in a grid, and how to use this both in character movement and in enemy movement.
Character/enemy behaviour with pathfinding (1 hour)
We will implement pathfinding in the game, and we will add a mechanism to use it by the player (mouse control), and by enemies
State-machine AI for enemies (2 hours)
We will learn how to configure enemies in a level to behave with some sophistication: patrolling around, line-of-sight, attacking/pursuing the character, shooting.
Level scripting and global conditions (2 hours)
We will learn how global conditions, triggers, events and actions can be added to level design, in order to control the user experience and progress of gameplay. We will create two levels using these kinds of features in the top-perspective game.
Level editor (30 minutes)
We will explain the basics of implementing a level editor.
Turn-based and board games (30 minutes)
We will review how to implement a simple turn-based game based on a board, so that students learn how this can be done based on all the previous concepts.
Freeform games (30 minutes)
We will see how to implement different types of games which are not based in a game world and characters, such as Dance Dance Revolution, Tetris, and possibly other ones.
Wrap-up (30 minutes)
Summary and wrap-up of what we’ve seen, possible avenues on which to continue learning and experimenting, suggestion on how to go on to the main two goals students will probably want to take: mobile games and 3D games.
Upon registration, students will be provided a link to a setup page that includes an overview of machine setup requirements and a detailed walkthrough of how to their machine ready for the course. Along with machine setup instructions, this resource will also include a list of pre-course study materials that will be expected to be completed.
What is included with the price of the course?
- Five days of coding madness (4 - 12+ hours days, 1 - 10+ hour day)
- Lunch, and Supper
- All code artifacts generated throughout the course of the week
This is a very intense week. Your mind will not have very much in the way of downtime. Come expecting to have your mind challenged, but to also have a lot of fun!!
If you feel you might be interested in getting your game on then check out the upcoming course calendar
Are you ready to Develop With Passion®?