Virtual Keyboard app for Steam Deck and other touchscreen devices.
Working (albeit still WIP) as of Picotron v0.1.0e but not v0.1.0f due to changes in wm. I haven't looked into how much is different but I do know that the way I was switching workspaces is no longer exposed as an event within wm, so that kills the project dead somewhat.
I'm not upset because Picotron is in flux and it was always possible that this could happen. However I feel a virtual keyboard is a must for handheld devices in the future as Picotron is totally unusable without one. Yes, the Steam Deck has a virtual keyboard built into Steam, but hitting Return hides it, so it is impractical. Plus it doesn't have cursor keys which this did.
If anyone can make use of it in the future then that's great. I think I'll have a break from writing apps and focus on games.
0 comments
In the fast moving world of Picotron, the PNG importers have already rendered this mostly redundant, but I thought I'd post it anyway. This little app imports an 8bpp bitmap of up to 64 colours and outputs to clipboard a pod containing the palette and the image, as well as a couple of lines of code to use it. You can specify the palette offset to use, so if your image contained only 32 colours but the project you want to use it in already used the first 32, you can offset it.
I've had decent results using Paint.net, using the Quantize filter to reduce colours and it lets me have good control over dither patterns. So I may still use this for some future projects.
UI design and feedback are minimal. The offset field won't allow for a value which will exceed 64 colours but it doesn't tell you that. I just decided to ship it in it's current state.
I've been working on a bitmap import cart (which I haven't finished yet) - it allows for simple 8 bpp bitmaps to be converted to userdata and then drawn as a sprite, or exported as a pod along with it's palette. You can set an offset for the palette to work around existing carts. Since I don't own Aseprite it means I can use Paint.net or anything else that can reduce colour count and save a bitmap.
Anyway, I had an idea for a screensaver and here it is. Maybe could edit the cloth of her dress and draw some bezier curves to simulate it flowing but that could be a job for another day.
/>load #notgenuine-0
Give your Picotron an authentic Windows feel by adding the "not genuine" watermark over your wallpaper. It isn't forced on top of other windows because I couldn't figure out if or how this was possible.
If you want to close it, Ctrl+click the text.
Controls
cursor / dpad - move the reticle around the play area
z / O - hold and press a direction to shift rows and columns of tiles
x / X - after the timer reaches zero press to start again
About
This is my second entry into the #pico1k 2023 jam. This is a "match 6" puzzle game where you try and clear as many lines as you can in 100 seconds. Featuring hand coded sprites inspired by Columns on Sega Megadrive/Genesis and a smooth addictive control style.
About
My #Pico1k 2023 jam submission, a shoot 'em up written in 1024 compressed bytes. I wanted to capture some of the polish from Lazy Devs Academy's first shmup tutorial, but without having use of the sprite sheet and sfx.
Features
-Sprites created at runtime from ascii
-Some lerping mid-wave
-Invulnerability after getting hit
-Gradual difficulty increase
-Very rudimentary sound effects with what bytes I had left
Controls
Directional to move and O / Z to shoot
On the GAME OVER screen you need to reboot the cart (because I ran out of bytes!)
Somewhat proudly presenting...
TIS-8
Introduction
This is a demake of possibly the least visually compelling and overall ill-suited games to port to Pico-8; TIS-100!
If you are familiar with Zachtronics games (and frankly why wouldn't you be?), you will be aware of this game already but in case you aren't, here's a (non-manual) way of explaining what it is:
TIS-100 is a virtual computer system produced in 1972 featuring a multiple-core architecture. Basic Execution Nodes can have up to 16 lines of assembler-esque code written into them and data is passed from one core to another. Each core only has one accumulator register and a non-interactable bak register. There are also Stack Memory Modules which can have up to 16 numbers pushed to and popped from them. The goal of the game is to read the instructions for each level, take the inputs from the top and using the nodes and modules, output the correct values at the bottom.
Cart features
- the first 17 levels that only feature Basic Execution Nodes and Stack Memory Modules. The Visualization Module isn't implemented in this.
- mostly near as damnit accuracy of the original game. I can't say that the tick/cycle counts will be the same (they won't) or that the ANY orders are the same when multiple nodes are all in read or write contention, but that shouldn't impact on your gameplay experience.
- high scores are saved but understandably code is not. copy and pasting level data is included but was mostly used for playtesting and there is no error checking on paste.
- a somewhat comprehensive version of the manual is included for those that aren't familiar with syntax.
Notes on control
Obviously taking a 100% keyboard driven game and mapping it to a dpad and two buttons isn't easy or even sensible, but I've hopefully made it as painless as possible. I did not want to enable devmode for this game as your Pico-8 didn't ship with a keyboard out of the box! Plus I wanted to play the game on my Linux based handheld emulator device. Controls are described at the top of the manual.
Change focus between three elements; playback, editor and navigation. Circle generally enters and allows edit, whereas Cross backs out. Setting labels on code is probably least intuitive and could do with a slight tweak, but I wanted to ship this nice and quick and it isn't so bad once you get used to it.
Final notes / disclaimer
I hope anyone who enjoyed playing the PC version enjoys this, even if it's a funny diversion. I enjoyed playtesting it and surprisingly the one-node-per-screen limitation wasn't as much of an issue as I feared.
I have done my best to make sure inputs and outputs are correct, but entering hundreds of numbers on a 65 key keyboard is likely to result in a typo and if that has happened, I apologize wholeheartedly. Let me know if there's an issue and I'll fix it. Likewise if you notice an issue with code you've written, please drop a comment below and I'll see what I can do. Tokens and most of all size are quite tight now.
Lastly, if the thought of playing this game interests you and you have not played the original (or any Zachtronics game), please please please check them out. Zachtronics literally gave birth to the Zach-like subgenre of puzzle games so give them a little love! Zachtronics' website
This is an exercise in whether I could and not whether I should try and write a primitive 3D engine within 1024 compressed bytes. Turns out I could but visually it would've been better to fake it. Nevertheless, I thought I would upload it here anyway. As it's pretty rough I won't enter it officially into the jam. It would be interesting to see how people from the community who are more proficient go about the same challenge.
It lacks any depth ordering so I put some dithering in there which I wanted anyway and helps mask the problem. Similarly I thought it would be cool to have a street light effect on the "road" so dithering was used there. It also has some really ghetto hacks to prevent clipping.
Thanks @freds72 for the tri fill code from SupaHex.
Maybe this one's better overall:
Entry for the PICO-8 1k Jam, where only code is allowed (no sprites or audio) and compressed size is limited to 1024 bytes.
This is a demake of Super Hexagon. Controls are just left and right - avoid the walls for as long as possible! After game over, the game will reset after a short pause. High scores are saved.
Credit for the smallest triangle fill code goes to p01.
Revision 2: removed a remark (facepalm), made a small increase to the wall gaps, tweaked the game over screen to be quicker and wait for a button press, reduced flashing of timer a bit. 4 bytes free but can't really use them anywhere. Thanks for the feedback all.
This is a WIP demake of The Witness, a puzzle game released in 2016 on PC and subsequently consoles and phones. Although the original game was more involved (no spoilers here in case people haven't played it), the core mechanic involved drawing lines on boards to satisfy the logic of symbols placed on the board.
I'm uploading now as (I hope) I've just finished the logic on the "tetris piece" blocks which are arguably the most tricky to implement, though rotating versions still need to be written in. The original game was brilliant in introducing new symbols in a progressive way, so the player learnt the nuances as they played. I'm hoping my scaled-down finished version will do this too, so I don't want to spoil by explain the logic here. Hopefully there will be some players of the original here that can give this a play and let me know if there are any bugs.
Press Z/O to start drawing a line and X to cancel. When the end of the line is at the exit point (the nub that extends outside the grid), press Z/O again to see if you were correct. Currently the line is moved by the smallest grid increment but I'll change this to jump to "intersections" to speed up drawing.
There are six levels in this build and you can skip to the next one from the pico-8 menu. Levels are written to memory in the format I want to pack them in the end, then indexed and loaded.
Todo:
Mirrored lines
Testing multiple exits
Title screen and level select menu
Level editor
General polish
Changelog:
210116: Fixed issue with invalid starting moves (thanks for flagging, @dw817)
210116: Implemented rotating tetris pieces. Not decided on a graphical approach for these yet - the original have the pieces slanted but I don't have the pixel count to do this. So for the time being they rotate slowly.
Hey folks,
So I bought Pico-8 last weekend and have spent a few nights reacquainting myself with Lua (which I hadn't used much of before anyway) and learning Pico-8's nuances. I figured since I was still learning I would recreate one of my favourite puzzle games of all time - Lumines.
I will warn you, the graphics and (especially) sound are a bit rough. Also, I borrowed the fade code from Zep but re-purposed it to sort of fade in. It sort of works. I'll have to make an effort to learn exactly what that does.
But the gameplay itself is fine I think, adhering to the rules of the original. Scoring is a bit broken due to the integer limit and I haven't really looked into ways to get large integers yet.
If you fancy improving it be my guest! Likewise if you want to use some elements of it elsewhere (as unlikely as that sounds) that's fine too. It isn't really commented as much as it should be (sorry!)
Anyway, have fun!
Cheers,
WeeblBull
