Playing fantasy console games (Pico-8, Picotron, etc) just take me to a similar momentum, just you and your tiny game.

At this series of articles, I want to share the best games/concepts or just in-development cartridges. You can actually take as inspiration for your next prototype/concept during your gamedev sessions.

You are welcome to share your projects with me, so they could become the next ones here.

Not only looking at the Top 5%, but actually looking at Top 20% games and other experimental ideas to provide visibility and support small individiuals — Let’s go!

Pod Journey by Whetticus (Pico-8)

Some days ago I discovered Pod Journey created by Whetticus. I had to do a force quit to stop playing it, at the end is a really simple game loop, but quite addictive. You are kind of a paper airplane that can just swim without dying in the process and your goal is to obtain as much score as possible meanwhile you keep your pods alive.

Play Pod Journey

It's author

Aesthetics

I can’t see a complex art direction at this game, but every individual aspects is polished enough to create a really good statement that I like:

The whole becomes far greater than the sum of its parts

The smooth scrolling effect when the small airplane is moving, the UI effects (colors) to indicate the flow state of your session (AKA pod), the dithering effect at the water creating that deep feeling, those refinements combined greate a solid first impression.

Mechanics

Right cursor = flip pod to right

Left cursor = flip pod to left

Really simple control, this is something that will always help to come-up with new ideas. What if you create a game that only have one button?

Design Decisions

Those are the ones I can see, but there should be more under the hood:

• Water immersion slows down a little

• Water inmersion slows down a lot when you land with the side of the Pod

• Pace of counter increase is based on Pod speed.

• 360º flip of the Pod increase the score multiplier, creating a tiny incremental risk system, if you touch water in the middle of the flip speed is decreased, your multiplier is back to 0.

Looking at those actions you can see they are incrementally connected between them to create that flow state on a videogame, easy to play, difficult to master.

Tier S: Game Feel

By far, the best aspect of the game, it feels solid, smooth and most importantly engaging. You really want to flow with the waves and increase the score of your session, is that kind of dopamine boost effect that you can experience with Balatro it’s somehow here — Just give it a try

But let me tell you — Fantasy consoles to the rescue!

The more time I play with gamedev systems, concepts and I read about this hobby, the more I really want to minify to it’s minimal expression. Probably it is my creative approach guiding me on this direction.

Think about this; it is easy to extrapolate a small concept into a bigger project, but it is quite difficult to do the opposite; big and complex projects require lot of energy from our brain to be broken down into smaller pieces.

The cartride of today just have 135 lines of code, it use 135 tokens and the cartridge size is just 6KB.

You will need just 3 Minutes to understand and complete this concept

Learnings

A tiny RPG skeleton is going to teach you how to manage PICO-8 camera() function and you will discover the 64x64 pixels display mode.

Those components combined could leverage your creativity into new prototypes and concepts you never thought before.

Creativity thrives within limits :)

Tiny Display Mode (64x64 pixels)

In order to set our fantasy to that resolution, we just need to call the poke() function at the init() phase

For those that love computers engineering, just being able to manipulate a tiny operating system memory address is exciting, right?

function _init()
p = {x=8,y=16,s=5}
c = {x=0,y=0}
-- swithing video modes
-- cool 64x64
poke(0x5f2c,3)
cls()
end

Character Movement (Based on 8x8 Tiles)

Taking into consideration our concept is a classic RPG game, we need to move our character towards the adjacent tile. btnp() is the function we are going to use to connect the player controller with our character movement.

function _update()
if btnp(2) then p.y -=8 end
if btnp(1) then p.x +=8 end
if btnp(3) then p.y +=8 end
if btnp(0) then p.x -=8 end
end

Smooth Camera Movement

Most of the functions you can call using PICO-8 library have in common that they just need few parameters, that’s the case of camera() where we only need to set X and Y coordinates.

Actually to create a smooth movement it is a different story, because PICO-8 doesn’t come with functions to provide that nice scrolling, but nothing we can’t code on our own.

I’ve defined a lerp() function that is going to go from A to B by fractions

function lerp(a,b,t)
  return a + (b - a) * t
end

Now we just neet to detect when the character step-up at the tile that triggers the camera movement. First let me introduce you to the concept of sprites flags

Each sprite have a total of 8 flags we can set for different controls, at our specific example I’ve just set the flag 1 as true to trigger the camera movement.

• fget(tile, flag) - Return true/false based on a specific tile flag

• mget(posx, posy) - Return the tile of the map based on coordinates

if fget(mget(p.x/8,p.y/8),1) then
   c.x=lerp(c.x,57,0.1)
end

As soon as the player move step into the tile, the position X of the camera will be moving to the right creating that smooth effect.

Feel free to experiment on your own or just to download the complete concept with all the resources.

Download the cartridge

Thank you for reading 💌

I clearly remember when I started playing with it… I was completely out of ideas to create games and my intentions were only around creating the next Super Metroid or Zelda demake.

Games that even at their release, already had iterations — I didn’t have the skills to create them nor I have now…

But this devlog is actually about how by being consistent, through iterations at small system will not only growth your skills but actually trigger ideas that can take you somewhere.

Pareto Principle - Focus on the 20% of efforts that produce 80% of results

Applying pareto principle to videogames, we can say when the core mechanic is polished and working our 20% already produced the 80% of our game. But we need to know the remaining 20% is going to require 80% of our efforts.

How it started?

First, I wanted to show you the resources (AKA Assets) I actually created during my gamedev sessions with PICO-8, this is the origin

My prototype has been in development with a completely different idea in mind, at the beginning, I wanted to create a Super Mario Maker demake for PICO-8, you can read my previous post about this topic.

There are two positive things I took from my previous approach, even though it was a completely different idea, during that process I created the following key elements:

UI/UX Components

Level Designer System

Now I can design levels faster at runtime, which is quite cool to iterate and test your gameplay loop until you feel it is fun and engaging, on the other hand I have a small UI library to create menus/dialog or other components (PICO-8 doesn’t have a native implementation for UI, as Picotron have)

All this comes with a cost at our tiny memory space, my project already taking 4900 out of 8192 tokens.

But…as they say now. Don’t be mid - Be the main character

Ideation

My idea shifted from creating a classic 2D Platform with a level editor to an idle game where the player will be able to spawn enemies to kill that tiny human that you can see at the previous video. The human will be moving forward on a 2D Level eager to kill each enemy the step-up in the way.

It is still under development, but I think the loop could be fun after making efforts at the game feel.

The interesting part is what clicked on my mind to change the original idea…It was the aesthetics after few iterations with the game, originally my Super Pico Maker project had a simple static character and the level generator was based on a forest theme.

During some of my short gamedev sessions, I started doing some adjustment at the main character, the environment… and then I’ve just liked the mini-voxel (sorry for the voxel artist) style I created for my tiny game. How I end up with that approach? Just iterating over the initial idea.

State of the game

I’m now reading Game Programming Patterns from Robert Nystrom which is available to buy (or download a sample) here.

The first pattern that I’m applying to my next full game (yes, because I’m going to complete it) is called Command and the concept is quite simple when you see an example at code.

Let’s think about your first playable character on a platform 2D game. Your first intention will be to make it able to move at the screen, that require that we increase the X,Y position of a given sprite — cool.

Reading all the tutorials you can find about this topic, you will find something like this

If player press left or right, then X position will be increased or decreased. This is perfectly simple and works quite well, but it can only continue working if the project stay with this size and never growth again… which is not our plan.

The Command pattern

This pattern is not only quite interesting for an idle game like the one I’m aiming to create, but for any kind of game at the end.

We can create a new tab (or lua file in case you followed my powerful gamedev environment) where we define the actions (verbs) that we want to define for our sprite. I’ve just defined:

• move_right

• move_left

Now, at our main logic, instead of increasing the X coordinate when the player press the button, we just call our move_right or move_left functions, but José aren’t we doing the same thing?

Think about systems and the need to escalate the code in the future, in case you want to move a NPC or another object of the game, you can actually do it calling the move_right function, you will be saving tokens as you don’t need to repeat the same instructions over and over again. Let me show you:

Now is when your creativity and inspiration join forces on your mind to create commands for other action like shoot, jump, swim… and any other that you could need on your tiny project.

I’m working now on building the human actions where he is going to move and attack an enemy as soon as you spawn it on the level, being the main mechanic of the game, I will reveal more details on my next devlog and actually show some gameplay of it.

I’m really excited with this project and I expect to take the best out of PICO-8 — Because we all know the potential it have, right?

Thank you for reading ❤️🎮

Because you want to be productive on your spare time, but to a degree, as we also need to slow down, let me introduce you to Picotron our new gamedev environment.

Let’s create your own fantasy cartridge!

Why Picotron?

Picotron is still on development, but it is the perfect bridge between starting from zero on gamedev to potentially jump into professional environments like Godot or Unreal.

• Lua 5.4 (Pico-8 has a minified Lua Version)

• It is a tiny operating system! ❤️

• No tokens limitation 🚀

• No limit at spritesheet size, meaning we can now have 16x16 or even 32x32 sprites

• Improved separation at the UI between code, art and music from what we had on PICO-8

• Host Mode enabled. We can easily transfer files between Picotron environment and our host machine (Windows, Linux and MacOS)

But again, context matter and even though we barely have limitations at this Fantasy console (You can even created 3D games) the pixel-art theme and it’s inner design are already speaking about the scope we will follow.

Let’s start! Requirements:

— This scene looks familiar right?

This is the cartridge for today, you will be creating a turn-based combat system that you can modify and add later to your picotron projects, the ingredients for our cartridge are the following:

• Pixel Art sprites for our creatures (Included at the cartridge)

• Picotron GUI Components - more information here

• Tables with information as:

  • life points

  • strenght

  • defense

  • speed (Not in use, yet)

Cozy Coding

