Log In  
Log In  

@2darray

Follow
Follow

I'm a game developer. I'm trying to mess around with pico8 because I want to take advantage of your pleasant little community by trying to attract attention so I can sell my other stupid shit to you. Hurr durr, nothing can be just for fun anymore

@2darray
2DArray.net
ObservatoryVR.com
NotTheRobots.com

Cart [#pico8adventcalendar2018-18#] | 2018-12-14 | No License | Embed
42

It's the Pico-8 Advent Calendar for 2018!

This is the main menu for a collaboration organized by Bigaston.

Come back on each day from the 1st to the 25th of December for twenty-five different surprises, each made by a different developer! This menu cartridge will link to all of the games as they are released, though the individual cartridges will also have their own threads.

P#59497 2018-12-01 04:12 ( Edited 2018-12-14 23:06)

Cart [#59051#] | 2018-11-16 | License: CC4-BY-NC-SA | Embed
5

An entry for TweetTweetJam - a weeklong gamejam where everyone makes a game in 560 bytes or less.

Arrow keys to move, X to reset if you die. Your score is based on your forward distance.

P#59052 2018-11-15 23:44 ( Edited 2018-11-18 18:10)

Cart [#winter_golf_2darray-1#] | 2018-12-03 | License: CC4-BY-NC-SA | Embed
15

This is my entry in the Pico-8 Advent Calendar for 2018, a jam organized by Bigaston.

Winter Golf is a short golf game for snowy-minded individuals. Each time you collect a snowflake, your snowball gets larger and larger. Grab all the snowflakes in a course to unlock the goal! There are five courses total.

Press left and right to aim, hold and release O (or, on a keyboard, Z) to take a shot, or hold X to restart the current course.

There's a special surprise at the end...but you'll have to figure out how to get to it!

(little note: this thread originally contained a placeholder cartridge, so there are some comments about that original cart - for context, it was a drawing of an orange.)

P#57221 2018-09-28 13:32 ( Edited 2018-12-03 02:09)

Cart [#51642#] | 2018-04-15 | No License | Embed
34

Ahoy! Here's a little fishing game for you.

The main goal of this project was to experiment with a bunch of fun rendering effects that aren't super common in Pico-8...

...so hopefully the gameplay is worthwhile enough to justify its own inclusion.

Some features:

  • 3D character animation (with knees and elbows!)
  • Spriteless animated fish rendering
  • Water which visualizes a flow-velocity field
  • Fullscreen "day to night" transition filter
  • Realtime shadows, including soft shadows from the player
  • "Windy grass" rendering
  • Procedurally generated maps
  • A shop with four gadgets
  • Something unexpected, which I don't want to spoil for you

The version of the code that's included here is obfuscated to be illegible, but you can buy the real source code (formatted properly, with optional comments) on itch.io - the price is "$1 or more."

Thanks for reading - I hope you enjoy the game!


First update - fixed a bug in the minified version which broke all the item unlocks. Sorry about that!

Second update - didn't change the game, but the itch.io page is live, so I added a link above.

P#51637 2018-04-15 15:19 ( Edited 2018-05-04 21:13)

Cart [#50802#] | 2018-03-25 | License: CC4-BY-NC-SA | Embed
7

It's a frosted 3D donut, drawn in 265 chars of Lua!

I'm including the code here, with spacing and indents for legibility (instead of minimizing chars like in the cart).

Variable meanings:
X/Y/Z: Current sample position (moves along a camera ray), +Y is up
I/J: Screenspace position
U/V/W: Ray direction (normalized)
C: Output color of the current ray
K: Raymarch iterator
Q: Distance to the unextruded torus on XZ plane
L: Shortest distance to the surface of the extruded 3D torus
A: Angular position of sample pos around the torus (0-1, repeating)

(Both distance values are signed: a negative distance means that a point is inside a shape)

cls(2)
::_::
x=0
y=2
z=-3
i=rnd(112)+8
j=rnd(66)+40
u=i/128-.5
v=-(j/128)
w=sqrt(1-u*u-v*v)
c=2
for k=1,20 do
    q=sqrt(x*x+z*z)-1
    l=sqrt(q*q+y*y)-.5
    if (z>4 or y<-1) then
        break
    end
    if (l<.08) then
        a=t()/64+atan2(z,x)
        c=(-y*5-.3+sin(a*6)/4)
        break
    end
    x+=u*l
    y+=v*l
    z+=w*l
end
pset(i,j,max(c%16,1))
goto _
P#50803 2018-03-25 14:12 ( Edited 2018-03-25 20:15)

Cart [#50080#] | 2018-03-08 | License: CC4-BY-NC-SA | Embed
6

Material Capture, or "matcap" for short, is a really neat technique, and now that I've learned about it, I'm pretty surprised that it doesn't come up more often in gamedev conversations. It's great! Here's a pico8 implementation of the concept: it draws approximated realtime reflections on 3D meshes.

There are three settings that you can change while it's running:

Right/Left: Switch materials
Up/Down: Fast-mode / Slow-mode
O/X: Switch models

Fast-mode is kind of like a vertex shader in modern 3D engines (the material texture is only sampled along the edges of triangles). Slow-mode is kind of like a pixel shader (except there's no GPU to give it a speed boost)

P#50081 2018-03-07 22:54 ( Edited 2018-03-09 18:15)

Cart [#48972#] | 2018-02-04 | License: CC4-BY-NC-SA | Embed
14

Hello again!

Here's something I made this weekend - I recreated a pixel art image which was made by @Kldpxl:

https://twitter.com/Kldpxl/status/944196919643070464

I love his pixel art because it often has a really striking photographic look about it, so I tried to carry that effect over as much as I could.

Some features:

  • It's 100% code: all sprites are generated at load time
  • Textured ground plane with perspective distortion
  • Value noise with multiple octaves (used for building all textures)
  • Raymarcher for generating sprites with lighting:
    • Four types of plants
    • Background mountains
    • Horizontally-tiling clouds
  • 3D-positioned plant billboards
  • 3D extrusion for low grass and road lines

I think it even runs at 60 fps!

P#48976 2018-02-04 16:53 ( Edited 2018-02-05 20:14)

Cart [#48605#] | 2018-01-27 | No License | Embed
13

Hello there! This is an example project which is intended to help people learn about making platformers in Pico-8.

The game is free to play, but the source code for this version has been obfuscated, so it's not really practical to look through it. To read the normal-and-legible version of the source code (with or without comments), you can buy it for at-least-$1 on itch.io. As long as you make your own map, you can even sell games that use this code! If you didn't already know, itch.io has very nice support for Pico-8 games.

Anyway, it's a cute little platformer with a grappling hook (you get the hook about halfway through) and a big finale! The main goal was to make a piece of illustrative/educational content which was centered around a real and complete game. See, "Madness Interactive" taught me that reading source code for a game that's fun to play can be much more exciting than reading a code snippet in the middle of some online tutorial. Not sure if I succeeded, but I tried real hard!

Huge thanks to David Carney for helping me with the music, and also to everyone who volunteered to test the game! Y'all made the game better.

A first run seems to take 20-45 minutes or so, but it depends on the player, and a fast runthrough is around three and a half minutes. If you record a video of a run that's faster than that, I'd love to see it!

P#48607 2018-01-27 18:52 ( Edited 2018-01-27 23:52)

Cart [#47254#] | 2017-12-10 | License: CC4-BY-NC-SA | Embed
9

A particle effect that spawns streams based on the music that's playing!

The song is a chiptune cover of "STONEFIST" by HEALTH.

It never stops repeating once it starts, but the music loop is maybe 45 seconds long.

Here's an example of how to do some basic stuff that reacts to music:

// pick a channel - a number from 0-3
// (0 is the far-left channel in the music editor)
channel=0

// get the sfx index that's playing in this channel
// (the number at the top of an enabled music channel's column)
sound=stat(16+channel)

// get the current timeline position of this channel (0-31)
row=stat(20+channel)

// get the two bytes representing the channel's current note
byte1=peek(0x3200+68*sound+row*2)
byte2=peek(0x3200+68*sound+row*2+1)

// now we can extract the note values!
// all three of these return 0-7
volume=band(byte2,0b1110)/2

effect=band(byte2,0b1110000)/16

instrument=band(byte1,0b11000000)/64
instrument+=band(byte2,1)*4

More info about the audio memory layout is available here.

P#47257 2017-12-10 16:15 ( Edited 2017-12-10 21:32)

Cart [#44285#] | 2017-09-17 | License: CC4-BY-NC-SA | Embed
5

I made an animated self-portrait!

Some of it is rendered with drawing functions (the head shape, eyeballs, "ear beams" on the glasses, cheek-lines, etc), and other stuff done with sprites (frames of glasses, eyelids, most of the hair).

Had a lot of fun making this - I recommend making one of yourself, or of someone else!

I also added a fullscreen trail effect for some extra pizzazz, because it's an easy addition. Here's the code for that part, in case you want to use it in your own stuff - note that this will only allow you to "fade to black" over time, but you could modify it a bit to make it fade to a different color. It's...probably very difficult to control what colors it moves through as it approaches your target color, though, since it's abusing the two-pixels-per-byte format that pico8 uses for its screen buffer (which is also why it produces vertical stripes).

for i=1,1100 do

    local x=flr(rnd(64))
    local y=flr(rnd(128))
    local m=8192*3
    poke(m+y*64+x,peek(m+y*64+x)*.6)
end
P#44286 2017-09-17 17:55 ( Edited 2017-09-17 21:55)

Cart [#42900#] | 2017-07-29 | License: CC4-BY-NC-SA | Embed
7

A barebones implementation of the FABRIK algorithm ("Forward And Backward Reaching IK"). Move the mouse around to control the IK target point.

I think there's something kind of cute and coincidental about the way that it actually sorta looks like fabric.

FABRIK is a clever trick that's surprisingly straightforward to implement, and it gives some really natural and performant results. The general principle is that instead of doing gradient descent or other fancy math for IK, you just imagine that your IK chain is a string (for 2D strings, imagine that they're resting on a table, and you're viewing from above).

At each tick, you perform two loops through the chain: First, you "pull the string" by the end point to the target position (and some amount of the rest of the string will get pulled along with it). After you've done this, you do the same thing, but this time, you pull the root of the string to the anchor point. (If the IK chain is a person's arm, then the anchor point is the shoulder.)

The source code also includes a 2D-distance check that tries to avoid number-overflow (by sacrificing some precision) when you give it a large enough vector. Might not be tuned perfectly (I really just guessed about the "safe range"), but maybe some motivated party can math out a more rigorous version of the function!

P#42901 2017-07-29 19:09 ( Edited 2017-07-29 23:09)

Cart [#42360#] | 2017-07-11 | License: CC4-BY-NC-SA | Embed
7

A weird animated image generator, based on the screensaver "Electric Sheep" (except way less powerful).

USAGE INSTRUCTIONS

Press Z to generate a new flame.

Press S to save the current flame.

Press X to view saved flames.

When viewing saved flames, press Up/Down to move the cursor between saved flames.

When viewing saved flames, press F to select/deselect a flame.

When viewing saved flames, press Z to load the selected flame (instead of generating a new one).

If you have flames selected and you close the saved-flame-view (by pressing X), then any new flames that are generated will be bred from the flames that you've selected (as parents).

For example: If you select one flame, close the selector, and generate new ones, they will all at least vaguely resemble the one that you selected. If you select more than one parent and generate new ones, then the new ones will inherit traits from all selected parents (plus some randomized mutations).

Post me your prettiest children in the comments!

P#42361 2017-07-10 21:42 ( Edited 2017-07-12 02:02)

Cart [#42207#] | 2017-07-05 | License: CC4-BY-NC-SA | Embed
9

A non-interactive view of a scene. It's roughly based on something I saw a few days ago, which reminded me of Virginia.

Some features:

  • Infinite random props
  • "Immediate mode" rendering - no spawning/deleting/pooling props
  • Smooth LOD on tree leaves (more leaves on nearby trees)

Source code is commented, but the least-intuitive part of it (infinitely looping random objects) isn't really explained in there, because it would be a huge comment. Instead, here we go:

First, think of the casino signs with a ring of lights around them. When they light up one at a time in sequence, it can appear like a "single light" is "moving around" the sign, even though it's really different lights which are blinking at choreographed times. Our trees in this demo work similarly, but we can also move the positions of the lights separately from changing their states. Also, instead of on-or-off, each tree is given a persistent random seed.

Other than that, it's all pretty normal, I think?

P#42208 2017-07-05 15:09 ( Edited 2017-07-05 22:23)

Cart [#42148#] | 2017-07-02 | License: CC4-BY-NC-SA | Embed
10

Just a little image generator. Generates buildings, a moon, some stars, and a reflective body of water. Nothing particularly fancy going on here; the code is probably relatively self-explanatory

P#42147 2017-07-02 14:32 ( Edited 2017-07-04 23:03)

Cart [#42122#] | 2017-07-01 | License: CC4-BY-NC-SA | Embed
7

I learned about L-systems the other day, so here's my first shot at making one. It generates a plant whenever you hit the main action button.

L-System Parameters:

axiom="a"

rules={}
rules["a"]={"b{c}b","c{b}c"}
rules["b"]={"a{a.}","a(bb.)"}
rules["c"]={"(ab.)","(b)"}

Constants are any characters that don't appear as a rule index - all rules for a given variable have an equal chance of being chosen. The generator runs five iterations for each plant.

A means "go forward," B and C mean "turn and go forward," {} and () mean "start a new branch and turn afterward," and . means "draw a circle."

All animation comes from the rendering portion - the L-system only runs to initially create the plant.

P#42123 2017-07-01 13:41 ( Edited 2017-07-03 22:15)

Cart [#40228#] | 2017-05-06 | License: CC4-BY-NC-SA | Embed
6

Just a simple little 2D-rotation example.

The function takes a 2D position (X,Y) and rotates it by ANGLE. CX,CY represents the center/pivot point.

The lines of code in the middle are the rotation matrix:

local rotx=cosa*x-sina*y
local roty=sina*x+cosa*y

This rotates a point around the origin. Before and after doing so, we offset our position by our center coordinate - this lets us rotate around any arbitrary pivot point.

For bonus points: When you're rotating lots of objects by the same angle (like a camera rotating, or a complex prop rotating), you can re-use your SINA and COSA values.

P#40230 2017-05-05 22:07 ( Edited 2017-05-06 02:12)

Cart [#39671#] | 2017-04-14 | License: CC4-BY-NC-SA | Embed
4

First real test-case for a 3D prop editor I've been making for Pico8.

There's no interaction in this demo - it's just four cars that drive around the screen. They also don't do any collision detection or avoidance, so they just drive through each other sometimes.

The point of the tool is that it lets you create and edit simple 3D props for use in Pico8 games. The editor is made in Pico8 so you can get a live preview with the same renderer that gets used in-game (crucial for lo-fi rendering!). The other reason that the editor is made in Pico8 was because it seemed like a funny thing to do.

If you clicked the link to the gif above, you may have noticed a familiar face - the tool can import triangle meshes, so that clip is showing a render of Suzanne (the test-monkey from Blender).

The workflow for making the cars goes like this:

  1. Make a car mesh in blender

  2. Run the mesh through a Unity utility I made that converts the model into a different coordinate space and exports a serialized mesh

  3. Add tires in the Prop Editor and tune up colors+triangles

  4. Export to console, paste the model into another cartridge (which contains the renderer) as a giant string

There's still room for improvement, but I'm at the point where I'd need to start optimizing out a bunch of tokens to add any more stuff to the editor. The renderer on its own is about 1700 tokens, so I think there's a reasonable amount of space left (>6000 tokens) for it to be used in a releasable game. Also, while each model is only one token, a really complex model (by lo-fi standards) can end up being a few thousand characters...

...but the serialization format is completely uncompressed right now - particularly, it includes every serialized variable name as plaintext (instead of just using a fixed order to infer the meanings of different numbers). This would cut the character-count down by a whole lot - like 50% smaller, or something.

Will likely release the editor on the BBS, though it's worth noting that for it to really be useful, you need to run it in the standalone Pico8, because you have to start it from the command line in order to export your models.

And for it to be fully-activated, you'd also want to be able to convert other meshes into the special serialization format. It's fun to make 3D stuff in this pico8 tool, but it's really not appropriate for making triangle meshes from scratch (no extrusion, edge loops, etc), so it's best to just do that elsewhere and import it into the tool for extra additions and final tuning. If you're a Unity user, I'd be happy to share my converter project with you. If you're not a Unity user but you do have some other 3D-model-scripting capability, I can explain how the middle-man works (that part is pretty simple)

Not exactly sure what it'll be, but I'm gonna make some type of cool shit with this thing!

P#39672 2017-04-14 19:35 ( Edited 2017-04-15 16:17)

Cart [#36390#] | 2017-01-22 | License: CC4-BY-NC-SA | Embed

Protect your rebbitts from the angry magician!

We made this for Global Game Jam 2017, at the Omaha, Nebraska site.

Eli Piilonen (Code/Design)
David Carney (Art/Audio)

(Instructions are in-game)

P#36365 2017-01-22 16:05 ( Edited 2017-01-22 22:08)

Cart [#35829#] | 2017-01-16 | License: CC4-BY-NC-SA | Embed
3

Cart [#35825#] | 2017-01-16 | License: CC4-BY-NC-SA | Embed
3

Cart [#35818#] | 2017-01-16 | License: CC4-BY-NC-SA | Embed
3

Cart [#35705#] | 2017-01-15 | License: CC4-BY-NC-SA | Embed
3

This is a port of my favorite mobile game, which was originally designed by Area/Code Entertainment. Zynga acquired the original version, and they promptly ruined the minimalist experience with a bunch of abrasive and irritating hooks. On top of that, all of the clones I've found have been kind of janky.

Pico8 to the rescue! I'm trying to make the very best totally-free version of Drop7. Your feedback would be greatly appreciated!

INSTRUCTIONS:

Click to drop disks.

A disk is destroyed if its number is equal to the size of the group that contains it. A "group" is a horizontal row or vertical column of adjacent disks (like Connect-4, except with no diagonals).

For example: If you have five disks in a row along the bottom of the screen, any of those disks with a "5" label will be destroyed. Vertical columns of disks work, too.

If you destroy a numbered disk while it's touching an unlabeled disk, then the unlabeled disk will take damage. If you damage an unlabeled disk twice, it will change into a random numbered disk.

After every tenth disk you drop, a row of unlabled disks will rise from the bottom of the screen.

If any disk ends up above the top of the gameplay grid, then you lose. Click anywhere to return to the main menu.


Version 1.1.1:

(Hopefully) fixed a bug causing an error when you run the game for the first time. If you get an error on first launch, try refreshing the page...and then please leave a comment saying that the bug isn't fixed yet.


Version 1.1:

Added three difficulty modes.


Version 1.0:

Lots more polish compared to the alpha version - Drop-5 and Drop-10 modes, a main menu, scene transitions, a palette selection screen, and more!

Experimenting with a feature that restricts certain unfair number spawns when an unlabeled disk pops inside a large cluster. Might make the game too easy, but then it seems like a feature that could be used for easy/training modes.


Alpha version:

A basic Drop7 clone. Will be adding extra features and such over time.

P#35706 2017-01-14 20:01 ( Edited 2017-01-16 18:20)

Cart [#32141#] | 2016-11-01 | License: CC4-BY-NC-SA | Embed
3

Cart [#32054#] | 2016-10-30 | License: CC4-BY-NC-SA | Embed
3

Simple "Space Invaders" clone with some wacky special effects.

Left/Right to move, Z to fire.

Version 0.2
Did another stream, added some new features:

  • Points system with perfect-wave bonus
  • Permanent high score
  • Infinite waves of baddies (gets progressively harder, to a certain point)
  • Simple starfield background

Version 0.1

Made in about two hours, to practice dev-streaming. You can watch the full process here. There aren't a lot of features, so it shouldn't be too hard to skip around to the part you're interested in. Glitch effect comes in pretty close to the end.

P#32055 2016-10-29 21:54 ( Edited 2016-11-01 23:51)

View Older Posts
X
About | Contact | Updates | Terms of Use
Follow Lexaloffle:        
Generated 2018-12-15 05:47 | 0.205s | 2097k | Q:249