Phaser home
Log inCreate a game

← Expansion packsArcade

Phaser AE

Grid kick

Pro packv3.0.0-32DArcade

Blocks on a tile grid that slide when kicked, until something stops them. Use the board on its own for the mechanic, or the whole session for an arcade maze game of kicking, crushing and dodging, deterministic from a seed and drawn by you in any style.

This is a Pro pack. Upgrade to Phaser Pro to use it in your games.See Phaser Pro →

Released October 14, 2026 · updated October 19, 2026

Grid kick: a screenshot of its demo
A note about these graphics

Expansion packs don't come with graphics. This screenshot is one way of drawing what the pack does, made for its demo: none of the sprites, tiles or backgrounds in it are in the pack.

That's by design. A pack is a game's logic, mechanics and effects, and it works with whatever art you give it. Some packs draw effects, backdrops or 3D scenes of their own, but none carries a game's sprites.

So the look is yours. Make the art on phaser.io, bring your own, or let your agent draw it in code: the same pack can look like anything.

What it does

The board, KickBoard, holds blocks of named materials. Push one and it slides at the board's speed, cell by cell, until the next cell is not free: another block, the border or another slide. What happens when a block is kicked with something right behind it depends on its material: ice breaks, thick ice cracks first and breaks after more hits, steel stays put, and a crate can be limited to one cell per kick. Blocks can hide eggs, goal tiles can ask for blocks of a group, and a query finds a line of same-group blocks and says whether it lies along the border.

The session, createKickGame, builds a game on that board. The player moves cell to cell and kicks at cell centres, with a short buffer so a kick pressed early is not lost. Enemies in front of a sliding block are carried along and crushed when it stops, scoring more for each one in a single slide. Eggs hatch into new enemies whenever the board is below its cap. Kicking the border shakes it and stuns the enemies moving along that edge, and a stunned enemy can be walked over for points. A round ends when every enemy and egg is gone, every goal is covered, or both, and pays a bonus for the time it took.

Enemies think for themselves. The arcade brain roams corridors, hunts along rows and columns, chews through ice, dodges a block sliding toward it and flees to a corner late in a life. Simpler brains patrol, chase along the shortest path, or push blocks at the player. You drive the session with a held direction and a kick, tick it, and drain events such as crush, stun, hatch and round-clear to present.

Features

  • The slide mechanic alone — push, slide, crack and break, eggs, goal tiles and line detection on a board you can use without any of the game around it.
  • Materials as data — whether a block slides, how far, whether it breaks when blocked and after how many hits, whether enemies can chew it, whether it crushes, its score, its group and whether it holds eggs.
  • Crushing — enemies carried along by a slide and squashed when it stops, scored from a table whose later entries double; an enemy's kick can crush the player.
  • Eggs and hatching — hidden in blocks, hatching in order up to the level's active cap, and destroyed for points if their block breaks first.
  • Wall shake and stun — a kick at the border stuns enemies on that edge, a line of special blocks stuns them all, and stunned enemies blink, then wake.
  • Four enemy brains — the arcade's roaming, hunting, eating, dodging and fleeing modes, plus patrol, shortest-path chase and a pusher that kicks blocks at you.
  • A maze generator — the arcade game's own ice-maze routine, quirk included, at any odd size.
  • Rounds and levels — enemies or goals as the objective, time bonuses, hurry and flee timers, lives, extra lives and level tables that loop.
  • Difficulty — Easy, Normal and Arcade scale any level table's speed, population, active enemies and patience.
  • Presenter-friendly state — stable ids for every block and actor, and a jump count so a sprite snaps on a respawn rather than gliding across the board.
  • Snapshots — save and restore the session or the board.

Good for

  • Ice-block maze games in the style of the 1982 arcade game Pengo, with the preset's numbers taken from an annotated disassembly of the original program.
  • Puzzle-action games where gems must be kicked onto goal tiles while enemies roam, as the ice-slide preset shows.
  • Turn-based sliding-ice puzzles built on the board alone, with snapshots for undo.
  • Hybrid grid games — a bomb-maze arena whose soft blocks are ice you can kick, or tunnels with rocks that slide.
  • Games where the player crushes rather than shoots, scoring by how many enemies one slide takes out.

Make it yours

A configuration is plain data. The board is an authored text map with a legend, or a generated ice maze with eggs and special blocks. Materials, enemy kinds and their brains, player speed and kick timing, slide and hatch timings, the stun, the line bonus, every score table, the round objective, lives and the level table with its speeds, egg counts and active cap are all settings. Board size, diamond count and line length are options of the arcade preset, and a 21 by 17 board with four diamonds and a line of four is tested.

Two presets show how far apart the uses can be. pengoPreset is the 13 by 15 arcade game with a generated maze, three diamonds, sixteen acts that loop and enemies that hatch from hidden eggs. iceSlidePreset is six authored rooms of steel, ice, thick ice, crates and gem blocks, with patrolling walruses and seals that kick blocks at you, an objective of gems on goal tiles, no wall shake, and an end after the last room instead of a loop.

A quick look

A Normal game from the arcade preset, a held direction and a kick, and crushes shown as they happen:

const gk = game.gridKick;
const pengo = gk.createKickGame(gk.kickPreset('pengo', { difficulty: 'normal', seed: 7 }));
pengo.control('left');          // held direction (null to stop)
pengo.kick();                   // kick the block faced, or shake the border
const s = pengo.tick(dt);       // fixed 120 Hz steps inside; returns a copy of the state
for (const e of pengo.drain()) if (e.kind === 'crush') showPoints(e.at, e.score);

Works with

  • grid-walker — the walker under the player and every enemy; a package dependency, not one to compose.
  • grid-bombs — kickable ice in a bomb-maze arena: blasts break blocks and a stopping slide can set off a bomb.
  • excavation and dig-combat — dug tunnels with rocks that slide along them.
  • tiles-2d — or plain sprites, one per block, keyed by its stable id.
  • pusher — for turn-based crate pushing one cell at a time, with undo and deadlock analysis.
  • boulder-dash and chips-challenge — for cellular rules where boulders fall or the mover itself slides on ice.

Good to know

  • It draws nothing: your game presents the state and the events.
  • There is no gravity; blocks move only when kicked.
  • The arcade preset moves at 120 Hz rather than the original's per-pixel steps, and leaves out intermissions, two-player alternation and the demo mode.
  • Generated mazes must be odd in size, from 3 to 999, and boards are limited to 1000 by 1000.
  • A snapshot restores into a session made from the same configuration.

More Arcade packs

Show all →