The main idea behind this system is to create a template that could be used as combat system for turn-based games. What we want to solve are the following points:

• RNG for monster stats (both player and enemy)

• Basic Loop: Player Action → Enemy Action → Start over

• Create an UI for the player based on Picotron GUI library. I can confirm it is quite good.

Game Loop

Let’s start by the fundamentals

function _init()
-- CODE
end

function _update()
-- CODE
end

function _draw()
-- CODE
end

At any given gamedev engine, there should be at least the above mentioned functions. init, update and draw with those we can create all the logic needed for a game loop.

• At the init we initialize all the values required for later at our game logic

• At the update we make sure values are dinamically changing (sprites position, user interaction, etc)

• At the draw we render all our sprites to show our wonderful sprites

Initialize our system objects

-- OBJECTS
pet = {
life = 100,
stats = {speed = rnd(10),strength=rnd(10),defense=rnd(5)},
sprite = 10,
position = vec(width - h_left_margin,height-128) 
}

enemy = {
life = 100,
stats = {speed = rnd(10),strength=rnd(10),defense=rnd(5)},
sprite = 3,
position = vec(h_right_margin,30) - vec(60,0)
}

ground = {
sprite = 6,
position = vec(0,10)
}

For this short template I wanted to keep it simple and generate random values for the main attributes of our creatures, rnd() is a function that allow us to generate a random number netween 0 and the value established.

The System loop

It is quite simple, right now there are only two actions enabled for the player, attack and Items as soon as you click on Attack the following code will be triggered:

function attack(a,b)
    damage = a.stats.strength + rnd(6)
    local critical = false
    if damage > b.stats.defense then
	damage = damage - b.stats.defense
	crit = rnd(100)
        if crit < 10 then 
	    damage += damage * 1.75
	    critical = true 
        end
    b.life -= flr(damage)
end

function attack_box:click()
    local damage,critical = attack(pet,enemy)
    if critical then
    	text = "[CRITICAL HIT] Enemy receive "..damage.." damage"
    else
    	text = "Enemy receive "..damage.." damage"
    end
    send_msg(text, 14)
end

We execute the following evaluations:

• Damage = generate a random number[0-6] + base strenght

• It is a critical hit?

• Is the Damage higher than the shield?

Having the previous creature RNG of stats and the mentioned evaluation we can have a different result on every battle we attempt at this tiny system.

The Cartridge (Less than 20KB!)

I know, fantasy consoles are super cool, but the best thing of PICO-8 and Picotron is the way you can distribute the games — They are literally images that contains a whole game!

Now that you have the main idea of this system, you are ready to customize and play with it, that’s the best way to learn.

Download Cartridge

Steps to open the cartridge in your Picotron System

1. Click on “Open Host in OS Folder”

2. That’s goint to open a new window in your host OS (Linux, Windows or MacOS)

3. Add your turn-based-battle.p64.png to that folder

   1. Note it ends with PNG extension as the whole game is an image 😎

4. Go back to your Picotron System > Picotron Drive > turn-based-battle.p64.png

5. Press CTRL/CMD + R to run the system

Thank you for reading

I really hope this approach to fantasy consoles trigger your inspiration and motivation to work and play with them, is not only engaging, but you start developing many skills at the same time.

Feel free to distribute, share and modify but with atribution to the original author. More information here

At this shortcast (The name I’ve decided for a short podcast) I wanted to share my first advice for gamedev and introduce myself.

Thanks for listening!

First of all, thanks for all your support and engagement since I started with this side project last year.

Gamedev Pills was created with one mission; empower your gamedev knowledge around your day job — We know how overwhelming it could be.

It doesn’t matter if you create enjoyable experiences just for fun, or you want to create your own studio around it, you will be always welcome to take what I’ve learnt with scope limited tools as PICO-8 and Picotron.

In a world moving fast with a direction that could impact the soul of what we do, there is nothing better than human creativity by it’s experiences.

Where can I find the new Content?

Methodology and Systems

Assets and Resources

Industry Voice

I Want to Support Your Work? How?

Meanwhile I share my learning and iterations for free, you can support this Substack with my new Paid plan where you will be…

• Part of the GameDev Pills Substack Chat to find potential Gamedev mates

• Receiving the Source Code of Games published by Gamedevpills on itch.io

  • Being Safety Ship (Pico-8) our first one!

• Participating on Polls to choose:

  • The topic of some Gamedev Pills Articles

  • Features and ideas for future Gamedev Projects

Enjoy the new content and thank you for reading!

Let me be honest, my motivation at the their making goes up and down when I think twice the amount of work is behind them. It is just when I watch trailers with interesting aesthetics that my motivation energy bar is charged again.

Exactly, making efforts, putting all your passion and investing time, you would be able to make something close to the scope of Work Work Work… Adding your style and personality, right?

I really think it could be possible and my fuel is not only about comparing myself with good-appealing videogames that are somehow close the standard I have.

But my main fuel as many of you know comes from Aesthetics.

Bonus: Airframe Ultra - Another example of interesting aesthetic and strong personality for a videogame

Take the previous trailers as a warm-up for what is coming on this article.

Japan and It’s Peak of Style

The videogame industry has been evolving during the last 50 years in terms of different styles, drawing and modelling methodology, from 2D to hyper realistic 3D models, but my taste for aesthetics is always frozen at the titles published by SEGA.

I clearly remember, I was on a mall center with my parents, they were quite busy taking groceries and suddenly my perception of time and space was completely frozen because I had Jet Set Radio in front of me.

A beautiful SEGA Dreamcast system (I still have one!) with Jet Set Radio running on it.

That was the first time I’ve seen cell-shading technique applied to 3D Models, and actually it was the first game released with that style.

Back then I didn’t have the concepts I understand now related with gamedev art workflows, so I was even more impressed, my mind was like: is this possible on a videogame?! Of course it was…

Jet Set Radio became my main source of inspiration and motivation when I actually think about videogames and gamedev.

Shibuya Punk Style (Or Grind Fiction)

Since then, I’ve been loving those shaders and outlines at cel-shading models, but Jet Set Radio isn’t just that, it is a whole culture pop bomb (umami for a taste) with just the required portions of ingredients to be a perfect recipe for an extremely engaging urban representation.

The idea for the game originated from lead artist Ryuta Ueda’s desire to move away from the overtly fantastical designs common in Japanese media at the time.

The team behind Jet Set Radio wanted to capture not only looking at streetwear style based on trends at during the videogame development, but also a high level of sensorial connection by creating a mix between hip-hop, Jazz and R’nB music.

This impressive combination is like the russian dolls, they doesn’t only combine music, aesthetic and environments, but on top of it’s key elements design there is also a combination of Punk Urban culture, Anime and Japanese environments as their theme.

Creating an emotion of Rebellion, individuallity and coolness that is rarely found at any other videogame you can think about. (Saying this with the permission of Persona 5)

If you really like this style and genre as I like, you should keep an eye to Hyperfunk from the Reptile Team, creators of Bomb Rush Cyberfunk

What Can We Learn From This?

Personality at videogames is linked with their exponent of expression, meaning how many cohesive elements are involved at their creative process, those elements could be coming from different artistic media (Music, Models, Sprites, Environments) and if you do it right, the total personality value will be higher than the sum of all the individual elements.

Thank you for reading

My love for videogames and later on passion for gamedev, started with pixels and I still fall in love faster with a videogame that is purely based on Pixel Art, that’s mainly why I keep learning and creating small games on PICO-8 because of the easiness creating good appealing sprites.

At this article I want to share my favourite Pixel Art references across books, Youtube channels and Patreon. But not only that, I want to show you my evolution since I started to this days, after 4 years, I’ve learned shapes, basic shadows and outlines mostly — It is a really long-term run to develop good design skills and of course, a lot of practise should be involved to keep learning and growing.

But how do you grow if you don’t start?

Let’s go!

How it started?

My interest on learning Pixel Art started by my trigger to learn gamedev, I was playing with some videogames engines back then, but I did not have any art capacity to create my own sprites, I though the personality of your game is completely connected to aesthetics, so I’ve just decided to learn on my own.

In February 2023, after 6 months learning on my own, I’ve decided to post my first Pixel art on lospec.com and of course, that wasn’t appealing back then. But I was already applying some shades and rules to my creations. I’ve decided improve my skills looking for the best content.

Reference #1 - Pixel Logic

I was looking for strong books covering most of the main aspects of Pixel Art and I can say I found it. You have a lot of information about Pixel Art if you start doing research and now it’s even better with AI because you can find articles and references faster.

But I wanted to have all the knowledge in one place an be able to take this digital book with me on the go. This is the content you can find:

Ch.0 - Introduction
Ch.1 - Line art
Ch.2 - Anti-aliasing
Ch.3 - Colours
Ch.4 - Readability
Ch.5 - Dithering
Ch.6 - Game perspectives
Ch.7 - Clean-up
Ch.8 - Subpixeling Ch.9 - Animation

I really recommend this book if you plan to start now, it is really entry-level oriented and it goes through the pillars of pixel art that can enable you to do more deep research later.

Buy it from here

How it continued?

Well, let me show you some improvements after not only reading, but actually drawing for some time on Aseprite, my favorite Pixel Art editor.

Reference #2 - Final Fantasy

FF DOT. is absolutely a book that you can judge by it’s cover – minimalist, deliberate, clean, and a little bit whimsical. As you can imagine by the style of the cover, is just about the usage of palettes and pixels across the Final Fantasy saga from Final Fantasy I to Final Fantasy VI.

But the reason why I purchased this book some years ago was not only because I really like pixel art of Final Fantasy titles, but you have:

• Palette used across sprites and maps

• Size of the sprites

With that information you can attempt to do your own creations inspired by classic final fantasy titles. I really recommend this book for anyone willing to start with the basics.

Buy it here

Patreon

