55 |
Hey Everyone! PICO-8 0.1.11d builds are now live on Lexaloffle and Humble! We are still working on CHIP / Pocket CHIP builds -- I'll update this thread when they are live. [Edit: they're live now with 0.1.11g]
Welcome to the Core
Despite the unassuming version number of 0.1.11, this update marks something of a milestone: The core of PICO-8 is now feature-complete, with API and specifications that are likely to remain fixed. Before it becomes entombed as a read-only blob of C code however, there is still some time before beta to address any issues that crop up. Let's see how 0.1.11 works out and what points of friction emerge.
One of the goals of PICO-8 is to create a stable, familiar medium in contrast to the shifting sands of modern software development. Instead of growing by changing the core of PICO-8 over time, I'm aiming to settle on a minimal, eternal component that can be built on top of (improved tools and bbs integration), extended sideways (extra ports / host platform support), built out from the inside (making useful snippets and carts!), and around (nicer BBS, cartverse, documentation, resources and community events).
v0.1.11 is also the point after which PICO-8 and Voxatron co-development start to part ways -- Voxatron's API and specification is a superset of PICO-8 v0.1.11's. The upcoming Voxatron update looks basically like a 3D PICO-8, with its own version of splore, png cart format, labels, and bbs integration. I messed up the Voxatron release plan partly because of committing to this -- but more on this later in a separate post. o(_ _)o
Many thanks to the numerous PICO-8 users who helped iron out bugs in the 0.1.11 release candidates. I snuck 0.1.11 out via twitter thinking it was pretty solid, but it took 3 more builds to get right. If you find any old carts that don't run or behave strangely, please ping me on twitter, or better still, post a bug report in the support forum. There will be another follow-up (0.1.12) to catch any left-over issues. After that it will be onwards to beta (0.2.0) \o/
Also special thanks to Gruber for help with the SFX editor, rez for helping shape fill patterns & cpu changes, and everyone who posted thoughts and suggestions on the BBS -- many of which I folded into this update. I haven't posted much this year due to going into blinkers-on just-make-the-thing mode, but I do read and appreciate every piece of feedback. I'll be re-visiting some older posts to update how things have turned out, and I'm also looking forward to joining the party and making some more carts too :D
New Features
Binary Exporters
PICO-8 can now generate stand-alone, distributable binary versions of carts and multicarts for Windows, MacOS and 64-bit Linux (dynamically linked with SDL2). Use the export command with a .BIN target, with the -I switch to choose an icon (or skip to use the cart label by default):
> EXPORT JELPI.BIN -I 48 JELPI.BIN JELPI.BIN/WINDOWS JELPI.BIN/LINUX JELPI.BIN/JELPI.APP |
Multicarts can be created the same way as exporting HTML -- just add up to 15 .p8 or .p8.png filenames at the end of the EXPORT command. Bundled carts behave just the same as local files -- they can be RELOAD()ed, CSTORE()ed to, and chain loaded with LOAD(), using the new breadcrumb and parameter features explained below.
SFX Instruments
Until 0.1.10, each of the 32 notes in a SFX were internally described with 15 bits: 6 for pitch, 3 each for instrument, volume and effect. 0.1.11 adds one extra bit to round out the 2 bytes: "SFX instrument mode" that can be set by toggling the button to the right of the instruments list.
When it is set, the instrument buttons turn into indexes 0..7, and when placing notes you'll see the instrument index appear green instead of pink. Instead of playing the built-in instrument, these notes will trigger the SFX of that index. In other words, SFX 0..7 are acting as instrument definitions. Each note will advance at the same speed as the definition, with the pitch shifted (relative to C-2), the volume multiplied, and the effects layered on top of each other. This can be used to reach a greater range of pitches, create per-note changes in texture and tone, and set up detailed volume envelopes.
Here's a rundown of other new SFX editing features, and a quick introduction to SFX instruments by Gruber (check out the other tutorials too!):
Fill Patterns
Along with SFX instruments, fill patterns are a late addition to the PICO-8 spec. In both cases I was planning to keep them as secret features, but they turned out to be too much fun and I couldn't wait! From the manual:
fillp p The PICO-8 fill pattern is a 4x4 2-colour tiled pattern observed by: circ() circfill() rect() rectfill() pset() line() p is a bitfield in reading order starting from the highest bit. To calculate the value of p for a desired pattern, add the bit values together: .-----------------------. |32768|16384| 8192| 4096| |-----|-----|-----|-----| | 2048| 1024| 512 | 256 | |-----|-----|-----|-----| | 128 | 64 | 32 | 16 | |-----|-----|-----|-----| | 8 | 4 | 2 | 1 | '-----------------------' For example, FILLP(4+8+64+128+ 256+512+4096+8192) would create a checkerboard pattern. This can be more neatly expressed in binary: FILLP(0b0011001111001100) The default fill pattern is 0, which means a single solid colour is drawn. To specify a second colour for the pattern, use the high bits of any colour parameter: FILLP(0b0011010101101000) CIRCFILL(64,64,20, 0x4E) -- brown and pink An additional bit 0b0.1 can be set to indicate that the second colour is not drawn. FILLP(0b0011010101101000.1) -- checkboard with transparent squares |
[tweet ]
Code Tabs
You can now organise your code into numbered tabs. They are not separate files, but rather the same block of code chopped up with special markers (internally: "-->8"). Hovering over a tab number displays the first line of code if is commented, which can be used as a makeshift method of naming tabs. To remove the right-most tab, just delete all of the text in the tab and then move off it.
Editing operations like undo, search and selections apply per-tab. It isn't currently possible to search across tabs -- this will be added later along with improved error messages that span multiple tabs.
Commandline Scripts
The new -x parameter to PICO-8 can be used to run carts as part of commandline tool chains. For example, if you have a long-winded process for copying data around and generating large multicarts, you could automate the process by creating a single cart that does the job:
-- BUILD.P8 CD("MYPROJ") LOAD("TITLE.P8") EXPORT("MYGAME.BIN -I 1 LEVEL1.P8 LEVEL2.P8 LEVEL3.P8") |
And then run PICO-8 from commandline:
$ pico8 -x build.p8 EXPORT /home/zep/pico8/carts/myproj/mygame.bin -i 1 level1.p8 level2.p8 level3.p8 |
This will execute each line of build.p8 as if it had been typed in from a fresh boot of PICO-8, but without ever opening a window. It isn't truely headless yet because it still requires SDL2 (along with the video/audio driver) -- e.g. you can still play sound from it. I'll look at improving this in the future for people who want to make twitter bots and whatnot.
HTML Templates / Plates
This is still a work in progress as I don't have any sample plates to offer yet! But the basic concept works: you can put html files in {app_data}/pico-8/plates, and use them as templates for the html exporter. The template should include a magic string ("##js_file##") in place of the accompany javascript file's name:
<script async type="text/javascript" src="##js_file##"></script> |
The template (in this example, one_button.html) can then be used when exporting like so:
>EXPORT FOO.HTML -P ONE_BUTTON |
The P is for 'Plate'. I use this more general term because they can act both as templates (custom control schemes like single-button, or to add technical javascript features) and also as faceplates (custom graphics around the PICO-8 screen e.g. based on the theme of the game). When doing the next round of website updates, I'll look at creating a way to submit plates as a community resource.
It is also possible in 0.1.11 to export the .js file separately (EXPORT FOO.JS) so that it is easier to work on the accompanying .html in the same folder as the exported cart.
Splore Menu
An extra per-cart menu can be accessed from splore by pressing the menu button (X and O still immediately launch the cart as before). This menu allows you to open the cart's BBS thread, remove it from favourites, and open a minimal options menu. The options menu includes SHUTDOWN which allows PICO-8 to be used from start to finish with only a controller (in -splore mode).
Extra splore tip that I forgot to mention in the docs: instead of typing SPLORE, you can use just S.
API Changes
- add() returns the value that was added
- assert() can take an optional error message parameter
- coresume() returns an error, making it useful to wrap with assert: assert(coresume(foo))
- getmetatable()
- sfx() takes a 4th parameter: number of notes to play
Time and Date
You can now grab the current local and GM time with stat():
80..85 UTC time: year, month, day, hour, minute, second 90..95 Local time |
Check out the ClockJam!
CPU Costs
There are many adjustments to the cost of calling api functions in 0.1.11. Some of them are due to fixing bugs including the ability to trick PICO-8 into giving back unlimited CPU cycles (!), some are to make costs feel more consistent with each other, to more accurately reflect the real world cost of the host machine (pffft -- like that matters), and finally to give a small bump to graphically intensive carts now that making 60fps carts is becoming more common.
I've tried to tread lightly on the heavy optimisation work done by cartridge authors. For example, kragzeg's technical articles on Dank Tomb rendering are still true. The general rule is that existing carts will run around the same speed as before, or a little faster depending on the operations they use. In a few rare cases they run slightly slower, and I am humbly offering low-cost pattern filling as compensation :P
- Horizontal scan fills are now super-fast (rectfill, circfill)
- sspr() is now the same speed as spr() per-pixel
- line() is faster -- but better to use rectfill() if axis-aligned
- bnot() and peek() cost 1 lua vm instruction more
- Fixed cost calculation of clipped gfx operations
Cartverse Preparation
The PICO-8 cartverse is a collection of interconnected webs of PICO-8 cartridges that can (optionally) exist independently of the BBS, and in the future the BBS will provide entry points to the cartverse rather than being a container for it. This update includes some of of the features needed to achieve this, and the are also useful separately:
BBS Cart Loading
Use LOAD("#45481")
to load a cartridge directly from the BBS. The number can (and normally should be) the containing post id, (not the id of the cart itself), in which case the most recent version of the cart is fetched. This can be called from a running cartridge, in which case the cartridge is immediately launched.
Breadcrumbs
Breadcrumbs allows the user to return to previous carts, much like the back button on a web browser. When LOAD()ing a cart, a second parameter can be used to request that the launched cart inserts an option in the pause menu to get back. The value of the parameter is the label of that button:
LOAD("#45481","BACK TO LAUNCHER")
Parameter Strings
The third parameter to LOAD() is an arbitrary string up to 1024 chars long that can be read by the receiving cart with STAT(6)
. When using a breadcrumb to get back to a cartridge, the parameter that cartridge was initially run with is restored.
The parameter string can also be set with RUN from the commandline: RUN BLAH DE BLAH
Custom BBS Functionality
This isn't a feature by itself but can implemented using these new features. Because the cartverse sits alongside the BBS, it will be (and maybe already is) a viable way to extend the functionality of the BBS. For example: when hosting a jam, instead of having customized web-based theme selection, cart listings and voting, we can do it all with carts. An invite cart could have a countdown clock + a link to a separate theme voting cart when it becomes available, and then afterwards a voting cart could link to all the entries and store results voting on itself. There isn't yet a tidy way to send data back to the jam host, but there will be later! I will try this out for P8JAM3
:D
Changelog:
A heads up for Voxatron users -- the first version of the Lua api will be out next week in 0.3.5!
Pictured above is the result of drawing voxels directly into a room's map. The 0.3.5 api also provides access to actor attributes and state, spawning, camera control, and direct access to the display. The entire PICO-8 api is in there with some 3D counterparts (line3d, box, sphere), and it's possible to import a pico-8 cart into the resource tree, place it in a room, and run the cart on a single slice of the display. The .p8 cart shows up in the resource navigator, and is placeable in the room like this:
The code can also be edited to make slight adjustments for the 3d display:
In other news, I've updated the website with mobile-friendly cart listings and touch controls for the carts. It's still a work in progress -- the sound in particular is very choppy or missing altogether. But apart from that it is quite useable. If you have a modern phone or touch device please try it out!
32 |
Hey All -- PICO-8 0.1.10 builds are now live on Lexaloffle and Humble!
Update: 0.1.10b is up with bugfixes for the html exporter. (Changes)
Update2: 0.1.10c is up with fixed atan2()
Multicart Exporter
The EXPORT command can now be used to create a single .js (and .html) file that contains more than one cart. All of the carts can read, write, and run each other as if they were local files loaded from PICO-8. To do this, add the names of up to 15 extra cartridges you'd like to include in the export: (.p8 format only in 0.1.10)
> LOAD MENU.P8 > EXPORT MEGACART.HTML JELPI.P8 DRIPPY.P8 CAST.P8 |
Inside the program, you can then use RELOAD() to grab data from other carts:
-- GRAB JELPI'S SPRITESHEET RELOAD(0,0,0x2000,"JELPI.P8") |
Or load and run other carts:
-- THIS WILL AUTOMATICALLY RUN THE CART LOAD("JELPI.P8") |
CSTORE() also works in this context, either for a cart to save over itself or to write data to other carts. Each time a different cartridge is accessed, you'll see the spinny cart animation to show that a swap is taking place.
Multicart exports offer a way to package and distribute what you can already do with local files (e.g. zipping up a group of carts), but isn't supported on the BBS and probably never will be. I think feeling invited to design for single 32k carts is an important aspect of PICO-8, so separating multicarts to the exporter is a way to preserve that to some degree while still broadening the scope of what can be made with PICO-8. Future binary exporters (Windows, Mac, Linux) will also support multicart in the same way.
Glitchy Reset
Resetting via the pause menu (press enter) now corrupts the ram in a semi-realistic way for a moment, just like some old hardware might. Carts glitch out in different ways depending on how they use the RAM! Here's Mistigri:New Demo Carts
Use INSTALL_DEMOS to add BOUNCE.P8 and SORT.P8. These are intended to be useful for teaching basic programming and computer science concepts. Eventually PICO-8 will come with a bunch of printable lessons that refer to the built-in demos.Code Editor
You can select and then tab / shift-tab to control indentation the selected lines of code. Also double-click to select a word, and ctrl-left/right skips across words.EXTCMD
This is function can be used to control taking screenshots and videos at precise times from within the code. From the manual:
extcmd x Special system command, only works when running a local cart. Where x is a string: "label" set cart label "screen" save a screenshot "rec" set video start point "video" save a .gif |
Raspberry Pi Improvements
0.1.10 now includes wiringPi statically linked (for gpio), so you shouldn't need to install anything else in most cases. The dynamically linked binary is back too.I couldn't get the X11 driver to work with gles, so it defaults to rpi without windowed support. If anyone is keen to try building their own SDL2 with working X11 support, you can run pico8 with:
env SDL_VIDEODRIVER="x11" ./pico8_dyn |
The mapped keyboard events for text input (SDL_TEXTINPUT) also seems to be broken for some raspis (so far observed on 2nd generation units), so 0.1.10 now detects if this is happening and uses a hard-coded US layout based on keydown events instead.
Full changelog:
PICO-8 0.1.9b builds are now live on Lexaloffle and Humble.
This is a bug-fixing update, mostly for crashes related to switching between widowed mode, full-screen and minimized windows. I've also included the dynamically linked pico8_dyn versions in the linux archives, that were missing from 0.1.9.
The Windows installer & .zip file include a more recent sdl2.dll, although there weren't any known issues relating to that.
I've switched back to shift-a..z for glyph entry in the code editor, as alt-a..z is sometimes reserved by the host operating system. If you find yourself accidentally entering the extended characters by accident, you can turn this off in config.txt (near the bottom). To enter glyphs without shift-a..z, press ctrl-k to toggle glyph mode.
Changelog:
v0.1.9b Added: Alternative function key mapping: ctrl-6..9 for F6..F9 Added: Alternative glyph entry method: (ctrl-k) to toggle glyph mode Changed: Enter glyphs with shift a..z, but can be disabled in config.txt Changed: Increased emscripten ram to 128MB (some carts at risk of running out) Fixed: Crash when window size is tiny or minified Fixed: Crash on toggling fullscreen mode Fixed: printh can write files outside filetree (security issue) Fixed: show_fps (can also now be toggled with ctrl-1) Fixed: Shorthand if/then syntax error when using the form: (functionname)(param) Fixed: log.txt not saved in path specified by -home switch Fixed: Default application data folder created even when -home specified Fixed: Missing dynamic builds (pico8_dyn) from linux archives Fixed: Removed unneeded RPATH from linux binaries Fixed: export foo%d.wav fails to write multiple files |
23 |
Hey All -- PICO-8 0.1.9 builds are now live on Lexaloffle and Humble!
Posting Carts via Clipboard
The handiest new feature is being able to post cartridges to the bbs via the clipboard, without ever saving it as a png. Use "SAVE @CLIP" to copy to the clipboard as text, and then paste it into a post (hit Preview to make sure it worked and to get rid of the wall of text). You can also copy carts from the BBS (look for 'Copy' under each cart) and paste it back into PICO-8 with "LOAD @CLIP")Posting GFX via Clipboard
You can also do the same thing with sprites. Using CTRL-C in the sprite editor also stores a copy of the sprites as text in the clipboard, and can be pasted back and forth to BBS posts. Here's an example: (click the 40x8 and then CTRL-C the text to copy&paste it back into a cart)
[0x0] | |
Jam
There's a new category in the BBS called Jam, which shows up in SPLORE. The Jam sub-forum (along with clipboard cart&gfx pasting) will be useful for things like the Tweetjam thread and for having a natural place to discuss / post ideas for external jams like Ludumdare.
I originally envisaged Jam-related stuff going in Collaboration, but I think Jam can grow into something quite worthwhile and separate. Collaboration will also be extended at some point to include a 'snippet library' of re-useable pieces of code/gfx/audio, which feels quite different from jamming.
Raspberry Pi GPIO
If you have a Raspberry Pi and an LED, try jamming one end into GPIO1, and the other one into GND, and you can make it blink on and off with POKE(0x5f81,255) and POKE(0x5f81,0). Note that you'll need to run PICO-8 as root: sudo pico860FPS HTML5
Exported html can now run at 60fps. To improve performance, the web player now always runs on a 128x128 rather than performing the scaling in software. If you are writing your own html shell for the exported .js, you'll need to do an unfiltered scale of the canvas to the desired size. (See the default exported 0.1.9 html shell for an example).Pixel-Perfect Scaling
When changing the window size of PICO-8, or swapping from a window to fullscreen, PICO-8 now chooses the largest integer scaling factor that will fit inside the window to avoid blurry filtered pixels. For example, on a 1920x1080 real-world display, the largest scale is 8 which gives a 1024x1024 PICO-8 display.PocketCHIP Update
We're working on it! I still can't give an eta on the PocketCHIP update, but the latest build is in testing and looks good across kernel versions, including GPIO access (so will likely skip to 0.1.9). It still needs to be coordinated with other things happening at Next Thing Co. though, so I'll keep you updated here.Coming Up
There are still a bunch of small issues with the editors I'd like to improve, but PICO-8 is starting to look pretty close to beta! Next up will be website improvements to complement the clipboard & Jam category additions, and also long overdue support for touch devices. The main feature missing for beta is being able to login and submit scores from carts using SCORESUB(LEVEL, SCORE).The next Voxatron update also has some new PICO-8 stuff -- the first version of the Voxatron API is a superset of PICO-8's and allows mapping one slice of Voxatron's display to PICO-8 video memory. (The display is basically a stack of 64 PICO-8 screen). So you'll be able to load PICO-8 cartridges into a Voxatron cartridge and make wee arcades and weird 3d ports and whatnot. It's fantasy consoles all the way down!
changelog:
Here's a 7500 word dictionary cart for making word games and whatnot. It contains the most common 3-6 letter words according to wiktionary.com, including proper names. The loader is 264 tokens, and the data is 11317, stored over the full map (including shared gfx), plus the last 44 SFX. So there are just 128 sprites and 20 SFX spare. The 5 most common and 10 least common words on the list are:
THE AND THAT WAS HIS RADIUM BAWL LINTEL WAFER WELTER AUNTY OPTICS SIKH LIL BARB |
Technical details..
The data is generated using a convoluted toolchain process, that I'll post later on if I find time to organize it into something useful.
The compression works by enumerating every possible word in order of word size first, and then alphabetical order. So, A is 0, B is 1, AA is 26, and so on. This means that to store the whole dictionary, only the distances between each word's index is needed. There are many clusters of close words (e.g the distance between CAN and CAP is only 2), so the distances are sorted into range categories depending on how many bits are needed to store each range. Repeated categories are common and so can be encoded with a single bit -- otherwise a 3-bit value is used to store the category for each distance. The encoding utility greedy-searches sets of 5 category bit-lengths and a roman cypher to try to optimize the encoded size, which saved around 1k compared with hand-optimizing the parameter set.
UPDATE!
PX8 has been replaced by PX9: https://www.lexaloffle.com/bbs/?tid=34058
But I'll leave this here for reference, and for existing projects using PX8.
This is a library mostly for compressing graphics and maps, but can also be adapted to compress sfx. It is designed for data-heavy carts and requires around 450 tokens for decompression, although this can be reduced if needed by removing remap(), hard-coding parameters, and/or removing predicted spans at the cost of compression performance. If someone wants a smaller/weaker version, let me know!
To use it, compress a 2D rectangle to an address in memory, and supply a function for fetching the source values (normally SGET or MGET). For map data, you probably want to set p.cbits to something like 4 first.
COMP(0, 0, 128, 64, 0x2000, SGET) |
0x2000 is the address of the top half of the map, so this will compress the top half of the sprite sheet (128 sprites) and write the compresed data over the map data.
DECOMP() takes the memory address of the compressed data, the top left corner of where to decompress to, and functions for getting and setting decompressed values. So to decompress this data at 0x2000 back to the screen, starting 32 pixels down:
DECOMP(0x2000, 0, 32, PGET, PSET) |
Only the decompression section of the code is needed once you have compressed data stored on a cart. A typical workflow would be to make a utility cartridge that grabs data from multiple source cartridges (using RELOAD() with a 4th parameter to indicate where to read from), and then CSTORE them to a single cartridge (again, using CSTORE()'s 4th external cart parameter).
Here's an example that stores 2-byte lengths at the start of each compressed block, to allow seeking out the start of any given gfx. I've commented the cstore and reload lines so that it will work if you paste it at the end of the main PX8 cart example:
The Algorithm
I started working on PX8 while working on PICO-8's specs, as an important question was how large a game could theoretically be for hard-core users who want to go to the trouble of compressing stuff. It became something of a brainworm, and releasing PX8 is a way to get this out of my system. I hope it is also useful to someone, or at least interesting.
PX8 is (AFAIK) a novel algorithm that appears to work well for typical PICO-8 data, and out-performs pngcrush -brute for the few 16-colour images I tested. Alternating spans of predicted and non-predicted values are stored:
-
Predicted values (colours) are calculated by maintaing a table of the last encountered matching neighbours: if a match top & left is found, that is taken to be the prediction. Otherwise, a match for only top, and then only left are considered. Failing those, the value is taken to be non-predicted.
- Non-predicted values are stored as indexes into CLIST; a list of literal values that are stored in the order they were last encountered. This means that recently encountered values have smaller indexes, and the encoding exploits this, along with the fact that each index can not possibly be for the failed prediction (in which case it would be part of a predicted span).
Each span is strictly made of either all predicted or all non-predicted values. This means that for predicted spans, no additional information needs to be stored except the length of the span itself. And conversely for unpredicted values, the index into CLIST is known to not point at the predicted value. This means that no colour index data needs to be stored for 2 colour images at all, and the compressed data is composed entirely of span lengths.
15 |
Hey All -- PICO-8 0.1.8 builds are now live on Lexaloffle and Humble! Note that there was no 0.1.7 release for Desktop; there were in-development versions of 0.1.7 released early for web and Pocket C.H.I.P. to resolve pressing issues, so I'm calling this 0.1.8 to keep version numbers in sync across platforms. New stuff:
60 FPS support
This breaks the 'every cart runs the same on all PICO-8s' rule of PICO-8's design philosophy a little bit, but I think it's worth it! On all of the desktop host platforms, it is now possible to make cartridges that display and update at 60 frames per second instead of 30. You don't get any more CPU though, so that means half the usual CPU allowance per frame. From the manual:
:: Running PICO-8 at 60fps If _update60() is defined instead of _update(), PICO-8 will run in 60fps mode: - both _update60() and _draw() are called at 60fps - half the PICO-8 CPU is available per frame before dropping down to 30fps ** please note that not all PICO-8s support 60fps. On machines that do not support it, _update60() will instead be called twice per frame and _draw() at 30fps. You can check the behaviour of your program running at 30fps by adding the following snippet to the bottom of your code: u60=_update60 _update60=nil function _update() u60() u60() end |
Button Glyphs
The two action buttons on the PICO-8 controller are called O (BTN(4)) and X (BTN(5)). To make it easier to print instruction in-game explaining the controls, you can now insert glyph characters directly into strings in your code with Shift - U D L R O X.
Long GIFs
Adjust the maximum GIF length in config.txt or by running PICO-8 with -gif_len n switch, where n is the number of seconds to record for (maximum: 120). The GIF output is not optimized, so you might want to run it through an optimizer to get smaller file sizes.
Custom Menu Items
It is now also possible to add your own items to the pause menu to trigger things like 'RESTART PUZZLE' or 'EXIT TO OVERWORLD'. Here's an example program:
col=12 function _draw() cls() rectfill(0,20,127,107,col) end function changecol() col = (col+1) end menuitem(1, "change colour", changecol) |
The first parameter is the position (1-5) in the menu to insert the item, the second is the item's label, and the 3rd is a function to be called when the item is selected. I opted to keep this simple and quite rigid, so there's no way to have extra stuff going on in the background while the cart is paused, or to re-appropriate the pause button as an in-game button.
Music Exporter
To record a .wav of a PICO-8 tune, first navigate to the pattern you'd like to start from in the music editing mode, then press escape to enter the console and type:EXPORT SONG.WAV
If the song is looping, it will export around 4:30 that you can then manually trim in a [sound editing program](http s://sourceforge.net/projects/audacity/).
Pre-installed Games
There are now 5 BBS games that ship included with PICO-8, so that it's easy to get up and playing something more than the demo carts, even when internet access is not immediately available. To install them, use INSTALL_GAMES -- they will be accessible from your favourites list in SPLORE. The games are Celeste, Frog Home, Tower of Archeos, Hug Arena, and Dusk Child.Linux Builds
I've included both statically and dynamically linked versions of the executables for i386, amd64 and Raspberry Pi. The RasPi build still depends on bcm, so it is tricky (impossible?) to get it up and running on Chromebooks.I plan to look at better Chromebook support at some point, but it will probably have to be during beta. Pocket C.H.I.P. owners, and later on regular C.H.I.P. owners can expect updates too, of course --- but we are still sorting out details and it will take a while. o( )o
Next up, 0.1.9 will be mostly ongoing bugfixes, and improvements to the web player (optimization, fold-out touch controls for mobile, and controller instructions).
Full Changelog:
The theme for the second PICO-8 Jam was Chain Reaction, and there were 35 entries. Thanks to everyone who contributed and made this jam a another splendid event. I hope you'll join me in congratulating the winning entry, which received a whopping 7.3 PICO-8 star average.. theatrically opens invisible envelope
NuSan! With Combo Pool.
As a token of gratitude for laying down this most excellent cartridge, NuSan will be receiving a commemorative cross-stitch based on the cart.
Also highly rated by participants was another disarming production by JTE: Nora's Mouse Chase, and the beautifully chaotic SPACETANK 9000 by arnodick.
You can play all of the entries by clicking on this montage:
That was fun -- let's do it again sometime soon!
If you'd like to take part in P8JAM2, please select one or more themes by clicking on the PICO-8 star next to it (you need to be logged in). You can change it anytime before the 24h voting phase ends -- at 00:00 PST on Saturday the 21st. Check out the jam thread for more details.
Edit: times's up! The winning theme is Chain Reaction. You have 9 days! Good luck!
Hey All
I'm in the process of simplifying the website a little. In particular, I wanted to improve the experience of playing cartridges in threads by removing clutter. They now look more like a page dedicated to the cart:
- The player starts open
- There's a big obvious play button and large thumbnail
- There's no banner at the top of each page
I removed the PLAY buttons from the thread previews, and autoplay, as I think they're no longer needed -- the whole playable region of a cart is now visible without scrolling after opening the cart's thread, and it's more obvious to new visitors what to do next.
There are still a few small things to finish, but let me know what you think of the new layout, and if there's anything that bugs you.
34 |
Time for another jam! EDIT: The theme is Chain Reaction.
EDIT2:
and... that's time! Thanks everyone who contributed a cartridge! If you submitted something with the p8jam2 tag, you can now rate other p8jam2-tagged carts at the top of the cart's thread.
If you'd like to continue working on your cartridges, feel free -- but please leave the compo version at the top of the p8jam2-tagged threads until voting finishes in one week (June 5, 24:00 PST). Good luck!
Same deal as last time, except with some limited theme voting:
Duration: The Jam will take place from 00:00 PST on Saturday the 21st of May 2016 and will finish at 24:00 PST on Sunday the 29th. So, it spans 2 weekends and 5 weekdays. You can spend as much or little time on your carts as you like. Tiny silly cartridges are more than welcome.
Theme: As is customary with other jams, a theme will be posted at the start and the goal is simply to make a cart (or some carts) during the jam that reflect your interpretation of the theme. Any type of cartridge is ok: games, toys, demos, music carts or pixels.
This time, the theme will be selected by a small twitter poll that begins 24 hours before the jam starts.
Submitting: To submit or update a jam cart before the deadline, just tag it with p8jam2. You can update your cartridge as often as you like before the deadline.
Voting: Jam participants will be able to use a voting widget on all p8jam2-tagged carts, and exactly 1 week after the jam finished, ratings will be tallied.
There will be a small mystery prize for the highest rated cart, but you should enter for glory and honor (or just for kicks).
During the jam, you'll be able to view all carts and posts tagged with p8jam2.
Rules: Teams / collaborations are allowed, in which case you should nominate one user to be the submitter (and voter). Re-using existing PICO-8 cart material is allowed as long as it is ok by the author, and that the carts are publicly available before the jam starts. Submissions should be mostly new material created during the jam, but it's ultimately up to other participants making ratings to decide what's cool and what's not.
If you're looking for a complete portable PICO-8 solution, good news! PICO-8 is going to ship pre-installed on Next Thing Co.'s upcoming PocketC.H.I.P. -- a complete portable mini-computer with built-in storage, wifi, keyboard, battery, touchscreen and everything else PICO-8 needs! The last few months, I've been working closely with the team at Next Thing Co. to create "PICO-8 C" -- a fully functioning and compatible edition designed to integrate nicely with NTC's hardware and software. It will be available to Kickstarter backers, or you can also pre-order one for just $49 bucks.
You can read more about the PocketC.H.I.P. over at getchip.com
18 |
Here's 0.1.6! You can download it from your updates page while you're logged in, or from your Humble Store Library. Just a reminder, that if you're a Voxatron alpha customer, you also own PICO-8! (it should show up automatically in both places).
By far the biggest change is the addition of SPLORE, a complete bbs and local cartridge explorer. You can run it by typing SPLORE, or start PICO-8 with "pico-8 -splore". If you plug a joystick in and auto-boot into splore, it's possible to navigate everything using only the 6 buttons + menu button.
This version also has a lot of new data storage functionality. Cartridges can cstore() to themselves in order to save extra data, and this is now officially supported on the web, so don't feel like it's a weird hack that's going to break! (actually it might break, but it's supported, so I'll fix it :p). Here's a demo:
Notes on cartridge storage, and the full change log:
This is a demo of the new cartridge storing in 0.1.6. (you'll need to update to 0.1.6 if you load this in PICO-8)
Press O (mapped to Z or C) to save the screen, and X to restore it. The cursor position is not saved.
To save, the screen is copied to the sprite sheet and then stored for clarity -- but it could have just been a straight cstore(0x0, 0x6000, 0x2000), and same again in reverse when restoring.
if (btn(4)) then memcpy(0x0,0x6000,0x2000) cstore() end if (btn(5)) then len = reload() memcpy(0x6000,0x0,0x2000) end |
This should also work in your browser, even if you close it and run the cartridge again. Please let me know if it doesn't!
Note that in 0.1.6 you can also cstore to separate cartridge files, meaning we can have quite large save games, and also saved data shared between carts on the bbs.
A build of PICO-8 0.1.5 is now available for Raspberry Pi! Check your updates page or look in your Humble library under the Linux downloads section.
It works in fullscreen under either X Windows or directly from the terminal (using directfb). For speed, the default resolution is 280,280; you can set this with the -width and -height switches:
pico8 -width 720 -height 480
Known issues:
- After quitting, keypresses during the session are sometimes dumped to terminal (annoying if you quit by typing shutdown instead of CTRL-Q!)
- Freeze on exit (observed on a zero)
- Some math-heavy cartridges (e.g. /demos/cast.p8) don't run at full speed on first generation models.
There are two builds included in the archive. pico8 is compiled statically (so no need to install SDL2), and pico8_dyn dynamically loads libraries, in case you'd like to supply your own SDL2.
Have fun, and please post pictures if you get pico-8 running on any cute displays!
This weekend (20th, 21st) I'll be at Tokyo Demo Fest 2016, giving a short PICO-8 seminar at 3pm on Sunday, and also making a wee demo for the Wild compo (also in PICO-8, naturally). If you're in Tokyo, come along! The venue is larger than last year -- 3331 Arts Chiyoda, which is around 8 minutes walk from Akihabara station. You can find the registration page and more information here.
Here's a 4k demo from last year (it won the combined pc section):
11 |
Hey All
Here's a quick update with music copying and keyboard configuration for controller buttons.
To configure buttons, use KEYCONFIG from the commandline.
To copy a song from one cartridge to another:
- In the song editor, click on the start pattern and then shift-click on the end pattern that you want to transport. They should light up green.
- Control-C to copy the pattern data, along with the sfx they point to.
- Load the cart you want to paste into, open the song view and click on the pattern index you want to paste to.
- CTRL-V to paste. When pasting a song, any SFX that are needed are written to unused slots and then the pattern indexes are adjusted accordingly.
Changelog:
v0.1.5 Added: Keyboard configuration for player buttons (KEYCONFIG) Added: Music tracker select / copy / paste Added: Single-level undo in audio tools Added: Live preview of frequencies in sound editor Fixed: Command history extends past last reboot Fixed: Sfx exporter broken Fixed: Slashes at end of path resolve to double slashes Fixed: Load cart from commandline under Windows |
Every day, Professor Miggles goes to work. And every day he snoozes in bed until the last possible moment. To keep the points you get for snoozing, make sure to head out in time without forgetting to put your trousers on.
v1.1: Fixed high score bug, and added persistent high score (when played from pico-8)
14 |
Hey All, I hope you had a great new year!
PICO-8 0.1.4 builds are live on the updates page and on Humble. The main features of this update are:
Friendlier Token Counting
Pairs of brackets and block deliminations now count as one token each, and local declarations do not count at all. You can now fit in around 30% more code because of this, and there is less need for odd space-saving techniques (e.g. using blah"" instead of blah()), or getting rid of local variables. It does mean you're more likely to hit the compressed code limit (use INFO to check), but I don't think this will be a problem. The raw character limit has also been increased from 32k to 64k.Importing / Exporting Data
import() and export() can now load and save the sprite sheet: export("something.png") and sfx: export("something.wav"). These aren't very flexible yet, but in future they'll be able to do things like grabbing particular sets of sprites, or only importing into empty slots.External Cartridge Data Access
reload() and cstore() now take an optional 4th parameter: a filename to grab the data from or store the data to. This is useful for making custom tools, or doing fancy data management. It's intended at this point mainly as a development tool, and isn't supported by the exporter or BBS player. But of course, you can do what you like with it :PHere's Let's Karate being gradually replaced with data from Jelpi during runtime:
Changelog:
View Older Posts