Learn C++ Programming By Making Games Volume 2

In depth and practical look at Object Oriented Programming

What you'll learn

Students will learn good OOP fundamentals

Students will learn some fundamentals of 2D computer graphics using SDL

Students will have created a shell app that will contain 4 games

Students will create a game like Tetris

Students will create a game like Break-out!

Students will create a game like Asteroids

Students will create a game like Pac-man

Students will learn some vector math in 2D

Requirements

Good understanding of basic C and C++ such as loops, if statements, variables, pointers, and references etc

Good understanding of your IDE and how to setup your C++ environment

No understanding of Objects or OOP will be necessary for this course

Description

An in depth practical course on OOP using C++. We learn the very basics of OOP like Classes and Objects up to more advanced topics like move semantics and lambda expressions. We then take those topics and apply them through a complex application that will contain 4 different arcade games: Tetris, Break-out!, Asteroids and Pacman. We will code 2 of those games together using the techniques we learned in the previous sections. The other 2 games will be projects for students.We'll be making this arcade app from SCRATCH (mostly), using SDL for window management, input and colour but that's it! Everything else will be hand coded by us so we can get a good understanding of what's happening underneath the hood in game engines. What we make from scratch:Drawing lines and shapesVectorsPolygon fill algorithm2D texturing2D sprite animations2D rotationsLoading bitmap filesSprite sheetsSo much more!This is an exciting course for students to take their skills to the next level through challenging problems and games. This is a HARD course, but if you stick with it (and finish all the exercises and projects), you'll not only be a better programmer than most of your peers, you'll be one step closer to getting that industry job you've been dreaming about.There’s no risk!This course comes with a full 30 day money-back guarantee. If you are not completely satisfied with the course, Udemy will refund you what you paid - no questions asked.Register for the course today!

Overview

Section 1: Raise the curtain

Lecture 1 Introduction

Lecture 2 Course overview

Lecture 3 Making things (mostly) from scratch

Lecture 4 GCC Setup

Lecture 5 Eclipse Setup

Section 2: Get to class

Lecture 6 Before we start / Something to remember

Lecture 7 Bottom up vs Top down design

Lecture 8 Classes and Objects

Lecture 9 Encapsulation - Public and Private access

Lecture 10 Data members

Lecture 11 Methods

Lecture 12 Structs Vs Classes

Lecture 13 Section 2 Practice Problems

Section 3: The particulars

Lecture 14 Constructors

Lecture 15 Initializer lists

Lecture 16 Delegating Constructors

Lecture 17 Destructors

Lecture 18 Class scope

Lecture 19 The this pointer

Lecture 20 How to have references in a class

Lecture 21 Explicit constructors

Lecture 22 Section 3 Practice Problems

Section 4: To instantiate or not to instantiate

Lecture 23 Calling methods on objects

Lecture 24 Objects within objects

Lecture 25 An array of objects

Lecture 26 Copy constructor

Lecture 27 Static keyword with classes

Lecture 28 Using const in classes

Lecture 29 Inlining methods

Lecture 30 Section 4 Practice Problems

Section 5: Hello operator my old friend….

Lecture 31 What are Operators?

Lecture 32 Operators In your classes

Lecture 33 A Vector Class

Lecture 34 Friend functions and one More Operator overload

Lecture 35 Friend classes

Lecture 36 Section 5 Practice probelms

Section 6: Let's make a thing: Nobody said there would be math…

Lecture 37 Comparing Floating point values

Lecture 38 Negating a Vector

Lecture 39 Vector multiplication by a scalar

Lecture 40 Vector Addition and Subtraction

Lecture 41 A Vector's Magnitude

Lecture 42 Unit Vectors

Lecture 43 Distance formula

Lecture 44 The Dot Product

Lecture 45 The Dot product interpretation 1 - Projection

Lecture 46 The Dot Product interpretation 2 - Trigonometry

Lecture 47 Reflecting a vector

Lecture 48 Rotating a Point

Lecture 49 Section 6 Practice Probelms

Lecture 50 Section 6 Source Code

Section 7: Dynamic Memory

Lecture 51 Dynamic Memory in classes

Lecture 52 Shallow copy vs Deep copy

Lecture 53 Operator equals

Lecture 54 Using new in constructors

Lecture 55 Cleaning up dynamic memory

Lecture 56 Pointers to objects

Lecture 57 Semi-complete DynamicIntArray

Lecture 58 Section 7 Practice Problems

Section 8: Let's make a thing: A line

Lecture 59 SDL2 Windows Setup

Lecture 60 SDL2 Mac Setup

Lecture 61 Setting up SDL 2.0 Window

Lecture 62 SDL Window Surface

Lecture 63 SDL Pixel Format

Lecture 64 The Color Class

Lecture 65 Screen Buffer Class

Lecture 66 The Screen Class

Lecture 67 Line Class

Lecture 68 Bresenham's Line Algorithm

Lecture 69 Drawing a line

Lecture 70 Section 8 Practice Problems

Lecture 71 Section 8 Source Code

Section 9: I spent your Inheritance kids

Lecture 72 Motivation: Is-A Relationships

Lecture 73 Basic Inheritance