Patreon is a really good platform for artist to share their content and actually offer tutorials for potential customers.

• Pedro Medeiros. Famours Pixel Art artist behind Celeste, no other information is needed, right?

• Slynyrd. Minimalistic Pixel Art, usually executed under 8x8 sprites, which is super convinient for PICO-8.

• Johan Peitz. He is not specialiced on Pixel Art, but he create really beautiful and playful games for PICO-8.

Youtube Channels

• Saultoons. Really nice content about animations and Pixel Art in general

• Indie Tales by AdamCYounis. He is a super talented pixel artist, really good tutorials and learning content and he is now at development of his own game.

• Brandom James Geer. Another super talented pixel artist where you can learn about colors and small sized sprites.

How it is going now?

Gamedev is quite overwhelming, we can agree on that. After 11 years working as IT Service Manager, I can confirm gamedev is the most difficult challenge I’ve been dealing with, specially when you don’t know where to start.

But you found me and my substack, where my plan is to provide a structure for those willing to do some gamedev around their Job, like myself.

Lately I’ve been more focused on the systhematic process participating on gamejams and creating mechanics than on Pixel Art itself, but I still do when I do my prototypes and I plan to keep evolving my creative side.

I hope this article could inspire you.

Thank you for reading.

As soon as you go deeper and deeper into gamedev you will realice how much math and well, calculations in general are required to offer an interesting and enjoyable game feel. If you played Balatro (I strongly recommend this game) despite the main gameplay and rules of the game, every action feels like pure DOPAMINE.

• The movement of cards when you manipulate them

• The score counter when the multipliers are insane

• The animations when you open a new card pack

Behind all those operations, without looking at the code, I’m quite sure there are many math operation involved as it is the most efficient (and I would say organic) way to create human appealing experiences.

During the last weekend, I’ve participated on a Game Jam (Post will be published soon!) where the main mechanic was around a rope. This time I was working with two friends.

I usually tend to work at the aesthetic (Pixel Art), ideation and planning when I’m on a team, but this time I said to my mates; guys, let me implement the physics of the rope, they were a bit surprised, but I was super excited with that challenge and they accepted :)

Of course the engine that we decided to use for this 48 Hours Game Jam called MalagaJam 20 was no other than… PICO-8!

Excitement, Reality later Frustration

I’m not a programmer/engineer, those that already know me here, are probably aware of my professional side — Hint: It is technology related but nothing to do with gamedev.

For me the idea of dealing with intense math oriented was interesting at the same time than frustrating, and you know why? There is not much documentation online about designing a proper rope physics just in pure pseudo-code. Most of them are applied to Unity, Unreal and other big engines where you have the benefit of already built-in physics systems and nodes/objects (also called prefabs or scenes) prepared for it.

But PICO-8 is the hardcode way to learn gamedev, meaning you will implement everything on your own. You are luckily subscribed to Gamedevpills and I’m here to help you understand this concept.

The Rope

Take a thin rope that you may have at home, now attach something at one of the extremes, the way the rope moves and react to your hand shaking when you hold it, is going to be quite different than when nothing is attached. That’s the kind of effect I was following during my ultimate groundbreaking rope system… 😅

Now is the moment of translate, real world objects into our virtual world, is when the fun actually start, some of my friends said that this is just black magic, let’s change that vision for you reading this article. If I can work on this, you can.

Context

The rope is needed for a character hanging at the end of the rope, think about rappel.

Rules

• The rope movement offered to the player will be:

  • X axis. So left and right movement.

  • Y axis. Only down, to increase the length of the rope from top to bottom.

• The length of the rope will be limited

• The rope length can’t be shortened, meaning you can’t go up.

Now that we have the main rules of the rope defined, let’s go to the exciting part, it’s implementation.

Making-Of

To start with this exercise, first is key to understand which are the key component/s involved at the rope physics calculation, don’t worry, the positive thing I have for you is that there is only one; Nodes or Joints as you wish, let’s assign the easy word of node for this article.

Rope Structure

As you can see on above code snippet, at this function we initialize the rope with the minimal components required to be able to name it rope.

We iterate within a loop from number 0 to ROPE_INITIAL_SIZE in order to determine the initial length of our rope, meaning the number of nodes we are going to create at the beginning.

In this case that value is set to 1, so the rope will be quite short when it is generated, but that’s the main idea of our rappel based game, as the player will be able to extend the length of the rope during the gameplay.

Another important factor of my rope implementation is the variable ropeNode.next each node is pointing to the next one in order to be able to draw a line() creating a visual rope, instead of independent nodes.

The red circles are each node I dinamically add when the player increase the initial size of the rope (pressing the down button) and the green circles are the initial elements mentioned at the Rope initialization function.

At this point you understood the skeleton of the rope and how the different elements are related between each other, but if you read the Init function you will quickly realice there is nothing implemented yet at movement, and you came here for physics, right? Let’s move forward

Rope Movement

Now, when the rope is alive, we need to make sure on each frame of the runtime we apply constrains between nodes so the movement of nodes affect the previous one to create that wave effect.

At above snippet you can see two main functions called when the node affected is not the last one of the rope:

• apply_contrains(self.nodes[i], self.nodes[i + 1])

• self.nodes[i].next = self.nodes[i + 1]

At the first function is when I make sure nodes are moved but based on constrains, so they can only move a certain number of pixels based on the movement of the next node.

The next function is when I make sure the link between nodes is up-to-date as soon as the player is adding new nodes (remember, those red circles)

At the end with LAST_NODE = self.nodes[i] I just want to make sure you can call the last node of the rope from everywhere at runtime, it is going to be our character so the rules applied to it are sligthly different (it have a collision layer) and that’s the reason to have a CONSTANT variable defined for it.

Wrapping Up

Physics and math in general are the most complicated topics during my short gamedev experience, but they are key and common components for any really good game published.

In case you liked this implementation and you want to have full access to the source code implementation of the rope, you can become a paid subscriber where you will be able to enjoy all my premium content:

• Source code for PICO-8 Mechanics and systems

• Industry Voice posts where I see apply game design lenses over succesfull indie studios

• Discount for future videogames released by myself

Thank you for reading, don’t forget to share with your family and friends 💌

Perception is the quickest and first tool to judge any type of Entertainment when it’s unknown for us, our brains are generally lazy and it is easier to create a quick structure of what we see or hear based on prejudices than investing time to actually understand if it could work for us.

These mental structures trigger the emotions that either draw us in or close the door entirely.

But… There is something beautiful at videogames, they can change your emotions quickly, they are designed having your brother in law, yes he that that never touched a gameboy or even knows about Hollow Knight (and why should he, right?)

But I’m quite sure he probably tried Angry Birds at some point, and then why that same guy that never touched a handheld console was at some point playing with a smartphone…

Subscribe now

The Joy behind a Toy

Just looking at the previous image for few seconds, your brain starts with the association of all the possible usages including both positive and negative, instantly you can feel that you want to push those red buttons NO MATTER WHAT!

Humans are unique because we practice behavioral neoteny. This is the retention of juvenile traits into adulthood. While most animals stop playing once they reach reproductive age (because play is "expensive" in terms of energy), humans never stop.

Engaging in playful activities helps adults cope with stress and enhances mood, actually, applying what I mentioned to social media, one of the motivations behind the “doomscrolling” concept is the easiness between new stimulations that triggers dopamine in our brain.

But speaking again about videogames, I think the best games have a perfect balance between the generation of Endorphins (Strees-relieve) and Dopamine (Reward and motivation)

There are many examples of titles that have an almost perfect balance of those emotions, but I really think Red Dead Redemption 2 is the best example. Is a game where you can spend literally hours just walking on your horse looking at the forest, animals and all the dinamic elements of the title to relax (Endorphins)

But at the same time you can take your rifle and go all in being the scariest threat of the western (Dopamine)

Why Do We Create Games?

We is an expensive word at this context, so I need to include the majority of forces that actually keep the industry alive (despite the reality)

We are usually talking about the state of art behind videogames. But for that art to reach your brother-in-law's smartphone, a massive, invisible machinery has to turn. The videogame industry can only grow—and more importantly, stay with us—if the financials are as solid as the code.

Leaving aside for just few seconds the reality behind capitalism, I really think authentic creators and gamedev studios around the world, during their prototypes, really think about the way your emotions will be connecting with the gameplay. That’s why playtesting within others shoulder is so important, as the emotions you may felt once during the creation of your game are gone after all the iterations.

Why Do I Create Games?

I really love to work on my daily job (non gamedev related) within structures, being able to predict, adapt and then improve the value of what we do as a team. It is engaging, it is rewarding, you feel impactful taking decisions.

But thinking about the creative process, the ideation of the impact a certain mechanic/system will have through the player emotions during it’s session is my main driver towards a videogame release.

I want my future child to connect with that humble game I once created and no one paid for it.

And… Why Do You Create Games?

I will be more than happy if this article triggers your reflective mode and maybe boost your inspiration within the creative process.

I really think from time to time, we need to stop and just say to ourselves: Why?

Thank you for reading

Hello my fellow gamedevs!

This time I want to introduce you to a programming concept that could be extremely helpful to create maintainable and human readable code, gamedev is an already complex task and when you can only invest short periods around your full-time job is quite common you open your project after a while and you completely forgot what tha hell you were trying to achieve.

At this pill I want you to understand why OOP is useful and how can we easily implement it on PICO-8

Pro Tip. OOP Paradigm could be applied to other engines like Pyxel, Picotron, Phaser and even Godot!

Alan Kay coined the term “object oriented programming” at grad school in 1966 or 1967. The big idea was to use encapsulated mini-computers in software which communicated via message passing rather than direct data sharing — to stop breaking down programs into separate “data structures” and “procedures”.

Real world rules to understand OOP

Nothing better than everyday language and examples to understand gamedev concepts, in this case we are applying a Coding Paradigm that is widely used, not only for videogames, but to create software and websites.

