To make the experience fit your profile, pick a username and tell us what interests you.
I recently spent not that much time on the 1D games as I've been rather busy on the one hand and got sidetracked on the other. I was all the more surprised when I've seen that my 1D gaming concepts were featured on the front page of everyone's favourite hacking site.
Great to see that people are interested in this topic, there were even some rather cool ideas for additional games in the comment section. Thanks for the appreciation! As long as there are resources in the Arduino left, I will keep adding games.
Since the program is running quite nice on The Arduino from a display perspective, it's time to make it playable. For the next steps I intend to use a Wii Nunchuck Controller...it's a nice package and I've used it previously in the ArCake project.
Furthermore, the Idea of a 1D FPS came to mind. As of now I habe a small demo running in the Processing simulation that allows me to walk around a cylindrical object...which aptly brings me back to a non 1D application. I am uncertain how this one turns out on the Arduino because of the heavy use of trigonometric functions. Stay tuned for some screenshots as soon as some basic shading is implemented. This is exciting!
Tonight I ported the code from Processing to an Arduino. The test installation here is a 5 meter stripe with 100 pixels in total. So besides from removing any "println" commands and changing the definition of every array I spent quite some time with re-defining the positions of most of my objects since most of the coordinates were given in absolute numbers and not relative to screen size.
Most things that worked in processing are working on the Arduino, too...I still have to deal with my inputs and have cut back my memory useage a bit. I am running at 67% RAM at the moment and still have three more ideas for games. One is supposed to be a simple rythm based game, one more or less a racing game and finally a stealth based dungeon crawler. Looking forward to it!
Another genre that might work in 1D is the sports simulation. Thanks to the graphic limitations it is not really important wether or not it is considered to be handball, soccer or (and I like this idea) Speedball (as in the Bitmap Brothers game for Amiga).
Anyway. The Concept is that there are two goals (five pixels wide, green at the beginning of the game). Each team consists of two memers: a field player and a goal keeper. The keepers are auto-controlled and stay close to the goals. The other players can run left or right. Running with ball is slower than without.
I am working out the possibilities to shoot and to tackle the enemy player. It might be possible to lift the ball over the other keeper. But this game is a complex one and it might need another night or two.
With currently four games implemented in the processing demo it was time for implementing a way to choose from the games.
Whenever a game is finished, the player returns to a main menu that consists of currently five blocks of different colors. The block at the left side is just representing the menu, the four other blocks stand for each game.
By pressing the action button, the player can advance through all games and after two seconds of inactivity the game at the current cursor position is started.
All current games as well as the menu are shown in a two minute demo I recorded the other night:
And finally: Two Bases. It is not really a demake of an existing game but more of an original ideal that came up along the way. It's a 1D take on the real time strategy / tower defense genre.
Each player starts out with a base (three white pixels wide) and a power plant (the green pixel behind each base). The power plants have nice random pulsing light FX. The power plants supply the player with energy that can be invested in more power plants (limited to a maximum number of power plants), shields (in red, in front of the base) or offensive units (the red and the blue pixel).
The objective is to get an offensive unit into the opponent's base. The units advance at a fixed speed and cannot be stopped once activated. They either reach the base or are destroyed along the way by hitting an opposing unit or a shield.
The particle FX fireworks are used again and look even better in this context.
I'm really looking forward to see it on an actual LED stripe!
Another classic game from the old days can easily be played in full 1D-glory:
Tanks/Scorched Earth/Artillery Duel....there were many names for it and it was basically Angry Birds a long time before Angry Birds. The concept is simple: two or more players are at fixed positions on the map and have to aim a ballistic shot at their opponents.
As I wanted it to remain simple and playable with one button, I decided to remove the vertical aiming and opted to a fixed angle (45 degrees). The strength of the shot can be controlled by pushing the fire button longer or shorter.
The shot is influenced by wind (can be seen before the shot by an indicator animation in the center) and gravity. The trajectory is modelled in two dimensions but of course only a 1D display is used.
Initially both players are five pixels wide and fire a one pixel bullet. The bullet explodes into random particles upon impact (1D-animation-galore!). If a player is touched by the particle FX, the player is hit and loses a life (and a pixel in width). The game is over when one player has lost all his lifes.
The next thing that came to mind (after seeing the hillarious 1D-Tetris) was a one dimensional version of Dr. Mario which I will just call "Pills":
This game is not actually working at the moment, it just generates the test pattern that fills up 75% of the playing field and then drops in one pill of at a time. The pill is randomly chosen from six combinations of colors and are two pixels wide. The player has to rotate the pill in a way that the two matching pixels are adjacent. If this happens, the two pixels disappear and the remaining pixels are moved two pixels to the right. The goal is to stay alive as long as possible.
Inspired by 1D Pong and Line Wobbler I wanted to explore what's possible in 1D Gaming by myself. The first thing that came to mind is a really (really) simple game of Golf.
The representation in Processing is a 640x32 screen that is supposed to be a 160x1 LED-"screen" (that's just a fancy description of "LED-stripe") in the final application. The white pixel shows the ball, the red and green fields slow down / speed up the ball and the yellow pixel is the hole.
The ball is shot at a speed that is determined by how long you press the action button and then slowed down by friction and the red/green fields. Once it hits the hole below a certain threshold speed, you advance to the next course. There are three different courses at the moment.
Become a member to follow this project and never miss any updates