Since there's no deadline for this game anymore, I'm taking as much time as I need. My goal now is just "as soon as possible."

I tried to design it with only what would be needed in mind, but even then in retrospect it was definitely overscoped. Lesson learned.

Secret project coming soon, and then I swear I'll finish Quantron's Game.

Well I did say that this game might be late because life is happening and boy it sure did happen. This game is nowhere near as finished as I hoped it would be. So I’ve put together what I have and released it as unfinished, so I can play Ludum Dare games before rating ends. Sorry about the wait, things just didn’t go as planned.

There isn’t much here, just one level and some basic mechanics, and a few bugs of course. But I am still going to finish this game as soon as I can. But I also have another secret project that will probably be released first, because I just can’t work on one thing at a time.

Here's the Ludum Dare page.

I want to make a game that has existed for years in my head and in my notes as an ambiguous, ever-changing concept until recently, when I came up with a plan for how I could make it in just a few weeks for Ludum Dare.

This means I’ll be submitting it in the Extra category (honestly I might not even make that deadline because life is happening). I may try to release a demo or “part 1” of sorts so I can play and rate some other games.

And even though Extra doesn’t use ratings yet, I’m still opting out of some categories anyway because some of the assets I’ll make will be similar to assets I’ve made before. I still want to make new and original things, derivatives and iterations. I just want to keep it fair. (there is one graphic from my first Ludum Dare game that I’m just gonna put in this game as it is, because there’s no reason to make a new version of it)

As for the theme, depending on what it will be, it might already fit my game, or I could add something that uses the theme, or I might just ignore it and opt out of that category, too. It would be neat if I could make it fit, but I already know what game I want to make.

I’ll be sure to explain all this in the game’s description, too, so everyone knows I am not causing problems on purpose. But I wouldn’t be doing all this if it wasn’t to make a really cool thing. I just have way too much visceral creativity bottled up inside. It's not always useful, especially with big projects I’m supposed to be working on instead, like that one game I'm making.

Well I can hardly believe it but I managed to finish Subpixel in time for Pixel Day. It was so last minute, I made that background above the day of, shortly before I published the game. Two games in one month, and both of them were too close to the deadline.

But now I can finally talk about how I made this game, because I used a lot of weird tricks to achieve the visual effects, and I had to do a lot of *gasp* M A T H to program the gravity mechanic. Maybe if you’re having trouble figuring out how that works, this post will help you understand it. (I really tried to make this game not hard…)

How gravity works

Most scenes have an invisible boundary between one direction of gravity and another. They can be horizontal, vertical, or diagonal boundaries. Some scenes have 4-way gravity with four diagonal lines around a center point the player falls towards (or away from). Here are some examples, showing the boundaries and directions of gravity.

When you cross a vertical or horizontal boundary, gravity reverses. It was simple to program; in the middle example above, I just check if the Y position of the player is less than or greater than the Y coordinate the boundary is at. There are also some scenes where you fall away from this line instead of towards it, and others where the direction of gravity is perpendicular to the line.

When you cross a diagonal boundary, gravity “rotates” by 90 degrees, and I had to do more complicated math to calculate if the player’s position is on one side of the boundary or the other. The equations for these lines are just y = x, or y = -x. So in the example on the left, I check if the player’s X position is greater than their Y position. In other words, are they farther to the right than they are down? (in Stencyl the coordinates start with 0, 0 at the top left, so as Y increases it goes down instead of up.)

Then I have to offset it by where the boundary is, since it usually doesn’t start at 0, 0. And for y = -x, I have to somehow reverse the player’s X position by making it negative and then adding the screen width. I don’t fully get it, but it works.

It’s one of those cases in math and programming where figuring out something that seems simple at first is actually super complicated, and can be more confusing than it feels like it should be. But I think I got something that feels somewhat intuitive to play.

False tiles and warping

The other mechanics in this game are much simpler. Starting in the caves, some tiles will be fake and you can move through them. And later on, you’ll find invisible tiles that you still collide with. They’re just a copy of the tileset with no collision shapes, and transparent tiles with collision shapes.

Warping is also simpler than it sounds. Usually when you cross one edge of the screen, you reappear at the opposite edge. But sometimes you won’t end up exactly across from where you were. In this example, the arrows point to where you’ll warp to.

Normal warping is easy to code. For example, if the X position of the player is less than 0 (the left edge of the screen), I just set their X position to what the length of the screen width is (that’s the right edge). But I couldn’t figure out a smart way to do the weird warping where I break that rule, not in time for Pixel Day. So I just put individual checks in every scene, which is messy but it works.

How I made the visuals

The original idea was a game with onebit graphics where the colored pixels would constantly hue-shift, creating a rainbow effect. I decided to deviate from actual onebit and added another darker color, just because I thought it looked better. It gave the graphics depth and shading, and made the onebit style look flat in comparison. So that’s why Subpixel is “onebit-inspired.”