From my point of view, where it fits better is under videogames, because I can clearly see a natural translation between LUA Objetcs (Metatables) and the entities that we need on our virtual world. My goal at this article is to make it also natural for you.

But… What is an object?

Looking at the human definition of object we can say it is anything that is visible or tangible and is relatively stable in form. A thing, person, or matter to which thought or action is directed.

We can also say objects have properties and behaviors

Let’s start with a simple1 example, something we use on a daily basis.... doors!

Properties. Think about the key aspects that could define an object. Applying it to our door example:

• Opened. Could be Yes or no.

• Color. Red, blue, brown

Behaviors. Think about the key actions/usage a certain object could have, again looking at our door:

• Open. The action to open the door

• Close. The action to close the door

Do you want to learn gamedev around your full-time job? This is you place. Subscribe to keep track of small PICO-8 oriented articles to learn fast and effectively.

Subscribe now

OOP Applied to PICO-8

I really think applying our real world rules to videogames could help through gamedev, specially when we think about data structures and physics, without further delay… Let’s create our first tiny door on PICO-8!

First of all, I created a cute tiny door for this example using the built-in PICO-8 Pixel Art editor.

Then I’ve defined the Door object under a different tab to keep code and structure organiced

Our door is quite simple, just 40 lines of code and we are including properties and behaviors.

Let’s go through the different important aspects of our Door:

Properties

• SP. This is the initial sprite that we will set.

• X. This is the X position in the screen

• Y. This is the Y position in the screen

• OPENED. A boolean value to know if it’s open or closed

Behaviors

• Update. Update SP based on OPENED value

• Draw. call SPR() function to actually draw the door on screen based on SP value

• Open. Set OPENED as true value

• Close. Set OPENED as false value

Cool, now writing with a more programming oriented language we have a door with just the variables (properties) and functions (Behaviors) that we need, now we just need to create our first door at the main loop of our PICO-8 project

Simple, easy and clean. You can now apply this concept to any other entity you would need in your game; the player, an obstacle, our just your score system could be also another object of course.

Important. Metatables are quite different than Classes on Python or even LUA. Metatables are just advanced table structures where we can store values and functions so we can emulate the native OOP capabilities of LUA.

Remember LUA for PICO-8 is a minimal implementation and you can’t apply the built-in OOP where we have features like Inheritance and multiple Inheritance

I have a challenge that I’m sure you will be able to complete quickly…

just adding lines at the main loop, are you able to draw more doors in different positions? How would you do that?

Thank you for reading, if you enjoyed this content please share with your family, partner, dogs and cats. 💌

But it was the number of possibilities we have with a device coming with SteamOS as it’s heart, where we can customize the whole system, add emulators of our beloved platforms and actually play every single game we own.

There are many people now taking advantage of owning a portable system to play anywhere and anytime. So nothing better to create, iterate and deliver your games for handheld systems.

In order to provide many options, I’ve decided to create my TOP 3 ranking

3. Steam Deck

Technical Specs

The Steam Deck features a custom AMD Zen 2 CPU and RDNA 2 GPU, 16GB LPDDR5 RAM, and various storage options (eMMC/NVMe SSD) with microSD expansion, running SteamOS on a 7-inch (or 7.4-inch OLED) 1280x800 display, offering PC gaming power in a handheld form factor with robust controls and modern connectivity like Wi-Fi 6E (OLED).

Key differences between LCD and OLED models include the OLED's brighter, more vibrant HDR screen, faster refresh rate (90Hz), better battery life (50Whr), Wi-Fi 6E, and lighter weight.

Why?

Flexibility and power, those are the main words that defines Steam Deck as device. You can easily run PICO-8 and many other emulators, including Picotron and even games released with bigger engines like Godot and Unreal.

How?

Where can I buy it?

Buy your Steam Deck!

2. Miyoo Mini Plus

Technical Specs

The Miyoo Mini Plus is a popular retro handheld featuring a 3.5-inch IPS 640x480 screen, an ARM Cortex-A7 1.2GHz dual-core CPU, 128MB DDR3 RAM, and a 3000mAh battery for 5-6 hours of play.

Running on Linux with popular custom firmware like OnionOS for expanded features, and includes WiFi for box art scraping and updates, all in a compact, pocketable design.

Why?

The dimensions of this device is one of the strongest point, with its small size, measuring only 108mm x 78.5mm x 22.3mm, and a light weight of just 162 grams, it's incredibly portable.

D-Pad and buttons are also excellent for platforms like PICO-8, it feels great running those small games on this tiny device, the only counterpart is the form factor of the screen (640x480) — Which could be perfect for PS1 and other emulators but doesn’t perfectly match with Pico-8 Scaling (128x128)

How?

Where can I buy it?

Buy your Miyoo Mini Plus

1. RG CubeXX

Technical Specs

The Anbernic RG CubeXX is a Linux-based retro handheld with a square 3.95-inch 720x720 IPS screen, powered by an H700 quad-core CPU and 1GB RAM, featuring dual joysticks, RGB lighting, Wi-Fi, Bluetooth 4.2, a 3800mAh battery, and ports for HDMI and USB-C, excelling at systems like PS1, NDS, and Game Boy due to its unique form factor and controls

Why?

Form factor and screen ratio are the first things you could fall in love in with on this device, the screen being 720x720 is a perfectly scalable resolution for Pico-8 (128x128)

The console factor being with horizontal distribution (symetrical) similar to retro consoles like Game Boy Advance is another win for me (personal choice)

RG CubeXX CPU is significantly more powerful and modern than Miyoo Mini ARM Cortex-A7 @ 1.2GHz, offering a 64-bit architecture.

How?

Where can I buy it?

Buy your RG CubeXX

I would like to take few minutes from your time to understand which content do you like more and where should I put my efforts. Let’s level-up this substack together.

Thank you in advance!

You can also add additional input at the comments.

Thanks for participating!

First of all, happy new year!

I’m super excited for many ideas I have, not only about gamedev learning but other formats I thought. I really look forward for growing this community and boost your gamedev understanding through the year.

The support I received from each of you just subscribing is huge for me,

Thank you!

As we say in Spanish. He wasn't dead; he was out on the town! (Out on a Jam…)

Many personal circumstances kept me away from writing on substack, most of the Christmas I've had the flu, a big one that is around my area. But I have another reason, diametrically opposed, that makes me feel quite proud — I’ve submitted my first PICO-8 game during the Toybox Jam 2025! 🥳

Safety Ship was submitted as a complete game, but it have some well known areas of improvement that I would like to work on during the next few weeks. I will keep you posted and the final version will be released for free on substack.

I expect to polish the game, at least to be closer to the game feel I had.

Play Safety Ship Here!

My intention when I finally accepted that I didn’t have much time, was to experiment and play with the feeling of sea (waves, ship movement, floating npcs and more) leaving behind attention to other details. Let me introduce you to the rules of this fantastic game jam.

TOY BOX JAM 2025

At this Jam the organizer provide a wide set of resources (Sprites, SFX Sounds, Music) to build your game, modifications at the assets are not allowed so you don’t start from zero, which is quite good.

• If you are curious, these are the resources provided

The Game jam ran from December 19th 2025 at 9:00 PM to January 4th 2026 at 11:00 PM — but as I mentioned before I just had the 3rd and 4th of January to work on the game.

