You will learn about what we will develop and why we will be developing it.
This course is all about becoming very proficient in game development and we introduce you here to what we will be developing.

Here we will go over some assumptions that we make about the knowledge expected from the student. This is an intermediate course so some knowledge of Flutter and Dart and the Flame Engine is expected.

We will also cover the approach to how we will break down the development process.

Being able to Reverse-Engineer game concepts into actual architecture and then code is crucial to being a great game developer.

This lecture explains why that is the case and why this is an important skill.

In this lecture we will discuss the game development cycle and how to approach game development in the most efficient manner.

A simple exercise for the student to get into the thick of things. Here we begin to document the game mechanics of the game we will be developing.

Solution to our first exercise.

We will discuss mapping out the game elements and their mechanics in this intro into a number of steps before we architect our solution.

Delving deeper into the Dino Jumping and Ducking details

Delving deeper into the game obstacle generation.

Delving deeper into the game parallax generation. We will especially see the synergy between clouds, stars, and moon phases for the background parallax.

Delving deeper into the speed logic of the game

Delving deeper into the logic behind the collision detection.

Delving deeper into the game scoring mechanism and how it ties into the speed of the game as well as time elapsed.

Delving a bit deeper into sound FXs in the game. The sound logic for the game is rather trivial in the dino game with only three sounds to be used.

Delving deeper into how the horizon is generated in the game and how it affects other elements in the game.

We will discuss the development strategy and how to prioritize our approach to design and development of the game.

Exercise for the student which will focus on documenting game elements.

NOTE: The template document has been attached with this lecture.

Solution to Exercise #2 with a sample document.

NOTE: The solution document has been attached with this lecture.

We will establish in the lecture what the most important code elements of the game are as a priority for development.

In this lecture we will abstract a high-level Modular Architecture of the full solution.

The student will be shown what to review and research in the Flame Engine for the game development

In this lecture we will break down what we will accomplish in Milestone #1
Basically we will cover the following:

1. Creating the Shell of the Game so we can run it in the Flutter/Flame Environment

2. Creation of the Game Manager class which will coordinate all other components in the game

3. Creation of the initial TRex/Dino player with the ability to Jump

In this lecture we code all the elements shown below for Milestone #1
Basically we will cover the following:

1. Creating the Shell of the Game so we can run it in the Flutter/Flame Environment

2. Creation of the Game Manager class which will coordinate all other components in the game

3. Creation of the initial TRex/Dino player with the ability to Jump

NOTE:  The source code for Milestone #1 is attached with this lecture as a zipped file of .dart files as well as assets and pubspec.yaml file.

In this lecture we will look at some more detail of the Player class, especially concentrating on how Sprite Animation and State Switching is achieved.

In this exercise the student will take the shell code that we developed in our coding section for Milestone #1 and will add some new functionality for the Dino:

1. The ability to duck with all the animation

2. The zoned-distinction for the tapping in the left half of the screen for ducking and the right half of screen for jumping.
   

This is a solution to Exercise #3

NOTE: The Source Code for the solution has been attached to thsi lecture so you can just look at that.
If you need an explanation then this video lecture explain a bit more about the approach and how it was developed.

In this lecture we will break down what we will accomplish in Milestone #2
Basically we will cover the following:

1. The Horizon Manager which will add smooth infinite horizon-line animation with images from the Asset PNG

2. We will also add the speed generation functionality to the Game Manager.

We will look at the code that we will use in the Horizon Animation as a strategy.
We will abstract out an algoirithm for cycling through horizon snippets to create our own revolving parallax effect.

In this lecture we code all the elements shown below for Milestone #2
Basically we will cover the following:

1. The Horizon Manager with proper animation that speeds up with passage of time

2. Speed generation in Game Manager

NOTE:  The source code for Milestone #2 is attached with this lecture as a zipped file of .dart files as well as assets and pubspec.yaml file.
This code builds upon Milestone #1 but does not include any of the exercise changes.

In this exercise the student will take the HorizonManager code that we developed in Milestone #2 and we will modify/add some new functionality:

1. Explore the horizion generation algorithm to create a more randomized horizon generation

2. Add a debug text om the screen to show how the speed is changing.