But I also came up with another, way more ridiculous excuse that I like to call…

⋆ ★ Q U A N T U M  O N E B I T ★ ⋆

…where every pixel on the screen is either on, off, or both at the same time at any given moment. In other words, they’re either black, colored, or colored at 50% opacity. This idea was so fascinating to me that I was looking for any opportunity to make a game with this visual style, and Pixel Day turned out to be perfect for it.

So how did I make this work in a game? Stencyl is a great engine, but it’s not without its quirks. And if I were to constantly apply effects to everything on-screen, surely that would cause catastrophic damage to my already traumatized computer. So I have to use as few objects (called “actors” in Stencyl) as possible.

The player, shooting stars and twinkling stars, the pause menu, and some text on the title screen are all actors. They’re tinted with the current color, and some of them also have an additional black outline actor behind them that doesn’t get the effect.

But everything else you see in a scene is a tile. The ground of course, but also the sky, and even the title on the title screen. I imported those entire images as tilesets instead of backgrounds, because they all have to be on the same layer, and here’s why.

Every pixel in a tile that would be colored is transparent in the image file. Then the color goes on a separate layer behind the tiles. So if I had a normal background behind the tiled ground, or if I had more than one tile in the same place but on different layers, the black pixels would overlap the transparent pixels and cover up the colors.

Also, I tried just setting the background color, but that caused a massive memory leak to constantly hue-shift. So instead I created a single pixel “actor” that’s literally just a 1x1 pixel, stretched it to the entire screen width and height, and then applied the color effect to it.

The result is indeed very cool in my opinion. But then while I was experimenting with the graphics, I got an even better idea.

Subpixels

That screenshot isn’t yellow (*Vsauce music plays*). Instead, if you zoom in far enough, every “pixel” is actually a 3x3 square of pixels with red on the left, green in the middle, and blue on the right.

These are called subpixels, and basically every computer screen has them. They use the additive RGB color model where, in the screenshot above, the red and green subpixels are on, and the blue subpixels are off. The red and green light combines to appear yellow.

I figured out that I can just draw 3 red pixels in a vertical line, then 3 more green ones next to it, and 3 more blue ones next to that, and when you zoom out it works the exact same way. So every pixel is really made of 9 pixels in a 3x3 square, and the game is three times higher resolution than it looks. And simulating these subpixels using pixels that are in reality also made of subpixels creates this really cool visual effect.

To make them appear to change color, I replaced the hue-shifting pixel actor behind the tiles with 3 repeating backgrounds for each of the 3 colors; red, green, and blue. Then instead of applying a tint effect, I change the opacity of each color. In the above screenshot, red and green are both at 100% opacity, and blue is at 0%. For actors like the player, they’re actually made of 3 individual actors each red, green, and blue that change opacity the same way.

It’s honestly one of the coolest things ever. And it makes me want to make more pixel art using this style, because this is only 1% of my power. Imagine if I used a palette of more than three colors. There are so many more ways I could explore this idea.

A Universe of Waves

So I have a game about how, fundamentally, everything you see on the screen is made of just three colors. Three slightly different wavelengths of light. And I also have a song for this game that (well, besides the percussion) is made of triangle waves and square waves with different pulse widths. But even with percussion, they’re all mechanical sound waves anyway.

It turns out there’s something even more fundamental than subpixels here, and it encompasses more than just the visuals. Just like how, in reality, quantum particles may actually be made from excited states in a field, or one-dimensional vibrating strings.

I will once again state that I am NOT an expert on these topics, and I am not qualified enough to be taken seriously. I just think it’s really cool. I’ve spent a lot of time watching Youtube videos and reading Wikipedia articles about these kinds of things, and they’re great inspiration. But I have no scientific education beyond high school, and I refuse to believe anyone who tells me I’m smart. I just make the pixels go brrr.

Some other silly quirks Subpixel has right now

Sometimes the player will face the wrong way as they move, usually when they switch to a non-downward direction of gravity. It might not be that hard to fix, but in the meantime you can moonwalk on the moon.

Jazz_horse found this while she was testing the game. It happens when you cross a diagonal boundary and press and hold both the direction keys that are opposite both the directions of gravity (in this case, gravity is down and to the right, so I press left and up). There are several more places in the game where you can do this, too.

(it doesn't seem like this gif is working, so here's a link to it)

Sometimes when you land on a corner that’s on a diagonal boundary, this happens. It’s a little tough to get out of it, you just have to keep trying to jump and move around. All I really have to do to fix this though is add a tile there, and there won’t be a corner to get stuck on.

I think that’s pretty much everything I wanted to say. I hope everyone had a great Pixel Day. It’s honestly hard for me to keep up with how many people are here that are way more talented than me. Maybe one day I’ll stop making everything for my games myself.