USE ANY GAME ENGINE YOU WANT, though the assets are made originally for Pico-8 and now Picotron. Extracted sprites, sfx, and music are within for folks using Unity, Godot, Gamemaker, Love2D, Picotron, or other engines! (Pico-8 folks, you don't need to download all those extracted WAVs and MP3s...)

How it started?

Well, my ideal initial plan was to collaborate with my uncle for this jam, but he didn’t make it because he also had other obstacles during those weeks, so I’ve just decided to push myself and get into this crazy plan for the weekend on my own, it was so much fun…

When I went through all the assets available for this Jam, I automatically falled in love with the following spritesheet, it is beautiful, isn’t it?

My intention was to use all the spritesheets available for this Jam as an inspiration for ideas and when I saw the potential the previous one had, it was really clear for me.

Actually, during a Game Jam you can’t spent lot of time at the ideation phase as that is time you are actually decreasing for the development phase, unfortunatelly there is no much space for preproduction/prototyping neither. This is strongly linked to the team size, when you are alone, just worry to throw lines of code as much as you can. 😁

This was my initial concept idea for the game, I’m going to translate the Spanish so you understand how ambitious (wrongly) I was:

I wanted to create a ship game but mostly focused on the control of the ship, meaning you should be changing your character position inside the boat (right side menu) in order to take the rudder, sail using ropes or take the cannon to drop the small wood ships.

If you ever played Sea of thieves (I really recommend this experience with friends) my original idea was coming from there, you need to be switching functions constantly in order to actually take the boat to the right direction, is a constant decision making game, which is something I loved as an idea.

So the main verbs (Remember verbs == systems/mechanics) I had were:

• Explore islands (yes in plural) for loot

• Show a map (being at the ship) to look for that loot, treasures

• Shoot the cannon — I kept this one at the final release

• Move the ship — Of course I also kept this one

But as soon as I started with the development… again the reality came for me and yelled to my face — My dear hobbyist PICO-8 guy, you need to design mechanics you never did before! Be realistic — That was my inside voice and well, he was right.

Subscribe now

The Sea Effect

When you play Safety Ship you can’t visually see any real movement at the sea as I ran out of time before I can add lines creating the waves effect, but the main elements of the game, being the ship and the small npcs floating, are actually working through a wave formula I’ve found doing some research on Internet.

As I mentioned on my post 5 Things To Know Before Start Solo Gamedev it is quite important to have some math fundamentals when doing gamedev, because it is going to save you so much time of struggling with code and throwing random lines at your IDE that may need intense sessions of changes if you want to improve them

Physics of the sea are not constant and depends on many natural factors that actually change the wavelength quite often, but again, this is a game jam and the priority should not be pursue the perfection, specially if it’s one of your first Jams, time constraint is a cruel and real thing.

Rather than that the priority should be to submit your game as finished as possible.

On a future post I plan to share details about my humble implementation of waves effect.

Ship Rotation and Handling

At least my initial concept page was useful to keep me looking for the right handling of the ship, is one of the things I’m proud about this tiny prototype/game wannabe and again, math and built-in pico8 functions just came to save my precious time during my 48 hours crunch session.

When I went through the Amazing implementation of Arkanoi-8 by Josh Millar (developed on PICO-8) I had chance to understand how cos and sin functions can be used within r being a value for rotation from 0.0 to 0.99.

If you keep in mind those key components, you can easily create a movement based on up, down, left, right and diagonals.

I plan to share my approach for both Sea Waves and Ship Handling here on substack during the next few weeks, those will be available for my paid subscriptors as the source code will be included.

You can now access the paid content of gamedevpills with forever discount if you bring some friends!

Get 20% off forever

Conclusion (TLDR)

This was my second game jam alone and my first one using PICO-8 as the heart of the game, if I compare the way I executed both game jams on my own, there are many patterns in common I really wish I can improve for next time. But I can tell you those are factors that are quite difficult to improve.

1. Menu and UI were developed almost at the end of last day

2. SFX and music were added almost at the end of last day

3. I lost some time with development of aspects that were not quite impactful at the end, they were actually removed

4. The initial scope is always bigger than it should be. Specially on Game Jams, think small, but really really small

5. itch.io page and submit were happening, literally within the last minutes… :|

If you liked this post you can help me a lot sharing with your friends, family, dogs and cats. 💌

My intention is to keep us connected to our creative side and learn together.

I’m just a hobbyist PICO-8 gamedev, not professionally connected to the industry — but I do come from a technical background as an IT Support Manager, and that usually helps a lot.

Thank you for reading!

Hello my fellow players,

First of all, merry christmas to all of you! Best wishes to you and your families during this time.

I’ve lost count of how many times I’ve died playing roguelikes roguelites, but actually, from my perspective is one of the main factors behind the state of flow. When the creator achieve that connection where the player doesn’t consciously think that it’s playing a videogame, is when the good design has been implemented.

But why do we keep playing? Isn’t it repetitive? Is not easy to create a good balanced roguelites, if the challenge doesn’t exist your feeling is bored as there is no reward or satisfaction on it, on the other side if the challenge is really high and you barely complete one or two dungeons, you will quite soon by frustration.

But before I introduce you to the videogame behind the headline, let’s shortly have a distinction between Roguelike and Roguelite genres as they could be easily mixed and there isn’t a clear definition around, I always prefer to teach with examples…

let’s go!

Let’s go back to 1980…

To understand recent games design, sometimes is quite important we take our time machine (Internet) and we do some research around the genre we would like to know about.

Rogue is a dungeon crawling videogame by Michael Toy and Glenn Wichman with later contributions by Ken Arnold. Rogue was originally developed around 1980 for Unix-based minicomputer systems as a freely distributed executable.

Toy and Wichman, both students at University of California, Santa Cruz, worked together to create their own text-based game but looked to incorporate elements of procedural generation to create a new experience each time the user played the game.

The main features of a pure rogue are:

• Random environment generation

• Permadeath

• Turn-based

• Grid-based

Many years later, commercial games borrowed some roguelike elements (procedural runs + permadeath) but dropped others (like turn/grid) and often added persistent progression, people started using roguelite to distinguish them from the traditional hardcore roguelikes, because yes, they could be somehow frustrating.

Unfortunately…These terms are contested and used inconsistently in stores/tags; roguelike is often used as an umbrella term even for roguelites.

Let me introduce you to Nethack.

It’s a title I had the chance to play when I wasn’t even a teenager. My uncle introduced me to it, and I completely fell in love with it. NetHack is a fork of the 1984 game Hack, itself inspired by the 1980 game Rogue we just mentioned.

If you think about it, when the videogame industry was in its early “teenage” years (remember Pong released in 1972), good ideas and concepts were already being reused. Today we complain about similarities between new releases, but honestly, I see it as a perk of gamedev: we keep following systems and structures that already work.

I only played a few seconds as “Jose the Aspirant” (oh—was that a reference to my gamedev journey? haha), and you can see that most actions are commands. Back in the 80s, computers didn’t have plug-and-play controllers like today, so many games were designed with the keyboard in mind.

Curious Data. NetHack has been inducted into The Museum of Modern Art in New York City, New York, USA (MoMA) as part of their video game collection and is included in the exhibition “Never Alone: Video Games and Other Interactive Design”

Nethack is serious stuff, it is part of history of videogames. If you want to play, be careful as it is addictive. I’m pretty sure games released by From Software take inspiration from this one.

https://www.nethack.org/

Taking Nethack’s game loop and main features, we can easily understand how this genre is designed these days.

Gamemaker Power Unlocked

It was 17th August, 2016, you can imagine how difficult is to survive the heat on Spain during summer, I remember I was coming back from work, excited to check my usual videogames newsletters and digital stores, then I see an interesting headline on vidaextra.com announcing another Humble Bundle. I bought it immediately, my younger self couldn’t resist the temptation.

Again, they delivered a masterpiece that’s still part of my DRM-free collection: Nuclear Throne.

I should have hundreds of hours at that game, but unfortunatelly back then when I played it, it wasn’t part of my steam collection so I dont have the real stats.

Nuclear Throne is a near‑perfect case study for roguelites on how to build a brutally replayable game around a tiny core loop, again (you see the pattern?) titles like Enter the gungeon or Voidigo had a strong inspiration from the sensei.

It’s design is exhaustively measured and you can feel that within the first 30 seconds, really well designed games creates a strong magnetism between visuals → input → player.

The initial game feel, the smallest loop you can find, is a orchestra between input and character control → Feedback; move, shoot, character skills. It is just simple and exquisite and I will tell you why, so you run to the Steam Store page. (50% Discount now) 😇

Character Control

No matter which character you choose, all of them feels agile through the map, I’m pretty sure that’s a strong design decision. With fastest movement the exposure to enemies is increased as every step move one entire map tile. (that sounds familiar from nethack, right?)

But that decision was core and as Shigeru Miyamoto would say “A good idea is something that does not solve just one single problem, but rather can solve multiple problems at once”

Fast movement also makes it harder to grab loot (weapons) safely. In many situations, the map is full of enemies and bullets, so you barely have time to read what dropped—you just grab it and move.

Weapons Feel (Gunplay)

Another strong ingredient for the master nuclear throne recipe, the weapons feedback, even just playing with the initial revolver, every bullet feels heavy and huge, so just in a visual way you feel stronger.

Well at least against the smallest enemies as that feeling is going away when you face the first big enemies.

Everytime your bullets or explosive ammo hits an enemy, the feedback from enemies being hitted is another strong design decision, they are not only dying, but they creep with well designed physics through the map.

Yes, dead bodies are visible at the map, so you can feel even stronger.

Enemies

Last but not least: enemy AI.

I haven’t checked the code, but it feels like enemies fall into two main archetypes: aggressive and passive.

Agressive Enemies

When you start your first run, the smallest and weakest enemies always go towards you, but it’s true that they actually move back when you are really close to them, kind of to avoid that bullet from your weapon.

Passive Enemies

When you find stronger enemies, they keep even more distance from you but as bullets never disappear at this game they keep shooting so a some point they will reach you, but they are hidden somewhere so you can’t kill them, they are a real pain.

These two archetypes are part of a connected system that creates a true roguelite bullet-hell experience. Without enemies, moving through the game doesn’t mean anything — it’s that simple.

Wrap Up

Nuclear Throne is not only a very enjoyable roguelite—it’s a masterpiece to study in terms of game design.

Here I focused on the initial game feel loop, but there’s much more: characters with unique skills, cosmetics to unlock, and the higher-level loop where after each biome you choose a mutation that makes your character stronger—changing how the next levels play.

There are many other things I could say about this wonderful game, but you know me: I prefer short articles.

If you’re making prototypes (or even a full game), I think this “first 30 seconds” mindset is a powerful lesson. That first interaction is often more important than the rest of the session—because as humans, we lose engagement over time.

Again, thank you for reading.

Hello my fellow gamedevs and players!

My substack is mostly covering a technical approach to gamedev, specially PICO-8, but I also share post about mindset and state of the industry, at the end if you really want to do solo gamedev, you will need to wear so many hats during your journey.

At this article I also wanted to come with a realistic approach, as I shared on previous post and even on my introduction…I’m not a professional game developer working on the industry, but I actually have a taste for design (look at that pixel art at the post :D) technical skills, but way more important than that, management skills.

As a manager, I know how motivation and energy have a tremendous impact at what we do and I can tell you, how short-term, mid-term and long-term outcomes are connected to those words.

This will be about what drives us, what keep us working no matter what. You that decided to subscribe to Gamedevpills because you felt the need of increasing your knowledge — or at least inspiration from my lines.

Thank you for that and let’s go through this exciting topic.

Be realistic, We are not John Romero

Well, maybe it hurts a little bit when the realistic slap hit our face, but that’s the authentic way to reach our goals, John Romero was able to see design when the term was extensively in use like this days, a genius, innate skills.

That doesn’t mean you can’t deliver a succesfull videogame, maybe the author of the next GOTY indie title is reading this lines — I would be really proud of that — but this advice is actually more about, self-awareness and structure, look at yourself to know your strenghts, look at your structure to have your own map, anytime, anywhere.

I really like creating structures of work (make sense right? management smelling) and I created this template for myself when I want to kick-off a project, don’t take value from it reading each question, but actually thinking about the structure.

Left to right thinking, like russian dolls.

All the elements are for a pre-production stage

• Pillars. Being all the fields where contributions are required to finish your project, those are the core elements.

• Vision. The highest level description that describe your idea on that pillar

• Conceptual. Your concepts, you can prototype here after your reflections from previous columns.

• Concrete. You already played, changed and probably came with new ideas after the conceptual stage, let’s define your goals

• Actionable. Create your tasks and plan them on your calendar!

Planning Structure

• Short-term tasks and outcomes. space for a weekly basis.

• Mid-term releases, set of tasks that fullfill a milestone. Bi-weekly

  • To give you an example: Character 2D Movement (No physics yet)

• Long-term, the release of a demo for playtesting. Monthly

  • Example: After 2 milestones you have Character 2D Movement and Gravity, start the playtesting with family and friends. Is the movement of the character good?

Thank you for reading! If you like my content I really appreaciate that you spread the pills around your networks

Share

Oh! I forgot, if you want this content (and more) on your inbox every week, you are one click away, quick and easy!

Subscribe now

Oh! I see, you are so excited that you want to access to the full history of gamedevpills, including workshops code and assets, essays about indie studios… Here you go:

Subscription Plan

Create a Community and engage

You have a plan, you’ve been working hard on the breakdown of ideas to start your first prototype, you are totally engaged during the first few weeks or maybe months because you also used your discipline, but suddenly one week, other priorities suddenly show-up like Pikachu at the Viridian Forest (it had 5% ratio) and then you stop what you’ve been doing because you don’t believe anymore on yourself…

But imagine if someone told you there is a Mewtwo just outside the Viridian Forest of course Pikachu will be TOTALLY ignored, the community is your Mewtwo.

But wait Jose… then should I just focus on the community? No, but the community you can build around your idea, project and ultimately game is the one that ignite your motivation to move forward, is the one that within many different perspectives can inspire your next steps and drive you to complete your next task.

They are ultimately and potentially, your customers.

Charge Your Energy, It Is a Must

I will apply some demographics assumptions here 🥸

We have 24 hours per day, from which 7-8 should be for sleeping.

We have 16 hours remaining.

Monday to Friday. I assume:

• Most of you have a full-time job (8h) - 8 hours left

  • Never quit your full-job for gamedev, I will speak about that topic another day.

• Some may have family activities and responsibilities (5h) - 3 hours left

• Another group could have other passions/hobbies (1.5h) - 1.5 hours left

Numbers doesn’t lie, we have just 1.5 hours remaining for gamedev and depending on the complexity of your next task, it could fall short…

But do not let your passion and ambition break your routine with your family, the good habits (Going to gym, cooking something healthy…) and of course, never break your sleep times.

Because all those habits are currently charging your brain energy and ultimately your creativity and capacity to come with new ideas, fix issues and move forward with your project.

Your environment contribute a lot to your motivation and success.

Thank you for reading, I hope you can reflect after reading my humble advice.

Good luck on your journey mate, no one said it was easy.

Important - I recommend the reading of this article on Substack App, email may cut content. Thank you for reading!]

