the fantasy console I desire
The fantasy console I want is one which tries to optimize for interesting bugs. The obvious way to do this aligns with the desire to make games easy to make. Namely the default arrangement of things should be a playable game. So there should collision and player controls by default which you add code to modify. Most possible configurations should try to map to something ~playable rather than a hard crash or just freezing or falling through the map.
Ideally, it should be possible to accidentally program a creepypasta game. really put the fantasy in fantasy console. Maybe if you write outside of memory in a particular place it runs a filter over your sprites that heuristically makes the sprites bleed from the eyes.
I think maybe the console memory should be segmented into N stacks of 256x256 byte fields, where many of the layers have a special meanings (like tileset, sprites, audio, pallet). This way you can graphically display memory which makes it more interesting to debug perhaps and also gives rise to novel programming challenges (which makes programming more interesting). Besides the default of displaying memory according to a color index, there should be special modes for displaying the other layers of memory is debug/edit mode.
Ideally writing a random value to a random location in memory should either do nothing, or do something observable while keeping the game ~playable. (this implies that lots of the actual real game logic needs to happen in the “hardware” of the console). We want bugs to be entertaining rather than just crashes.
Perhaps programming should happen in a sorta CISC-type assembly, but with plenty of application specific commands, so programming isn’t hard, but it has the aesthetic of being low level. Ideally designed in a way to let you or even encourage you to do wacky stuff like self modifying code, or playing with integer overflow. Perhaps have commands which change how the instruction pointer is incremented, and thus let you run your assembly both forwards and backwards, or even left to right (since we are 2D) Making the assembly very high-level (like having a command for “change player velocity by X” or “mark X type of object as playable collidable” means that if assembly is in memory, then changing your code randomly will add.
Maybe half of my idea could be described as “what if memory corruption was fun and exciting?” and thus we can encourage normally memory corruption prone programming methods.
perhaps the console should have a strong sense of “defaults” where the default is
It might difficult to include neatly but the option to switch to an execution mode where assembly instructions are read out of just the lower bits of the bytes which allows you to layer assembly code into your sprites could be fun. (the code is somewhat visible in the displayed sprites, but it is subtle)
It would be fun if there was more advanced commands that to trigger you have to draw out magical sigils and do demonic sacrifices (this would also enable more of the creepypasta bug traps). It would have to be for something big. Perhaps unlocking additional layers of memory.
The fantasy console emulator performance could be an issue since you are definitely not JIT compiling this code except if you do a very fancy speculative compiling where it appears that some code isn’t being modified soon. But modern computers are pretty fast, and everything else about this game engine is for low-end games. Plus, many of the more computationally expensive aspects like rendering or collision detection are done inside “hardware” of the game console. So I think it would likely be runnable.
if someone wishes to steal this idea from me and make it themselves, I would be very pleased as I have other ideas I wish to work on more, but wish to play with this fantasy console.