Well I didn’t think I could pull it off this time with how busy I’ve been lately, but I managed to make a Ludum Dare game for the jam. If you haven’t seen it yet, it’s a really hard and fast-paced hack ‘n’ slash called Reaper, where you fight creepers that can replicate similar copies of themselves, and drop health and power-ups.

Its release was down to the wire, with less than an hour before the deadline before I submitted it. And it was a rough start. Creepers were so buggy, they wouldn’t even replicate themselves at all like they were supposed to. I had also just grabbed the code for displaying score from another game, but I forgot to code pretty much everything else for it. And a lot of power-ups weren’t working correctly or at all.

Version 1.0.2 fixes all the major bugs I could find. Also, since 1.0.2, your high score is saved after a game over, but it’s not displayed anywhere so I still need to add that. I had just run out of time and couldn’t get to it.

Honestly, though, I really like this game. It was the perfect chance for me to put together some vague ideas that have been bouncing around my brain for years, and it’s also just really fun for me. It’s ridiculously hard. I really don’t try to make super hard games all the time, it just kinda happens. It was even harder at first because the player’s invincibility frames didn’t work, and I had to fix that. If anybody wants an easy mode, I could make one.

This was also a chance for me to make a remix of a theme that I’ve been wanting to develop further. Way back when I made Spaceblast, I wrote a song called Robot Alien Invasion, and it was one of those songs that was accidentally actually pretty good. It’s perfect for Reaper’s theme, but it only had one verse, just repeating itself throughout the song, and while I think that does work for it, it still wasn’t a complete song. I’m amazed that I managed to make what I feel is a big improvement in just a weekend.

Other than displaying high scores, Reaper is pretty much done. Now with Pixel Day less than two weeks away, I better get cracking on my next game because I just can’t help myself. This idea is just too good.

I just barely managed to get this game in a playable state in time for the jam submission deadline, which I did not think I'd be able to do. Emphasis on "playable." This game about bugs is unsurprisingly quite buggy, but I don't have time to fix them right now because I have to go to work. Have fun with it while I'm gone!

I’ve just updated The Legend of Quintavius to version 0.5. Aside from more bug fixes, it adds a new setting for effects; in addition to just turning them on or off, you can also enable them during cutscenes only, and not during gameplay.

Effects in this game are just Stencyl actors (similar to game objects in Unity), same as characters but much simpler. Since this game has a lot of actors, I wanted to have options to reduce the number of actors for anyone who has trouble running the game, for whatever reason that might be.

But since there’s so many effects, I’ve played through the entire game with each of the three settings to make sure nothing breaks, but it’s still possible some bugs exist that I just didn’t come across. So if you find a bug, experience lag, or the game freezes, you can try a different setting for effects and see if that makes a difference, and let me know if it does.

Now that this update is out (later than I had wanted), I’ll be taking a probably much needed break from The Legend of Quintavius for the rest of the month. In a few days, I will try to make a game for Ludum Dare; it’s most likely going to be in the extra category again. And after that, I’ll start sharing what I’m working on for Pixel Day. To be honest, that project has been stealing my attention from LoQ, and I think you’ll understand why when you see it.

I plan on returning to LoQ in February, and I’ll resume my semi-daily Twitter posts. But instead of doing more bug fixes, I’ll start working on some of the bigger stuff that needs to be done. Because there’s always going to be a bug to fix, even after the official release.

In case you missed it, or if this is the first you’ve seen of it, I finally released that one game I’ve been making for over three years. It’s an open beta pending an actual official 1.0 release because I still have a few more things to work on, but the game is entirely playable from start to finish. If you haven't tried it yet, you can find it here.

So far I’ve released a couple patches, mostly bugs that had escaped me until after launch. I also posted some blogs just talking about the game, not just general updates like this one, but topics I think might be interesting, like how my silly battle game accidentally gave rise to phenomena found in the real world.

Most of my activity has been on Twitter recently, where I’ve been posting semi-daily. Social media is not my strong suit, and I’m a very shy lurker, but I’m just trying to tweet little things about the game and keep a consistent flow. A neat idea I had was this thread of character introductions with a short description, their dialogue picture and animated sprite, and some relevant stats. But something I still need to figure out is how to record pixel perfect clips of gameplay, or as close to that quality as I can get, because my beta trailer could have looked better if I’d known anything about recording gameplay.

I have another update in the works that fixes a lot of problems with effects (which in this game are just a lot of pretty objects), it just needs a lot of testing to make sure it doesn’t break anything. But my progress has been slowing down; the holidays are near and I got pretty busy with some IRL things. I also plan on making another Ludum Dare game in January, and later I want to do something for Pixel Day. But I won’t stop making The Legend of Quintavius for another few months again.