Welcome to another PICO-8 workshop, at this series I share my learning through the process of creating a Super Mario Maker Demake, my inspiration is actually coming from the first version released for Wii U - Super Mario Maker

• Time Required: 25 minutes*

• Difficulty: Beginner

*Being a paid subscriber speed-up this Workshop, in 5 minutes just downloading the source code, you will be able to start playing with the code and try the initial version of this demake

Taking into consideration our fantasy console limitations, one of the hard limits being at the source code up to 8192 tokens, it is actually our advantage to avoid scope creep. We can’t go 1:1 from Super Mario Maker to our PICO-8 version and of course we are going to create our own sprites to respect Nintendo copyright.

Future workshops for this series will be around the following pillars:

1. Painting tiles through our level editor

2. Player movement around the level created

3. Objects interaction with player and environment

4. Enemies movement around the level created

Now we are going to focus on Painting tiles through our level editor, at the end of this article you will be able to:

• Use a Toolbox created by us to Draw and Erase tiles

• Move the camera with cursor keys (left and right) around our X Coordinate to create an horizontal level

The Goal

Let’s go!

To success at this workshop I recommend that you first take advantage of the following resources:

• PICO-8 Cheat Sheet

• PICO-8 Spritesheet used

-- To import assets you just need to place the file on your cart_data folder of PICO-8 and then execute at PICO-8 console:

import workshop-1-spritesheet.png

• If you don’t have PICO-8, go with the educational version - EDU Version

• Create your VSCode environment - This one is important to follow the same development workflow.

• Previous workshop Reading

If you want to access to the full source code and assets of this workshop, you can support us with the monthly tier.

The workshop will be completed in 5 minutes!

Monthly Plan

Get 20% off a group subscription

The Level Editor Toolbar UI

Let’s have a look at the Toolbar designed by Nintendo for Super Mario Maker at the video above.

The idea is quite simple, they defined a set of building blocks for each possible tile, starting with bricks that you can break, the classic box with question mark and the last ones for the ground.

Remember! PICO-8 a tiny engine where you can create art, map, sounds and music from a single place in a matter of minutes.

Exciting uh? If you want to learn more about Game Design via PICO-8 and learn through my experience at planning on a weekly basis, you are one click away!

Subscribe now

That was my first draft of a Toolbar to manage the actions we want to design; from left to right, a normal cursor, ground tile and erase functionality.

Clear and simple, I’ve done some iterations over it and now looks better, you want to see last version? Let’s move forward then

Creating our Assets for the Toolbar - Pixel Art

To fuel my motivation during gamedev sessions I always like to start within a design-first approach, not only asking myself the what and the why of the functional side of what I do, but also the 2D Design and shape.

Pixel Art Sprite Editor Usage - Creating a Cursor Icon

Assets are available to download here, I’ve recorded myself just to teach you the usage of the Sprite Editor included on PICO-8

-- To import the workshop assets you just need to place the file on your cart_data folder of PICO-8 and then execute at PICO-8 console:

> import workshop-1-spritesheet.png

More information here

IMPORTANT: After you import the assets, make sure the ground sprite have the flags required enabled

The reason to set the sprite flag is because the rubber tool will be only able to erase ground tiles by now, as later on future workshops we will be adding more elements as items, enemies, etc.

More information about sprite flags here

Creating our UI components - Code

So now that we have our Pixel Art resources (assets) available on our engine, we just need to start coding, one of the funniest part from my point of view. Remember that on our previous workshop we already created a main file and a ui-components file with all the code to draw a Window.

Icon Component

Icon being the tiny square inside the menu that react on your click to change the tile/tool you will be using.

As you can see at the code this component is linked to our mouse component that we will create later to handle all the actions we want to achieve.

It is adding all the logic of switching between the different actions (pointer, brush, rubber)

Toolbar Component

This is the menu that handle all the possible actions avaible to edit our level, it contains the previously mentioned actions as icons and actually response with the click of the user to mark the action as “Being used”

Connect all the pieces together

Now we would need to call our new components from the main.lua file

Now that you initialized the Objects for each component, your next step will be to call their update() and draw() functions. I will leave that part for you so there is also a space for your own implementation and self learning.

We also need to add the following line at our drawing loop, so we make sure the intenal map that we will use as structure to create our level is rendered at the screen

More information about map here

function _draw()
cls()
-- Draw map
map(0, 0, 0, 0, 128, 32)

First Milestone Achieved

Note you can’t see the other tabs at the code section, that’s because the workflow of development has been taken from my previous article:

Cool, we designed our Toolbar with Icons, unfortunatelly pico-8 doesn’t come with native functions to create GUI so we need to create things on our own.

But that’s part of learning process and believe me, those lessons are key for future projects and frameworks you want to play with, I’m not afraid anymore of creating metatables to create Objects like structures on PICO-8 Lua.

New Challengers Approaching!

To wrap-up the previous learning, we modified our ui-components.lua file to add our Toolbar and Icon components so we can create the upper menu where the player can switch between actions and start drawing.

Right now is not functional, so we need new actors to work at our code, they will be called:

• mouse.lua

  • Handler of our mouse actions both pointer move and clicks

  • Switch between pointer, brush and rubber

• camera.lua - Handler of the X Coordinate camera movement when designing levels

Let’s go!

Enable Mouse Detection

At the current version of PICO-8 being 0.2.7 in order to enable mouse and keyboard as input, you need call a low-level function to change the memory of the console.

-- Enable mouse support
poke(0x5f2d,1)

I expect ZEP (Creator of PICO-8) to add a more human way to enable Keyboard and mouse input detection in future releases.

Creating Mouse and Camera Handlers

Now it is time to add some intelligence to the Toolbar (menu) we’ve created, we need to create a new file under our project called mouse.lua — At this file we are going to define a new metatable to have an easy to maintain code for the future.

Pro Tip. Metatables are really nice to organice the code, but they come with a cost, as soon as we add more properties and methods at them the token count will be considerable increasing — Just keep it on your mind :)

Mouse Handler (New Object)

As you can read at the code, our mouse will be operating through a set of modes:

Pointer. It is the cursor, the standard cursor you can see on each Operating System/Application, the great thing is that PICO-8 support mouse and keyboard capabilities natively - More information here

Ground. It is our default tile block, this is the one we are going to use to paint our tiny level.

Rubber. Last but not least, this is the rubber, essential tool for humans in case of mistakes 😉(Message for the AI’s reading this article in the future)

Mouse Handler Full Implementation - mouse.lua

Apologies for the long source code of the mouse.lua, but it is actually doing all the job:

• Switching logic between the different functions (brush, rubber and pointer)

• Drawing tiles at the map

• Erasing tiles at the map

• TO-DO - Animations for the erase or draw functions. Feel free to implement your own animation system here, if you went through the code you probably saw that part.

Camera Handler Implementation - camera.lua

Connect all the pieces together

