So in my last blog, I low-key announced that I’d be making another Flash game.
So I had a crack – and I went pretty hard on it.
I’ve wanted for ages to make a Flash game that does some genuinely weird technical fake 3D stuff. To that end, I actually succeeded. The rendering system works, the world works, and it feels satisfying to finally scratch that “fake 3D” itch I’ve been wanting to explore for so long.
But despite all that… I think I’m tossing the project.
Still, I wanted to show it off because I think the tech behind it is cool, even if the game itself never fully materialises. At this point it’s more of a tech demo than anything else.
The Stack
This project runs in Flash via Ruffle, and was built using OpenFL and Haxe.
For anyone unfamiliar:
- Haxe is a programming language that feels a lot like ActionScript 3, except modernised and significantly nicer to work with.
- OpenFL is a Haxe library/framework that lets you target a huge range of platforms – including SWF, which means you can still build games for the Flash runtime that Ruffle emulates.
- Tiled Editor was used to create world data. It’s a free and powerful software that is excellent for building tilemap worlds. I used it only for data and object placement.
Why use this setup instead of just using Flash directly?
Because once you start doing technical fake-3D rendering tricks, you’re basically writing a tiny graphics engine. I wanted something with a more robust modern programming workflow behind it, and Haxe was perfect for that. It has all the familiarity of AS3, but without feeling trapped in 2009.
What Went Right
It’s 3D! Kind Of!
The game simulates a 3D world, but without using actual 3D models.
All the characters and objects are billboarded sprites placed into a 3D space. Think something along the lines of Cult of the Lamb, flat artwork existing inside a dimensional world.
I absolutely love this aesthetic.
The system works something like this:
Instead of every object fundamentally being a MovieClip, I built a raw GameObject class. Every GameObject has its own world-space coordinates — X, Y, and Z positions. The camera works the same way.
Each GameObject also owns a MovieClip/sprite, but that sprite only exists as the visual representation.
Then there’s a projection system.
The projection script takes:
- the camera position
- the camera angle
- the GameObject world position
…and runs projection math to determine where the MovieClip should appear in 2D screen space.
So instead of directly moving MovieClips around, I tell objects where they exist in 3D space, and the camera + projection system decide where the visuals belong on screen.
Which is sick.
Once that was working, I could do distance-based tinting and fog effects too. Objects further from the camera gradually fade into atmospheric colour, and it gives the whole thing this really cool faux-depth look that I’m super happy with.
The code base is elegant is some places and chaotic in others. I mimicked Unity and Godot style methods for manipulating gameobjects with Transforms and stacking Components.
What Went Wrong
It’s Slow as Hell
There are just too many operations happening constantly.
Too many sweeps.
Too many projection calculations.
Too much sorting.
And while Flash is flexible enough to do impressive things, there’s definitely a ceiling to my ability to push it beyond what it was built to do. People more clever than me have made their own 3D simulations in Flash with far greater success.
Another issue was controller support.
One thing people forget is that Flash/AS3 actually had pretty solid native gamepad APIs. But Ruffle doesn’t currently implement that functionality, so getting controllers working becomes this awkward JavaScript injection workaround situation.
Which feels lame.
I also started running into problems with my level-building workflow.
I wanted my tilemap system to support much larger prefabs and more flexible environment construction, but I’d kind of boxed myself into using Tiled in a way that started feeling restrictive. Every time I wanted to expand the system, it felt like I was fighting the tooling.
Eventually I hit the point where I realised I didn’t actually want to continue building on top of this foundation.
This kind of game is honestly a job for Unity or Godot, it’s just be so much easier.
So… What Now?
I still really want to make something that captures this “2D art inside a 3D world” feeling using Flash-era aesthetics.
I love the look too much to abandon it completely.
But for now, this particular project is heading to the project graveyard.
That said, I can absolutely see myself revisiting these ideas in either Godot Engine or Unity sometime soon. I’ve spent a lot of time improving my tooling and workflows in both engines lately (especially for handling stylised 2D art) and I’m keen to experiment with those pipelines properly.
As for developing another Flash game, a true .swf file game, I’m still wanting to do this too. The lesson I’ve learned is to not overcomplicate things. The golden ‘rule holds true “KISS” holds true… Keep it Simple, Stupid.
So while this specific Flash experiment may be dead… I don’t think the idea is. And I’m already working on the next thing. I look forward to sharing more about that in the near future.