Flash for 2D Game Development (the Basics)

Topics Covered

Programming Basics: How to Make a Video Game

The basics
Programming
What kind of games can you make?
New terminology
Laying the foundation
Game files you'll need
Setting up the work environment
The Flash Developer workspace
Setting up the ActionScript code format preferences
Writing your first gaming program
Using the constructor method
Aligning code
ActionScript directives
Importing and extending the MovieClip class
Adding comments to your code
Publishing the SWF file
Using the Project Panel
Naming conventions

Making Objects

Understanding Interactive Objects
Setting up the work environment
Creating the first page
Drawing the first page
Drawing the background
Organizing layers and the timeline
Drawing the foreground objects
Creating a hill
Making some water
Grouping objects
Adding some clouds
Creating some flowers
Learning more techniques
Creating a character
Adding some more pages
Using buttons
Creating a button symbol
Understanding button states
Creating the Over state
Creating the Down state
Duplicating the button
Organizing the Library
Adding the buttons to your scene

Programming Objects

Displaying the first page of the storybook
Variables and Variable types
Creating empty boxes
Creating an instance
Displaying the instance on the stage
Programming buttons
Using dot notation
Invoking methods
Using method calls
Using function definitions
Creating method arguments and parameters
Using multiple arguments and parameters
Understanding events and event listeners
Importing an event class
Adding an event listener
Using the event handler
Understanding other events
Programming storybook buttons
Looking at the onHillButtonClick event handler
Using the onPondButtonClick event handler
Adding back buttons
Knowing when to use the model

Controlling Movie Clip Objects

Movie Clip properties
Setting up the project files
Understanding x and y positions of objects
Moving incrementally
Tracing the output
Using increment and decrement operators
Limiting movement
Making instances bigger and smaller
Visibility
More properties

Controlling Movie Clip timelines

Using the timeline as a state machine

Decision Making

Setting up the project files
Designing a GUI
Inputting and outputting
Adding dynamic text fields
Creating dynamic text
Adding input text
More about fonts and text fields
Adding a button
Building a simple guessing game
Setting up the Main.as file
Learning more about variables
Making it more obvious
Making decisions
Displaying the game status
Using postfix operators to change variable values by 1
Controlling strings
Why use the gameStatus variable
Using UINT vs. INT variables
Winning and losing
Modular programming with methods
Using random numbers
Disabling the Guess button
Playing again
The final code
Tracking guesses
Adding a visual display
Entering numbers with the Enter key
Turning the tables

Controlling a Player Character

Setting up the project files
Controlling a player character with the keyboard
Creating a player character
Adding keyboard control code
Controlling the keyboard
Moving with velocity
Using the new onKeyDown event handler
Using the onKeyUp event handler
Using the onEnterFrame event handler
Setting screen boundaries
Blocking movement at the stage edges
Building a better pigpen
Screen wrapping
Scrolling
Creating an environment
Fine-tuning the player character
Adding a drop shadow
Scrolling basics
Better scrolling
Parallax scrolling

Bumping into Things

Setting up the project files
Using hitTestObject
Changing a dynamic text field
Triggering a change of state
Reducing a health meter
Using scaleX to scale the meter based on a percentage
Updating a score
Picking up and dropping objects
Disadvantages of using hitTestObject
Detecting collisions with the bounding box
Creating subobjects
Using hitTestPoint
Using hitTestPoint to create an environmental boundary
Creating objects that block movement
Working wilth axis-based collision detection
Programming with the Collision class
Using static methods
Using the method parameters
Using the Collision.block method
Pushing objects
Detecting bitmap collisions

Object-Oriented Game Design

Introducing object-oriented programming
Binding classes to symbols
Using properties and methods
Private properties and methods
Using an underscore character to highlight private properties
Communicating between classes using getters and setters
Using getters
Using setters
Getting started with the object-oriented approach

Case study: Dungeon Maze Adventure
Setting up the game
Gathering project filles and objects
Ente rilng the dunge on!
Laying out the level
The objects in the game
Animating with the timeline
Creating the enemies
Animating the object
EnemyTwo
Controlling timeline animations with code
Adding and removing objects from the stage
ADDED TO STAGE event
REMOVED FROM STAGE event
How Dungeon Maze Adventure works
DungeonOne_Manager class
Moving the player
Picking up the key
Opening the first door
Adding sound to the game
Creating the Sound and SoundChannel objects
Colliding with the enemies
Losing the game
Picking up the star weapon
Firing bullets
Using bullet objects
Bullets vs. enemy collisions
Player vs wall collisions
Synchronizing ENTER_FRAME events
Winning the game
Modifying the game
Adding a new level
The problem of dependency
Creating a game manager
Firing bullets in four directions
Accessing the stage outside of the document class
Removing objects from the game

Platform Game: Physics and Data Management

Natural motion using physics
Setting up the project files
Acceleration
Player_Acceleration class
Friction
Bouncing
Gravity
Jumping
Stage boundaries and subobjects
Case study: Bug Catcher
Setting up the project files
Using the Player Platform class
Constants
Player friction
Bounce variables
Player collision area
Adding Platforms
Beveling
Tinting
Detecting platform collisions
Using for loops
Looping through platforms
Finding the global x and y position of a subobject
Rotating toward an object
Rotating the frog's eyes toward the player object
Changing the stacking order
Adding some bugs to the code-literally
Dynamic instance variables
Multiple objects sharing one event handler
Making the bugs move
Artificial intelligence
Using arrays
Pushing elements into an array
Looping arrays
Searching arrays
Collecting bugs
Winning and losing conditions
Complete Main.BugCatcher class
New Collision.playerAndPlatform utility
player.And Platform method
Platform bounce and friction
Detecting the top of the platform

Advanced Object and Character Control

Dragging and dropping objects
Dragging and dropping the procedural way
Using target or currentTarget properties
Using dropTarget
Snapping the object to the target
Centering the drag object to the mouse
Confining the drag area
Dragging and dropping the object-oriented way
DragableObject class
Releasing the mouse outside the stage area
Main.DragAndDrop class
Easing
An alternative to Inheritance: Composition
Moving objects with the mouse
Fixing an object to the mouse's position
Adding a dynamic filter
Moving an object with easing
Following the mouse with a bit of delay
Easing: advanced
Properties and methods of the Tween class
Easing package classes and methods
Tween events
Easing to random positions and calculating velocity
Calculating velocity
Implementing a chase feature
Case study: Complex mouse-driven player control
Player.as􀀗
Moving the player
Rotating the wand
Firing bullets in 360 degrees
Bullet.as
Using a bevel filter
Bullet factory: Using switch
Object factories
Product classes
Factory class
Client class
Enemy AI systems
Following the player
The root property
Moving the object
Running away from the player
Rotating and shooting toward the player
Timer and TimerEvent classes
Using a timer to fire bullets
Shooting at random intervals
Using other player control systems
Dispatching events
Event "bubbling"
Case study: Space Shooter
Game structure
Creating bullets
Checking for bullet collisions with objects
Removing bullets at the stage boundaries
Classes and events

 

Required Textbook

Foundation Game Design With Flash

by Rex Van der Spuy

Friends of Ed

 

www.friendsofed.com