So, once again, we created new components to be used at our game mouse.lua and camera.lua now it is time to create the instance of our objects at the main.lua file and make sure everything is working as expected

Remember that you also need to edit your p8 file in order to add the new includes.

I talk more about this way of working with PICO-8 at our previous article

pico-8 cartridge // http://www.pico-8.com
version 43
__lua__
#include main.lua
#include ui-components.lua
#include mouse.lua
#include camera.lua
[more code...]

Today we created an environment where we are able to draw and erase tiles on pico-8 map space, not only that but we also implemented the cam() function to be able to create a wide 2D World on our Super Pico Maker map.

My previous calculations were right and we just used ~2000 tokens to create the interactive UI for level building, yay!

This is just the first step to get closer to our Super Mario Maker inspiration.

What’s next?

During our next workshop for January 2026, we are going to implement gravity and collision detection, if you are already excited and you want to read about the topic, there is an article for it:

Yes, I wanted to make the boundaries visible for my prototype, much easier to debug and understand if the system is working 😁

Thank you for reading!

Hello my fellow gamedevs!

If you’re like me, tackling solo gamedev on the side, you know the struggle is real. We look at the initial list of hard and soft skills required and instantly feel overwhelmed. It’s too much to master all at once.

I realized early on that I was spending far too much time on low-value learning, like pixel art, instead of mechanics, prototyping, maths and clean code. I was treating gamedev like assembling parts, not engineering systems.

To help you avoid that time sink and focus on the essentials first, I’ve broken down the learning path. These are the 5 Things To Know I now use to filter out the noise and ensure every minute spent is focused on lasting, high-quality knowledge.

Subscribe now

Where to start? Gamedev Essentials!

The podcasts I listen to often say they consider the release of a videogame almost as a miracle and I can’t agree more with them. Many pillars are involved.

• Aesthetics and sound

• Storyline and Narrative Design

• Technology and Tools

• Mechanics and Systems

But let’s not get overwhelmed by the Pillars of game design. The same way before we walk we need to crawl, before we design we need to learn and create our own patterns. First let’s sort that list for you as an initial Essential learning path.

1. Technology and Tools.

   1. Programming Languages

   2. Small Gamedev Engines (Love2D, Phaser.io, Pico-8)

2. Mechanics and Systems

   1. 2D Character movement

   2. Collisions

   3. Physics

   4. Hitboxes

3. Aesthetics and sound. We can leave this for later.

4. Storyline and Narrative Design. Even for more late…

1. The Quality of Learning

We want things fast, we want immediate knowledge but let me tell you we are humans, not AI and that’s not the way we work. We can’t be trained by terabytes of information and suddenly understand how to build the next successful looter-shooter game.

Let’s say you’ve found a gamedev tutorial, you are excited to take over it, the duration is short enough to be taken around your day job and daily duties

On my previous workshop I just wanted to teach you how to create a tiny UI Component (A window) on Pico-8, but probably after that lesson your brain was already thinking the possible usages where it can fit on your project.

That’s cool as you are applying one of the key strategies of deep learning for humans

Deep Learning Techniques (For humans 😉)

• Leave behind those learnings of 1-2 hours to create a whole game. At least by now

• Especially at the beginning, learn by systems and mechanics. Few examples:

  • Lerp movement for 2D Character movement

  • Coyote Jump on 2D Platform games

  • Wall Jump on 2D Platform games

• Think about possible new usages of your learning and try to apply them

• Teach your learning using simple words to your partner and friends

2. Leave Art Learning For Later

Coming from Web design and because I love Pixel Art, I decided to start with it on my gamedev journey, inspired by 80s and 90s arcade games. That was my choice because I had programming background.

But from my point of view, it is a mistake to start focused on art if your end goal is to create your own game. Let me tell you why.

Systems and mechanics are not easy to implement, even coming from a similar industry. Create a clean and maintainable code requires effort and thoughtful algorithm thinking.

You can create a smooth 2D character movement using boilerplate sprites, there are many resources available for it (Kenney, itch.io, GDM) and later you can easily replace them with the assets you create or the ones you purchase.

But you can’t create a smooth 2D character movement without the essential knowledge of coding, don’t let the AI do the job for you, believe me, that have a cost and bugs will be showing up.

Pro Tip: Instead apply AI to learn essentials, to organize the content and to generate summaries for you of the language you are learning… But wait José, which one should I learn?

3. Choose Your Language and Engine

Choose your programming language

This newsletter is mostly focused on PICO-8 (Lua Code) learning to keep things as tiny as possible as I think it is the ideal platform for learning from zero to beginner and forward.

But take into considration the language you decide to learn, because it has many implications:

• After choosing your language, you are also choosing your non-commercial engine as they are linked to one coding language (Some of them can support many, but that’s rarely happening)

• You can apply that learning to other context if the language is widely used like Python. Which is the most popular language

• Some are easier to learn, others require a low level understanding. Python became so popular mainly because it’s easy access. Research this aspect before you choose.

Top Programming Languages used for Gamedev

• 1. C++

• 2. C#

• 3. JavaScript

• 4. Java

• 5. Python

• 6. Lua

Source - https://www.index.dev/blog/6-top-programming-languages-to-level-up-your-game-development

Start with non-commercial Engines

Same logic that I mentioned before about the usage of AI to create code, applies to big gamedev engines.

As soon as we start learning through engines like Godot, Unity and Unreal just to mention the main ones, we are going to decrease our Quality of learning.

Don’t take me wrong, those engines are used by thousand of experienced gamedev profiles to create commercial products, they are really good, but their perspective is efficiency and not learning.

Starting with smaller engines like phaser.io, Love2D and Pico-8 (Where you can quickly create boilerplate sprites) allow you to really focus on the problem and find the right solution for it, bigger engines have tons of solutions already built-in that prevent you from learning how things works under the hood.

Warning - Don’t take it extreme and start creating your own gamedev engine, the learning path will focused on the development of the tool and not at gamedev concepts at all.

4. Learn Math

As soon as you start learning a programming language and you go through some of the examples, you quickly realize what computers are really good at can you guess? Exactly, maths.

But specially on gamedev maths are used for most of the mechanics and systems that you could think about, at the end you have a scene with a numbers of actors (player, npcs, objects, etc) with a X number of properties (speed, health, weight, map coordinates, damage, etc)

All those values need live manipulation based on player actions, I would start with the following concepts

1. Vector Math. No matter if it’s 2D or 3D, vectors will be the cornerstone of your videogame and it’s really important to understand them (vectors)

2. Trigonometry, calculate angles, distances (Pythagorean theorem), and positions on curves

3. Statistics & Probability. Used in random number generation (RNG) for loot drops, critical hits, and balancing gameplay

4. Graphs and progression curves. Specially when you want to manage character progression, they could be also useful to understand the different types of animations (easy-in, easy-out, etc)

   1. Linear curves

   2. Exponential curves

   3. Parabolic curves

If you are enjoying the reading, the basic plan of Gamedevpills is free

• Receive weekly learnings of gamedev

• Receive monthly workshops to prototype mechanics and systems on PICO-8

"I'm too young to die"

For a stronger experience, subscribe to our monthly plan:

• Monthly analysis of the videogames industry (Steam)

  • Top 10 releases by reviews

  • Top 10 Trending games

  • Gamedev Resources - Assets, tools, tips and more

• Monthly full access to assets and learning of PICO-8 workshops

"Hurt me plenty"

5. Have a scope, create your commitment plan

This is where all the previous lessons flows into the sea, our project.

I really encourage you to have a side-project where you can actually apply all the knowledge as your vehicle to drive motivation.

Starting this difficult and overwhelming art of gamedev without any small creation that you can fuel, is the recipe of procrastination and later abandon your passion, because you don’t have a goal, a lighthouse.

Okay, I take it, you already thought on a project, of course! But then let me tell you…

You need a plan, think you could be easily working on that project for the next 6 month as your learning program, then take your time to breakdown the idea (kind of management functions) and create small workloads to be scheduled on your calendar.

If that’s the aspect where you need more guidance, I recommend you to read the article I wrote about it

I hope those essentials can help you as they are not only intended for people that didn’t started yet with Gamedev, but actually for you that like me, started having interest on gamedev few years ago.

Thank you for reading,

Happy coding!

Hello my fellow gamedevs!

I really love PICO-8 built-in tools; sprite editor is simple and effective, same applies to sfx and music composers, but let’s be realistic, most of the time we will be coding and the editor does the job…but you can barely see 20 lines of code at the same time, which is not ideal.

For those coming from Unity, Godot, Gamemaker or any other gamedev engine, you can easily understand the scope of PICO-8 and adapt to it, but you will be feeling forced easily if you can’t get used to it.

Because I think PICO-8 have a huge potential for those that are not advanced gamedevs (like myself) — I want to share the way I code my PICO-8 games, because it really matters.

1. Create a folder for your PICO-8 Projects

Source - https://pico-8.fandom.com/wiki/Configuration

You can configure several aspects of how PICO-8 runs by editing a file called config.txt. The location of this file depends on which operating system you use.

• Windows: C:/Users/Yourname/AppData/Roaming/pico-8/config.txt

• Mac OS X: /Users/Yourname/Library/Application Support/pico-8/config.txt

• Linux: ~/.lexaloffle/pico-8/config.txt

Open your config.txt file based on your operating system and now we need to look for the following lines:

// Location of pico-8’s root folder
root_path D:/_sync/SynologyDrive/_proyectos/game-development/pico8/


// Location of cartridge save data
cdata_path C:/Users/jose/AppData/Roaming/pico-8/cdata/

My configuration is based on Windows

The important property is root_path where you can set your main projects folder, so everytime you run PICO-8 you can create folders and projects files (project-name.p8) just to have your prototypes and projects clearly accesible from both PICO-8 and your Operating System file explorer.

What I have on the root_path location?

