Make a game like Lumines with Flash – part 2

Read all posts about "" game

In the first part we managed to move and rotate a 2×2 square made (obviously) by 4 bricks.

Now we’ll see how to make them fall when we press SPACE key.

Notice that you move and rotate blocks by tapping arrow keys, but you make them fall by pressing SPACE.

This because timing is essential, and we want to make blocks fall as the player touches the spacebar.

The code does not have anything difficult, I just have to check if there are empty spaces under falling bricks.

No “game over” check at the moment, it will be covered later.

// declaring some setup variables
// number of horizontal cells
grid_width = 16;
// number of vertical cells
grid_height = 10;
// size of the cell
tile_size = 30;
// offset in pixels fron the left side of the stage
x_offset = 10;
// offset in pixels from the top side of the stage
y_offset = 10;
// number of different colors that can be displayed in a brick
different_colors = 3;
// boolean values saying if I should wait for the left (or right, up...) key to be released
// this is used to make the player move bricks tapping arrow keys instead of just pressing them
wait_left = false;
wait_right = false;
wait_up = false;
wait_down = false;
// flag indicating if blocks are falling
falling = false;
// array containing the game field data
field = new Array();
// array containing the bricks I can move
moveable_bricks = new Array();
// initializing and drawing the play field
for (x=0; x variable
		if (Key.isDown(Key.LEFT)) {
			wait_left = true;
		} else {
			if (wait_left) {
				// if the left key has been tapped, move the four bricks on the left
				for (x=0; x<4; x++) {
					// this "if" is used to determine if the bricks are still inside the game field
					if ((_root["brick_"+moveable_bricks[x]]._x-x_offset)/tile_size-_root["brick_"+moveable_bricks[x]].pos%2>0) {
						_root["brick_"+moveable_bricks[x]]._x -= tile_size;
					}
				}
				// reset variable, now I must wait again for a key to be pressed
				wait_left = false;
			}
		}
		// same routine for the right key
		if (Key.isDown(Key.RIGHT)) {
			wait_right = true;
		} else {
			if (wait_right) {
				for (x=0; x<4; x++) {
					if ((_root["brick_"+moveable_bricks[x]]._x-x_offset)/tile_size-_root["brick_"+moveable_bricks[x]].pos%2<14) {
						_root["brick_"+moveable_bricks[x]]._x += tile_size;
					}
				}
				wait_right = false;
			}
		}
		// when the DOWN arrow is pressed, I must rotate the bricks clockwise
		// block 0: moves to the right and becomes block 1
		// block 1: moves down and becomes block 3
		// block 2: moves up and becomes block 0
		// block 3: moves to the left and becomes block 2
		if (Key.isDown(Key.DOWN)) {
			wait_down = true;
		} else {
			if (wait_down) {
				for (x=0; x<4; x++) {
					switch (_root["brick_"+moveable_bricks[x]].pos) {
					case 0 :
						_root["brick_"+moveable_bricks[x]].pos = 1;
						_root["brick_"+moveable_bricks[x]]._x += tile_size;
						break;
					case 1 :
						_root["brick_"+moveable_bricks[x]].pos = 3;
						_root["brick_"+moveable_bricks[x]]._y += tile_size;
						break;
					case 2 :
						_root["brick_"+moveable_bricks[x]].pos = 0;
						_root["brick_"+moveable_bricks[x]]._y -= tile_size;
						break;
					case 3 :
						_root["brick_"+moveable_bricks[x]].pos = 2;
						_root["brick_"+moveable_bricks[x]]._x -= tile_size;
						break;
					}
				}
				wait_down = false;
			}
		}
		// when the UP arrow is pressed, I must rotate the bricks counter-clockwise
		// block 0: moves down the right and becomes block 2
		// block 1: moves to the left and becomes block 0
		// block 2: moves to the right and becomes block 3
		// block 3: moves up and becomes block 1
		if (Key.isDown(Key.UP)) {
			wait_up = true;
		} else {
			if (wait_up) {
				for (x=0; x<4; x++) {
					switch (_root["brick_"+moveable_bricks[x]].pos) {
					case 0 :
						_root["brick_"+moveable_bricks[x]].pos = 2;
						_root["brick_"+moveable_bricks[x]]._y += tile_size;
						break;
					case 1 :
						_root["brick_"+moveable_bricks[x]].pos = 0;
						_root["brick_"+moveable_bricks[x]]._x -= tile_size;
						break;
					case 2 :
						_root["brick_"+moveable_bricks[x]].pos = 3;
						_root["brick_"+moveable_bricks[x]]._x += tile_size;
						break;
					case 3 :
						_root["brick_"+moveable_bricks[x]].pos = 1;
						_root["brick_"+moveable_bricks[x]]._y -= tile_size;
						break;
					}
				}
				wait_up = false;
			}
		}
		// when SPACE key is pressed, I don't wait for its release but I detect the key at once
		if (Key.isDown(Key.SPACE)) {
			// letìs made bricks fall...
			falling = true;
		}
	} else {
		//if the blocks are falling 
		// blocks_landed variable will count the number of bricks that already touched the ground
		// or that cannot fall anymore because they are over other bricks
		blocks_landed = 0;
		for (x=0; x<4; x++) {
			// calculating x and y position of the brick in the array
			x_pos = (_root["brick_"+moveable_bricks[x]]._x-x_offset)/tile_size;
			y_pos = (_root["brick_"+moveable_bricks[x]]._y-y_offset)/tile_size-1;
			// determining if the block can fall. There are two conditions:
			// 1: its position is less than zero. It means the block is outside the grid, in its starting position
			// 2: its position is lower than the grid height and the tile under the block is empty
			if ((y_pos<0) or ((y_pos
		moveable_bricks[x] = brk.getDepth();
	}
}

And this is the result… arrow keys to move/rotate and SPACE to drop

Download the source

Get the most popular Phaser 3 book

Through 202 pages, 32 source code examples and an Android Studio project you will learn how to build cross platform HTML5 games and create a complete game along the way.

Get the book

215 GAME PROTOTYPES EXPLAINED WITH SOURCE CODE
// 1+2=3
// 100 rounds
// 10000000
// 2 Cars
// 2048
// A Blocky Christmas
// A Jumping Block
// A Life of Logic
// Angry Birds
// Angry Birds Space
// Artillery
// Astro-PANIC!
// Avoider
// Back to Square One
// Ball Game
// Ball vs Ball
// Ball: Revamped
// Balloon Invasion
// BallPusher
// Ballz
// Bar Balance
// Bejeweled
// Biggification
// Block it
// Blockage
// Bloons
// Boids
// Bombuzal
// Boom Dots
// Bouncing Ball
// Bouncing Ball 2
// Bouncy Light
// BoxHead
// Breakout
// Bricks
// Bubble Chaos
// Bubbles 2
// Card Game
// Castle Ramble
// Chronotron
// Circle Chain
// Circle Path
// Circle Race
// Circular endless runner
// Cirplosion
// CLOCKS - The Game
// Color Hit
// Color Jump
// ColorFill
// Columns
// Concentration
// Crossy Road
// Crush the Castle
// Cube Jump
// CubesOut
// Dash N Blast
// Dashy Panda
// Deflection
// Diamond Digger Saga
// Don't touch the spikes
// Dots
// Down The Mountain
// Drag and Match
// Draw Game
// Drop Wizard
// DROP'd
// Dudeski
// Dungeon Raid
// Educational Game
// Elasticity
// Endless Runner
// Erase Box
// Eskiv
// Farm Heroes Saga
// Filler
// Flappy Bird
// Fling
// Flipping Legend
// Floaty Light
// Fuse Ballz
// GearTaker
// Gem Sweeper
// Globe
// Goat Rider
// Gold Miner
// Grindstone
// GuessNext
// Helicopter
// Hero Emblems
// Hero Slide
// Hexagonal Tiles
// HookPod
// Hop Hop Hop Underwater
// Horizontal Endless Runner
// Hundreds
// Hungry Hero
// Hurry it's Christmas
// InkTd
// Iromeku
// Jet Set Willy
// Jigsaw Game
// Knife Hit
// Knightfall
// Legends of Runeterra
// Lep's World
// Line Rider
// Lumines
// Magick
// MagOrMin
// Mass Attack
// Math Game
// Maze
// Meeblings
// Memdot
// Metro Siberia Underground
// Mike Dangers
// Mikey Hooks
// Nano War
// Nodes
// o:anquan
// One Button Game
// One Tap RPG
// Ononmin
// Pacco
// Perfect Square!
// Perfectionism
// Phyballs
// Pixel Purge
// PixelField
// Planet Revenge
// Plants Vs Zombies
// Platform
// Platform game
// Plus+Plus
// Pocket Snap
// Poker
// Pool
// Pop the Lock
// Pop to Save
// Poux
// Pudi
// Pumpkin Story
// Puppet Bird
// Pyramids of Ra
// qomp
// Quick Switch
// Racing
// Radical
// Rebuild Chile
// Renju
// Rise Above
// Risky Road
// Roguelike
// Roly Poly
// Run Around
// Rush Hour
// SameGame
// SamePhysics
// Save the Totem
// Security
// Serious Scramblers
// Shrink it
// Sling
// Slingy
// Snowflakes
// Sokoban
// Space Checkers
// Space is Key
// Spellfall
// Spinny Gun
// Splitter
// Spring Ninja
// Sproing
// Stabilize!
// Stack
// Stairs
// Stick Hero
// String Avoider
// Stringy
// Sudoku
// Super Mario Bros
// Surfingers
// Survival Horror
// Talesworth Adventure
// Tetris
// The Impossible Line
// The Moops - Combos of Joy
// The Next Arrow
// Threes
// Tic Tac Toe
// Timberman
// Tiny Wings
// Tipsy Tower
// Toony
// Totem Destroyer
// Tower Defense
// Trick Shot
// Tunnelball
// Turn
// Turnellio
// TwinSpin
// vvvvvv
// Warp Shift
// Way of an Idea
// Whack a Creep
// Wheel of Fortune
// Where's my Water
// Wish Upon a Star
// Word Game
// Wordle
// Worms
// Yanga
// Yeah Bunny
// Zhed
// zNumbers