Lecture 74 Access control: protected keyword

Lecture 75 Static and Dynamic binding

Lecture 76 Overriding methods

Lecture 77 Using base class methods

Lecture 78 Inheritance and dynamic memory

Lecture 79 Section 9 Practice Problems

Section 10: Designing with Inheritance

Lecture 80 Pure virtual functions

Lecture 81 Abstract base classes

Lecture 82 Pure virtual classes

Lecture 83 Multiple inheritance

Lecture 84 Multiple inheritance pitfalls - don't use Multiple inheritance

Lecture 85 Protected and Private Inheritance

Lecture 86 Section 10 Practice Problems

Section 11: Let's make a thing: Shapes

Lecture 87 The Shape class

Lecture 88 The Triangle class

Lecture 89 The Rectangle Class

Lecture 90 The Circle class

Lecture 91 Drawing a Triangle

Lecture 92 Drawing A Rectangle

Lecture 93 Drawing a Circle

Lecture 94 Poly Fill

Lecture 95 Alpha blending

Lecture 96 Section 11 Practice Problems

Lecture 97 Section 11 Source Code

Section 12: A detour of C++

Lecture 98 auto and decltype

Lecture 99 Static casting

Lecture 100 default and delete

Lecture 101 lamda functions

Lecture 102 std function

Lecture 103 Randomization

Lecture 104 Section 12 Practice problems

Section 13: Unstoppable force meets an immovable object

Lecture 105 L Values, R Values and R Value references

Lecture 106 R Value references

Lecture 107 Move semantics and std::move

Lecture 108 More hidden methods

Lecture 109 The Rule of 5 vs the rule of zero

Lecture 110 An example: dynamic array class revisited

Lecture 111 std unique ptr

Lecture 112 The good news is…

Lecture 113 Section 13 Practice probelms

Lecture 114 Section 13 Source Code

Section 14: Let's make a thing: Arcade app internals

Lecture 115 The base app

Lecture 116 The main loop

Lecture 117 The Scene class

Lecture 118 The Arcade Scene

Lecture 119 Scene stack

Lecture 120 Game Controller

Lecture 121 Keyboard Input

Lecture 122 Mouse Input

Lecture 123 The Game Interface and the Game Scene

Lecture 124 File Command Loader

Lecture 125 Section 14 Practice problems

Lecture 126 Section 14 Source Code

Section 15: Let's make a thing: Breakout!

Lecture 127 Overall design

Lecture 128 Excluder class

Lecture 129 Paddle class

Lecture 130 Ball class

Lecture 131 Making things bounce 1

Lecture 132 Making things bounce 2

Lecture 133 Block class

Lecture 134 Level class

Lecture 135 Loading levels

Lecture 136 Breakout game states and serving the ball

Lecture 137 Lives And Game over

Lecture 138 Section 15 Practice Problems

Lecture 139 Section 15 Source Code

Section 16: Now You Try: Tetris

Lecture 140 Tetris Requirements

Section 17: Let's make a thing: Images!

Lecture 141 The almighty BMP

Lecture 142 Drawing a BMP

Lecture 143 A sprite sheet

Lecture 144 Bitmap font

Lecture 145 Color Overlay

Lecture 146 Texture Mapping

Lecture 147 Fast path 2D rendering

Lecture 148 Section 17 Practice problems

Lecture 149 Section 17 Source Code

Section 18: Let's make a thing: The real Arcade App

Lecture 150 A button class

Lecture 151 Button options Scene

Lecture 152 Not Implemented scene

Lecture 153 Restructuring the App

Lecture 154 Section 18 Practice Problems

Lecture 155 Section 18 Source Code

Section 19: Let's make a thing: Animations

Lecture 156 Animation Data

Lecture 157 The animation Class

Lecture 158 Loading animations

Lecture 159 The Animation Player class

Lecture 160 The animated sprite class

Lecture 161 Section 19 Source Code

Section 20: Now You Try: Asteroids

Lecture 162 Asteroids Requirements

Section 21: Let's make a thing: Totally not Pac-man

Lecture 163 Pacman Start Game Scene

Lecture 164 The overall design

Lecture 165 Loading and drawing the level

Lecture 166 Pacman Game Utils

Lecture 167 The Actor Class

Lecture 168 Pacman Class

Lecture 169 Collisions

Lecture 170 Wrap around

Lecture 171 The Pellets

Lecture 172 Eating pellets and Drawing the Score

Lecture 173 Pacman Spawn location

Lecture 174 Levels

Lecture 175 Bonus items

Lecture 176 Lives

Lecture 177 Ghost Class

Lecture 178 Getting Ghosts in the game

Lecture 179 Ghost collisions

Lecture 180 Ghost AI

Lecture 181 Ghosts AI states

Lecture 182 The Gate

Lecture 183 Ghost Delegate

Lecture 184 Release the Ghosts!

Lecture 185 Game States

Lecture 186 Super pellet

Lecture 187 Game Over

Lecture 188 Full Course Source Code

Section 22: Wrapping up

Lecture 189 Final thoughts and what's next?

Anyone who is interested in learning more about C++ and making games,Students with a good understanding of C++ basics: Loops, control flow, functions, pointers