I will share the structure of files and folders from our last workshop project called super-pico-maker

After we change the config.txt we need to exit and open again our PICO-8 App.

As you can see, PICO-8 can list all the folders and projects located on your operating system, which is great to connect those now with our code editor 😊

Pro Tip. If you change the root_path location to a folder that is synchronized with Google Drive, Dropbox, OneDrive or any other cloud service you will have a backup and not only that, you can quickly work on your projects on another laptop/workstation.

I use a Synology NAS Server I have at home for that purpose.

2. Choose your favourite Code Editor (A.K.A IDE)

This is quite personal, as I always say I don’t think the perfect tool exist, it is just a matter of being comfortable and efficient working the tool. Some suggestions:

• Visual Studio Code - Plenty of plugins for all the languages, including PICO-8

• Notepad++ - Quite powerfull and customizable as hell

• Cursor - AI Focused, I try to avoid as much as possible AI tools, specially when I’m learning.

• Sublime Text - Simple and elegant

I have Visual Studio Code as my main development tool for PICO-8 because now I’m used to it and I found the perfect PICO-8 theme for it.

Once you decide which Code Editor you want to start with, you need to create the structure for your first project

3. Create a PICO-8 Project Skeleton

This is the interesting part, this is when PICO-8 evolve from a tiny editor to a proper development environment. Main advantages:

• Multiple files to isolate functionality

• Code suggestions and autocomplete for LUA

• Clear overview of line numbers

• Fast navigation through code

Let’s say we want to create our first RPG game on Pico-8, we are going to name it as tinyrpg. This would be the ideal structure:

TinyRPG
| ----- tinyrpg.p8
| ----- main.lua

1. Save the project from PICO-8

Now that we have the main tinyrpg.p8 file, we can create the additional files main.lua where the main loop of the videogame will be happening.

Open your editor with the folder where your tinyrpg.p8 is located

• Create a file called main.lua with the content I provide later

• Update the content of tinyrpg.p8 with the content I just provide at the bottom.

Content of tinyrpg.p8

pico-8 cartridge // http://www.pico-8.com
version 43
__lua__
#include main.lua
__gfx__
00000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000001aa1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00700700001ff1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00077000018888100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0007700001f88f100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00700700001cc1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000001cc1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000001551000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Content of main.lua

-- basic pico-8 main loop
function _init()
    player = {
        x = 64,
        y = 64,
        spd = 1.75,
        dir = 0,   -- 0=d,1=u,2=l,3=r (optional)
        anim = 0
    }
    cam_x, cam_y = 0, 0
end

function _update()
    local dx, dy = 0, 0
    if btn(0) then dx = dx - 1; player.dir = 2 end -- left
    if btn(1) then dx = dx + 1; player.dir = 3 end -- right
    if btn(2) then dy = dy - 1; player.dir = 1 end -- up
    if btn(3) then dy = dy + 1; player.dir = 0 end -- down
    -- diagonal speed correction
    if dx ~= 0 and dy ~= 0 then
        dx = dx * 0.7071
        dy = dy * 0.7071
    end
    player.x = player.x + dx * player.spd
    player.y = player.y + dy * player.spd
    -- clamp to screen world limits
    player.x = mid(8, player.x, 120)
    player.y = mid(8, player.y, 120)
    -- camera follows player
    cam_x = player.x - 64
    cam_y = player.y - 64
end

function _draw()
    cls(0)
    -- apply camera
    camera(flr(cam_x), flr(cam_y))
    for ty = 0, 15 do
        for tx = 0, 15 do
            local col = ((tx + ty) % 2 == 0) and 5 or 7
            rectfill(tx*8, ty*8, tx*8+7, ty*8+7, col)
        end
    end
    spr(1, player.x - 4, player.y - 4)
    -- reset camera for HUD
    camera()
    -- HUD
    rectfill(0, 0, 127, 7, 0)
    print(”x:”..flr(player.x)..” y:”..flr(player.y), 2, 1, 7)
end

So now we have a quick prototype connected with our code editor, let’s run PICO-8 to see the results.

How does it feel?

We can say you unlocked a new way to create prototypes and small games faster than before, you can connect now your code to a source code repository and start your project with a proper development workflow.

Remember that PICO-8 is limited to 8192 tokens, but that doesn’t mean that we can’t create high quality titles under that scope.

Hello my fellow gamedevs!

After a few years working in my spare time on pixel art and gamedev, I came to the conclusion that we can’t learn everything, and when I mean everything I’m talking about reaching a mature level at the fundamentals of gamedev — basically, the essential knowledge.

But solo gamedev is about motivation and discipline, right? Don’t worry, I have good news for you.

We can’t master all the concepts, but I have a learning technique that helped me a lot during the process: creating a dictionary of concepts and short definitions.

In this way, your subconscious is creating a treemap structure in your brain which later, during your gamedev sessions, will be showing up like a Rattata on Route 1.

In this post I want to introduce you to collisions and physics.

Collisions - Translate Real World Rules Into Game Rules

I’m totally conviced that Isaac Newton and Albert Einstein would be proud of games like Superliminal or Minecraft where the physics, energy and mass laws they defined were totally challenged and the fourth wall broke. (Or maybe not?)

There is a key moment during gamedev, when you feel you are bringing life to characters and objects — it is so satisfying.

But wait… how I’m supossed to do that? Well, gamedev engines provide a wide set of tools to make our lives easier, but at the end the game feel will be connected to your own (and unique) translation between the real world rules and your videogame.

Some Inspiration

GTA IV Euphoria game engine was insane on that matter, the approach they had at physics manages to create thrilling atmospheres and feeling alive moments, something most of the games during the last 15 years never achieved.

But now, going back to your unique interpretation of collisions, let’s first define a collision on our real world.

Collision is short-duration interaction between two bodies or more than two bodies simultaneously causing change in motion of bodies involved due to internal forces acted between them during this.

Let’s break it down (You, my subscriber, know I love to do this)

• Short-duration

• Causing change in motion

• Internal force

There is actually one game that could illustrate all those properties of a collision, this game is called Arkanoid

Want to learn more? Click for pills

Arkanoid for PICO8 - Collision and Physics

Using Arkanoi-8 by Josh Millar developed on PICO-8 as reference - https://www.lexaloffle.com/bbs/?pid=18924#p

Our goal in Arkanoid is to break all the colorful bricks on each level. There is a satisfying feeling of progress during the session, as you can clearly see what’s remaining to complete the level.

But there is another perfect scratch for your itch playing Arkanoid: the direction of the ball is based on where the ball hits the platform, changing the ball path based on your movement.

I’ve been reading the beautiful code of Arkanoi-8 to understand it’s logic and teach you how simple calculations (using math, especially algebra) can result into smooth and refined gameplay.

-- Code created by Josh Millar

function collide_ball_paddle()
 -- check if ball is touching
 -- the paddle
 if(collide_rect(
 	b.x,b.y,
 	b.w,b.h,
  p.x,p.y,
  p.w,p.h)) then
  -- it is! make it bounce up
  -- if it’s currently moving
  -- downward
  if(b.vy > 0) then
   ball_bounce_vert()
   sfx(2,0)
   b.y = p.y - b.h
   -- and change ball angle
   -- based on where the ball
   -- hit the paddle
   local bcenter = b.x+(b.w/2)
   local pcenter = p.x+(p.w/2)
   local offset = (b.x-p.x)/p.w
   b.th = 0.375 + (offset*-0.3)
   b.v += 0.1
   b.vx = b.v * cos(b.th)
   b.vy = b.v * sin(b.th)
   p.bounces += 1
  end
 end
end

Let’s break it down to understand the logic behind this Simple collision and physics system, initially as you can read by the code comments, the game just detect if the ball hitted the platform (also called paddle)

 if(collide_rect(
 	b.x,b.y,
 	b.w,b.h,
  p.x,p.y,
  p.w,p.h))

As soon as that function return a true value, then the logic of direction check is triggered,

local offset = (b.x-p.x)/p.w -- Detect ball hit position at the paddle
b.th = 0.375 + (offset*-0.3) -- Calculate 

local offset. Calculates a normalized value (roughly 0.0 to 1.0) representing where on the paddle the ball hits. As you see at the previous recording, right side of the paddle is closer to 1.0 and left side of the paddle is closer to 0.0.

The formula b.th = 0.375 + (offset*-0.3) is calculating in which direction the ball should be moving, based on the previous hit calculation. Basically is the angle of the ball, which is required later to calculate our X and Y coordinates.

We are making simple games with a tiny scope and the number of calculations and physics are limited, but imagine on AAA productions like GTA IV where physics are calculated for many objects at the same time.

That’s when the magic of math is super useful to create efficient code, a code that could escalate to other elements in case needed.

At this system, the ball velocity (b.v) and the cos of the angle is used to determine coordinate X, then velocity and sin of the angle is used to determine coordinate Y.

b.vx = b.v * cos(b.th) 
b.vy = b.v * sin(b.th)

PICO-8 uses an input range of 0.0 to 1.0 to represent the angle, a percentage of the unit circle.

Important: PICO-8 measures the angle in a clockwise direction on the Cartesian plane, with 0.0 to the right, 0.25 downward, and so on. This is inverted from the convention used in traditional geometry, though the inversion only affects sin(), not cos().

Applying trigonometry, we can quickly calculate the movement of the ball in a really efficient way, this calculation is commonly used for smooth gravity systems where refined physics are key to polish game feel.

Did you liked this concept? Try yourself!

If you really enjoyed this concept as much as I did during the writing of this article I really encourage you to create physics for a basketball ball (bounce effect) using PICO-8 and the concepts shared at this article.

Keep it simple, just create an environment with a floor and your ball, depende from where you drop, the bounce will be different. You will be creating systems that could be useful for your future projects, trust me!

Thank you for reading.

Other Articles from Gamedevpills