PICO-8: Map-Based Grid Movement

=====================================

Introduction

----------

This article will cover the basics of creating a simple map-based grid movement system in PICO-8 using its built-in features and functions.

What is Pico 8?

-------------

PICO-8, formerly known as Picopiko or simply Picodash, is an open-source interpreter for old 8-bit home computers. It allows you to write games and other programs written in a custom dialect called 'LUA' (Lua) that closely resembles the original BASIC programming language used on those systems.

Why Use Map-Based Grid Movement?

-----------------------------

Map-based grid movement offers several advantages over traditional tilemap or pixel-perfect collision detection methods:

1. Performance: It requires less CPU power and memory compared to more complex algorithms.

2. Flexibility: You can easily add, remove or modify map tiles without having to recompile your entire game engine.

Basic Concepts

--------------

Before diving into the actual implementation details let's cover some basic concepts you should be familiar with:

* Grid Cells (Tiles): These are small square areas that make up our playfield. Each cell has a unique ID assigned to it.

* Entity: An entity can represent anything from player characters to enemies or even static objects like walls and platforms.

Map-Based Grid Movement Implementation

-------------------------------------

### Step 1 - Create the Map

To create your map, open PICO-8's built-in editor by pressing F4. The default project already comes pre-configured with a blank canvas set at 128x64 pixels which is ideal for most retro-style games we'll be making today.

Next up, let us add some basic tiles onto our playfield so that players can actually see what they're playing on top of! For this example, we will only need three types:

1. Empty Space: This type represents empty space between all other objects in the game world.

```lua

local map = {

{0, 0},

{0, 0}

}

```

2. Solid Wall (Blocking Tile): We'll use this tile to represent solid walls that block movement through them.

### Step 2 - Add Entity Movement

Now it's time to add some actual entity movement onto our map! Let's create a simple player character who can move around freely within the boundaries of their current position on screen. To do so, we need to first define how exactly they should interact with each individual tile type when trying to pass through them:

```lua

local function update()

-- Get the currently selected entity (in this case our player)

local ent = get_entity()

if not ent then return end

-- Check which direction keys were pressed down last frame vs now

local dir_x, dir_y =

love.keypressed('left') and -1 or 0,

love.keyreleased('right') and 1 or 0

-- Calculate new position based on current speed + movement direction * delta time

local nx = math.floor(ent.x + (dir_x < 0) and map'math.ceil(ent.y)''math.max(1, ent.x)' == 3 and -4/60 or dir_x)

local ny = math.floor(ent.y + (dir_y > 0) and map'ny''nx' == 2 and -4/60 or dir_y)

-- Cap new position within bounds if necessary

nx = love.math.clamp(nx, 1, #map'1'-1)

ny = love.math.clamp(ny, 1, #map-1)

-- Update entity's actual x/y coordinates based on our calculations above

ent.x = nx * 32

ent.y = ny * 32

end

function love.update(dt) update() end

```

### Step 3 - Draw Everything onto the Screen!

Finally, we need to actually render everything onto the screen using PICO-8's built-in drawing functions. Here is an example of how you could do this:

```lua

local function draw()

for y=1,#map'1'do

for x=1+#map'y'-2 do

love.graphics.draw(map'y''x')

end

endfunction love.update(dt) update() endfunction love.draw() draw();love.graphics.flushometahs(60/frames_per_second) end```

-------

In conclusion, implementing map-based grid movement in PICO-8 is a straightforward process that requires minimal knowledge of programming languages beyond basic Lua syntax. By following the steps outlined above and understanding how each component works together within your game engine's architecture, you can easily create complex 2D platformer games with smooth physics simulations without having to worry about low-level details like collision detection or optimization yourself.

This concludes our tutorial on creating a simple map-based grid movement system in PICO-8.

Pico 8 mapdraw