In this lecture we will break down what we will accomplish in Milestone #3
Basically we will cover the following:

1. The Cloud Manager which will add variable (i.e. randomly generated) cloud Parallax Generation with images from the Asset PNG

2. We will also create our own randomizer.

We will look at the main code elements that we will use in the Cloud Animation as a strategy.
We will abstract out an algorithm for randomizing and animating cloud images to create our own revolving parallax effect.

In this exercise the student will take the CloudManager and Cloud code that we developed in our coding section for Milestone #3 and will modify/add/fix some new functionality:

1. You will investigate what the absolutePosition variable is doing when computing the cloud location.

2. You will also look at an issue with z-order for the clouds and other elements in the code.

3. You will add a whole new StarManager and Star classes to add stars to the parallax of the game

In this lecture the student will see how we will keep track of the game score and how we will display it on the screen. We will also get some hints about the high score for the user which will be part of the section exercise.

In this code session we will add the score management (tracking and displaying) code to our game

NOTE: The source code for Milestone #4 is attached with this lecture as a zipped file of .dart files as well as assets and pubspec.yaml file.

This code builds upon Milestone #3 but does not include any of the exercise changes.

in this exercise you will add permament High score to the game

In this lecture we will introduce the concepts necessary for obstacle generation such as:

1. Randomization of obstacle generation

2. Grouping of obstacles to create more complex obstacles

3. Calculating the gap between obstacles so that the game does not become impossible to play

4. Controlling the timing of obstacle generation.

NOTE: we are not going to manage collision detection yet as this is an independent action that is not reliant on obstacle generation algorithm.

In this lecture we will look at the main points of the algorithm for Obstacle Generation.

1. We will create first a pseudocode version of the code

2. We will also abstract the main variables that will drive our algorithm.

In this code session we will add the obstacle generation to our code. This is an initial simplified version that we can later enhance.

NOTE: The source code for Milestone #5 is attached with this lecture as a zipped file of .dart files as well as assets and pubspec.yaml file.

This code builds upon Milestone #4 but does not include any of the exercise changes.

In preparation for collision detection we want to student to try adding collision detection themselves as well as thinking about how to end the game and allow the user to restart it.

In this lecture we will introduce the concepts needed to provide collision detection in our game:

1. How do we add HitBoxes to the Player and Obstacle classes

2. What needs to be done to wire the collision in the Flame Engine

3. We will discuss what needs to be done to detect and process the collision.

NOTE: we are not going to yet manage the proper game termination. We will add this towards the end of this section.

In this code session we will add the collision detection to our code. This is an initial simplified version that we can later enhance with proper game over/restart logic

NOTE: The source code for Milestone #6 is attached with this lecture as a zipped file of .dart files as well as assets and pubspec.yaml file.

This code builds upon Milestone #5 but does not include any of the exercise changes.

In this exercise the student will make the hit-boxes (and thus the collision areas) more accurate by combining smaller hit-box areas. Additionally the student will document the architecture of the game so far with a high level UML diagram

In this section we will tie all the loose ends together:

1. In this video we will primarily look at how to properly adding a Game Over Component as an overlay to our already existing game.

2. We will look at the High Score solution directly in code (in the next lecture)
   

In this lecture we will code all the outstanding elements for the game:

1. Game Over Management

2. HIGH score display and persistence

NOTE: The source code for Milestone #7 is attached with this lecture as a zipped file of .dart files as well as assets and pubspec.yaml file.

This code builds upon Milestone #6 but does not include any of the exercise changes.

In this end-of-source project the student will accomplish the following:

1. Add zone-tapping to allow the player to both jump and duck in the mobile version of the game

2. Lower the horizon so that there is more real-estate to allow Dino to Jump higher.

3. Improve Collision Detection with better hit-box definition.

4. Add the animated pterodactyl sprite as a new obstacle

5. Add two different heights to the Dino jumping based on the time-length of the tap

6. Add more complexity to the cactus-generated obstacles.

7. Add other background parallax elements such as

   1. Stars

   2. Moon phases

8. EXTRA: Explore Adding sound to the game

Thank you for taking the course. Here are some final thoughts about what to do next in your journey to become a better game developer.