J4K Retrospective
The Java 4K Game Programming Contest was an annual competition from 2003 to 2014 that dared developers to squeeze an entire game into a measly 4096 bytes. As a participant in six J4K’s, I produced 34 tiny games. Unfortunately, they can no longer be played online. They are embedded applets, a technology incompatible with the modern web. However, for those interested in exploring them, I combined all my submissions into a single downloadable application, a launcher with a menu from which you can a pick and play.
The download link above contains the launcher and the source files for all the games. On a side note, the 4096-byte constraint refers to the deployed binaries, not the source file sizes. Contest participants used ProGuard, Pack200, KZIP and other tools to compress the binary to the max while still leaving it executable. The launcher isn’t ultra-compressed in that way.
If the JRE is installed on your box and double-clicking fails to start java4k.jar, try the following at the command prompt:
java -jar java4k.jar
Since I hardly remembered what I coded so long ago, I realized I had the opportunity to judge my own creations. So, I reviewed them all and ranked them from worst to best. I also recorded videos of sample gameplay for those who just want a peek at what was possible to accomplish in so little space. To find out what’s worth playing and what’s not, the list begins below.
In this competitive fighting game, you play an anthropomorphic red hotdog battling against a yellow one. Actions are limited to walk, jump, punch and block.
This was my very first attempt at creating a 4K game. At the time, I didn’t take the contest seriously. Since I believed it was virtually impossible to create an interesting game in so little space, I made no attempt at pushing the bar. In fact, I simply threw together this demake to draw attention to my Meat Fighter game and website.
The sprites and background are stored as vector graphics, specifically paths of straight lines, instead of bloated bitmaps. During development, I remembered reading that to save space the bushes and clouds in Super Mario Bros. are the same sprite with different colors. I employed the same trick for the tree top and cloud in this game.
For some reason, the health bars do not regenerate after a fight. This bug was not present when the game was originally released. I assume some JVM update in the past 13 years introduced this side effect. If I get a chance, I’ll explore that mystery further.
That bug currently makes it impossible to advance very far in this game. But even if that were fixed, there is little reason to play this game due to its many flaws. The AI does not offer much of a challenge since it moves randomly. Not only that, the player can walk straight through the opponents. Jump is a useless action and block is nearly useless. It’s not much of a fighting game and not worth playing.
Desert Bus is a demake of the tongue-in-cheek minigame of the same name in Penn & Teller’s Smoke and Mirrors (Sega CD). The goal is to drive a bus back-and-forth between Tuscon and Las Vegas in real-time. The game consists of nothing but perfectly straight road and flat desert extending to the horizon. To prevent cheating, the bus veers slightly to the right. The player is rewarded with 1 point for every 8 hours of driving.
The road and desert textures are procedurally generated. The textures were based off photographs of actual roads and desert sand.
It’s tic-tac-toe played on a 5×5 grid. The object is to form a line of 4 of a kind.
The background texture is procedurally generated. It contains fractal elements. The spheres are ray traced.
Like Yoshi’s Coins 4K, this entry employs the negamax search algorithm with some clever heuristics. Consequentially, the AI is brutally hard to beat. In other words, this entry took a boring game and made it frustrating.
PacMinia is a demake of Pac-Mania (arcade), a 3D interpretation of the classic maze-chase game in which you can jump over ghosts. The mazes and all the graphics are procedurally generated. And, instead of cabinet projection, this version displays the maze using a mode-7-like effect.
Unfortunately, to save space, this game compromised too many aspects of the original. The ghosts look like gumdrops and Pac-Man has been reduced to a sphere. Neither animates at all. Pac-Man doesn’t even have his iconic mouth. When ghosts are captured, they just vanish without the classic floating eyes. As for the backgrounds, gone are the Legos, pyramid steps, railings, etc. that made each 3D maze feel like a unique environment. And the procedurally generated maze layouts are terrible, resembling nothing like a Pac-Man maze should.
This entry features sprites borrowed from Pitfall! (Atari 2600) and game mechanics from Super Mario Bros. (NES) in a mashup that shouldn’t exist. The jump physics, the strength of gravity and the character momentum just feels wrong. You can change direction midair, except when you jump straight up for some reason. As a result of all that, the game is very difficult to control. The levels are procedurally generated with many repeated elements and poorly placed obstacles and enemies. They are far less fun than the handcrafted levels in traditional platformers.
The blur effect was inspired by a similar effect in Super Mario World (SNES). The progressively worsening snowstorm was based on the Snow Barrel Blast level in Donkey Kong Country (SNES).
This was my very first attempt to create a platformer, which explains the bad physics. I consider it more akin to an artistic study than a fun, playable game. The Java 4K Contest always served as excellent excuse to learn new things.
Despite what the title suggests, running over zombies is a secondary priority. Your goal is to rescue 8 scientists, each colored red to help identify them in a crowd of green zombies. The value in the upper-right corner is the number of scientists that you have yet to pick up. The compass in the lower-right corner points the way to the nearest scientist.
Be sure to pay attention to the time bar displayed below the scientists remaining number. It depicts the amount of time you have left to locate the next scientist. You gain time when you make a pick up. However, if the bar fully disappears, your mission will reset (i.e. your score will reset to 0 and the scientists remaining number will return to 8).
I created this entry after reading about Death Race, the controversial 1976 arcade game in which you run down humanoid figures with your car. I though it would be funny to make a 3D version of it.
The look of the zombies was based on the AIGA men’s toilet sign.
The city is procedurally generated, consisting of random streets and solid colored buildings. Each building is made of 4 polygons that are sorted and shaded by distance from the virtual camera. Polygons behind the camera and those on the opposite sides of buildings are culled.
The game is repetitive. And it isn’t that challenging. Once you understand how the compass operates, it’s not that difficult to collect all the scientists. The entire can be completed in under 3 minutes and once you do, there is little reason to ever play it again.
The Coffee Shop Puzzle is the Tower of Hanoi played with cups instead of disks. The goal is to move the stack of cups while maintaining the constraint that a smaller cup cannot fit over a larger cup.
The cups and background are ray traced. The background texture was based on the Green Hill Zone in Sonic the Hedgehog (Genesis).
I created this game as a joke in response to Notch’s Left 4k Dead entry that went on to win J4K2009. It employs a similar light-and-shadow gimmick, but instead of killing zombies, you play as a glob of butter that fires at demonized slices of white bread.
To complete each stage, you need to destroy all the bread slices. You move with WASD and you direct your light and fire with the mouse, an ambitious control scheme for a 4K game.
All the enemies are the same, leading to very repetitive gameplay. They can be controlled to some extend by directing them into walls, a mechanism that was inspired by the enemy patterns in Gauntlet (arcade).
There are a few items that can be collected while navigating the mazes. Lanterns momentarily enable you to see in all directions. Ice temporarily freezes all the surrounding enemies. And med packs restore health.
The floor texture was borrowed from The Legend of Zelda: A Link to the Past (SNES). The pink version slows you down. The yellow one speeds you up. And there is also lava that injures you.
F-Zero 4K is a futuristic racing video game that, unfortunately, doesn’t live up to its SNES inspiration. On a cursory glance, it contains the same basic elements, such as the 2.5D Mode 7 look, the bubbled track borders with its ping-pong physics and the high-tech, flying vehicles that scale to further the illusion of depth and that are controlled by AIs. But it fails to capture that intrinsic sense of extreme speed and craziness in the original. Instead, the demake feels more like a slower kart game. Part of the reason is the lack of S-JETs, speed boosts and jumps. But it’s also poor track design. The track is too narrow, and it lacks straightaways, wide curves, rough patches, ice and other characteristics normally found in F-Zero courses amenable to high speed. While on the topic, the game only contains a single track. That’s understandable given space limitations, but it also means that the entire game can be beating in under 3 minutes and there is little reason to replay it.
Steering doesn’t feel right. The player’s vehicle is missing that distinctive momentum. And the competitors feel flat, like buoys drifting in a flowing river. They are just obstacles to be avoided rather than interactive opponents. And, since ping-pong physics with the walls and other vehicles is also way off, colliding with anything drains power much faster than in the original. Worse, the Pit Row area doesn’t replenish power fast enough.
All the graphics and the track are procedurally generated. If multiple tracks were captured from the original game and compressed into this entry, that alone would have greatly enhanced the gameplay. Regarding the 2.5D effect used for the ground, the geometric perspective is wrong. Instead of tilting the virtual camera downward about 35°, the vanishing point was simply moved off center to create a false horizon higher in the frame. The result is subtle and unnatural, and it may make players feel dizzy or nauseous after playing, yet another reason to avoid this 4K entry.
This is a Yoshi-themed Connect Four game. You and Yoshi (the AI) take turns dropping a coin into one of the columns of a grid. A coin fall straight down, occupying the next available space within the column. The object is to connect four yellow coins next to each other vertically, horizontally or diagonally before Yoshi does it with red coins.
You start off with 1 egg and each time you beat Yoshi, you gain another egg. For each egg you own, Yoshi becomes a more challenging opponent. If you own 7 eggs and you beat Yoshi, you win the tournament.
Like Ultimate Tic-Tac-Toe, this entry employs the negamax search algorithm with some clever heuristics. Consequentially, the AI is brutally difficult. Connect Four can be a fun game. But, paraphrasing WarGames, when you are playing against a nearly invincible opponent, the only winning move is not to play.
Castlevania 4K is a final boss battle, pitting Simon Belmont against Dracula. Although it borrows graphics from Castlevania (NES), albeit reduced to black-and-white, the game mechanics are slightly different and Dracula’s pattern is completely different.
Simon can change direction midair, which makes the fight a lot easier. He also has infinite hearts, enabling him to dish out endless boomerangs. And there is a separate button for subweapon as opposed to pressing Up+Attack.
Dracula’s pattern is a blend of his behaviors in Castlevania (NES) and Super Castlevania IV (SNES). He starts out by throwing fireballs. As he takes damage, this advances to manifesting fleamen. A simultaneous mix of fireballs and fleamen follows. Then, he drops blocks. And it ends with a blocks-fireballs combo.
To kill Dracula, his head needs to be hit an excruciating 32 times. It’s a challenge, but if you have what it takes, the entire game can be completed in under 3 minutes.
Laser Pinball is a Tron-themed demake of the Android table in Epic Pinball (PC). The table was stored using vector graphics, specifically paths of straight lines and circular arcs, which were constructed by manually tracing the original. The lightsaber effect was created by applying a large-radius Gaussian blur to the paths. And then on top of that, the paths were redrawn without the blur and with very low saturation (nearly white). The habitrails were tinted yellow to indicate that they are set above the normal playfield ball level.
The game features the common elements of most pinball tables: plunger, flippers, bumpers, drain, habitrails, bullseye targets, rollover targets, one-way gates, detour gates, chutes, sinkholes, ejection holes, slingshots, ramps, kickbacks, etc. It contains a physics engine and state machines that enables the virtual ball to interact with the swinging flippers and all these other elements.
Unfortunately, this pinball game is missing the excitement factor. It’s absent of sound effects and flashing indictors, a dot matrix display or audio cues that would normally indicate what the player achieved and what he needs to do next. Due to space limitations, these concepts were reduced to solid colored dots on the playfield, which simply do not have the same impact and fun. It’s not immediately obvious from looking at those dots what game features are even available.
Worse, the table needs tuning. The ball often gets trapped for long periods between the bumpers in the upper-right. And when it finally escapes, it very often makes a beeline directly to the drain, just out of reach of either flipper. Luckily, if a ball goes down the drain without contacting a flipper, it gets ejected out of a hole in the middle of the playfield rather than getting lost. Nonetheless, it’s very annoying that after waiting a while for the ball to be freed that it’s obliterated before you can play. Sadly, I ran out of space before these flaws could be fixed.
McJob is a Tapper (arcade) inspired game that puts the player in the shoes of a fast food server who must attend to hungry and impatient patrons while collecting empty trays and tips. The patrons emerge from the bottom and slowly advance toward the player at the top in one of 4 queues. As they walk, they call out their orders. In response, the player selects food items from a menu above and delivers to the requestor’s queue. If an order is not satisfied fast enough, the patron will leave, causing the player to lose a life. A life is also lost if a returned empty tray is missed. As the game progresses, patrons advance faster for a heightened challenge.
The food sprites were created by scaling down actual photographs of fast food items and recoloring them. The server and patron sprites are modified versions of sprites from other games. The floor texture is based on a texture from The Legend of Zelda: A Link to the Past (SNES). The font is original. Apparently, there was enough empty space left over to include a very large title graphic.
McJob is not as fun as Tapper. The patrons arrive too slowly at the beginning of each level, initially giving you very little to do. When they make their orders, the request bubbles only display momentarily, which can leave you idle as you wait for them to reappear. The player delivers the food on a counter to the right of the patron rather than lined up with the patron, which is confusing. And delivering a specific item to a patron, rather than the same type of beer from any tap, adds a level of complexity that makes the game frustrating. On top of all that, as the title indicates, the game is a simulation of a tedious, repetitive job. It has little replay value.
Double Dragon 4K is a demake of Double Dragon (NES), a beat’em up video game. Games in that genre tend to be repetitive and this game is particularly so. Due to lack of space, it was impossible to provide a variety of enemies and locales. Instead, a generic man and a generic woman recur in different colored clothes in front of the same generic building that also appears in multiple colors. When they fall and get up, their sprites rotate as oppose to animate, again a space-saving measure. The bosses are either the generic man or the generic women scaled to look larger.
On the plus side, a mode-7-like effect is used to give the ground a pseudo-3D look. And the sprites scale appropriately, contributing to the illusion of depth.
Invaders is a space-themed dungeon crawler that draws inspiration from Gauntlet (arcade) and Space Invaders (arcade). You fly a ship through a maze in search of diamonds while shooting at green insect-like aliens. Along the way, you pick up keys to unlock new regions of the maze. There are also med packs that restore health, TNT that destroys all onscreen enemies and shields that temporarily make you invincible. Some of the maze barriers can be shot open.
The sprites use mirror symmetry to save space. The TNT sprite is noteworthy for clever use of a lowercase N that was mirrorable. I particularly like the green insect sprites, but more effort could have been put into the player’s red ship.
The mazes are procedurally generated, and they get larger and larger with each level. But once you’ve seen one maze, you’ve seen them all. The lack of variation and the repetitive nature of the game leaves it with little replay value.
This Jackal (NES) demake is an overhead run’n gun-style shoot-‘em-up. It vertically scrolls, like its inspiration, as you advance northward toward a boss at the end of the level. But it’s only 1 screen wide instead of 2. To survive, you need to inch your way through, methodically taking out each enemy. And there is a wide range of enemy types packed into this 4K entry.
With sprites borrowed the original, some of the enemies have a surprising level of detail. For instance, turret guns recoil after firing. Enemy solders can be run over or shot dead, leaving bloody corpses behind. And the underground spread guns open and rotate to face the player.
This was the first entry that I create for J4K2011. Around that time, I was reading an article on the history of Pitfall! and how its colorful backgrounds disguised it from other Atari 2600 games, which primarily used solid black backgrounds. I realized that most 4K entries were doing the same. So, I decided that all my future works would have textured, colorful backgrounds, as can be seen in this game.
In the NES version, a single hit will kill you. But you have multiple lives and you immediately continue where you left off. Unfortunately, after taking a hit in this demake, you are sent all the way back to the start of the level. While you have infinite lives, that change makes the game brutal. With all your progress erased, there is little motivation to try again.
Due to space limitations, there are no weapon upgrades and you can only fire in 4 directions instead of 8. Also, the surroundings do not change that much between levels. While this entry captures a lot of the spirit of the original, it was impossible to fit in the full variety of enemies that prevents the game from feeling repetitive.
On The Ball is a demake of the SNES game of the same title. Gamplay consists of moving a ball through a labyrinth by rotating the maze around the ball and letting gravity do its thing. It has many of the elements of its inspiration including the breakable blocks, the annoying X’s that subtract time when hit, and the black-and-white striped goal bar. But the mazes are procedurally generated to save space. And, unlike the cleverly constructed mazes in the SNES version, these aren’t that fun to play. The demake is also missing the arrows that make navigation a breeze. Without them, it’s easy to get lost and even head opposite the goal. Also missing are the bonus tiles that added time, balancing out those annoying X’s. The original game was very repetitive and this demake is even more so. It has very little replay value.
Like Pitfall: Scorpion Island, this entry was created at a time when it was believed that it was impossible to fit all the sprites and game logic into a 4K Super Mario Bros. clone. In this game, rolling marbles serve as the substitute. And unlike Pitfall: Scorpion Island, the jump and bounce physics feel good. But the collision detection can be a bit unforgiving. And, since the levels are procedurally generated, they feel repetitive and poorly crafted. There’s not enough variety in the game to play for very long.
This entry is a based on the first level of Star Wars: Shadows of the Empire (N64) in which you take the controls of a snowspeeder in a gallant attempt to destroy evil AT-AT Imperial Walkers and AT-ST chicken walkers. It combines a mode-7-like effect, virtual camera roll, sprite scaling and receding laser blasts to create a 2.5D in-ship perspective. The ground and sky textures were procedurally generally using fractal elements. And a significant amount of space was dedicated to the enemy bitmaps, which were borrowed from other Star Wars games.
While this is a visually stunning entry, it’s not engaging enough to play for very long. It’s simply too repetitive; you just shoot at things, steer and repeat. The enemies don’t offer much of a challenge.
The philosophy behind this entry was maximum gameplay with minimal graphics. Since fancy graphics take up precious space, I decided to abandon them completely. Instead, the graphics in this Gradius-inspired space-themed side-scrolling shooter are limited to circles for bullets, squares for your ship and the enemies, and the occasional rectangle for walls and obstacles. The intro animation is based on the intro in Contra III: The Alien Wars (SNES).
Normally, the levels in side-scrollers are constructed out of tile grids. But I applied a simpler approach. There are 8 pieces that can be put together in different sequences to form a level. Pieces include a wave attack, a triplet attack, a wall with a hole in it, the explosive barrier, the shrinkers, the cave, a boss, etc. Each piece is affected by the level number (e.g. bosses become more difficult) and a random number generator (e.g. the hole in the wall will appear at different positions). When the stage begins, a clock is started. The sequence for each stage looks something like: at time T1, manifest wave attack, at time T2, manifest triplet attack, etc. Originally, this was encoded with 2 arrays of integers. But, to save bytes, it was ultimately encoded more compactly.
I enjoyed creating this entry so much that I ended up writing a sequel to it in C# that maintains the same look-and-feel as the original, but vastly expands the gameplay.
This game’s name is based on R-Type (arcade), but it’s more of a spiritual successor to Squarius, one of my entries to a prior J4K competition. It’s a space-themed side-scrolling shooter rendered with geometric forms instead of bitmaps to save space. There are no weapon upgrades and your red circular ship is on constant auto-fire. The enemies are limited to circles and worms, but each stage has unique, distinguishing features and obstacles. Like many of the shooters that it’s based on, one bullet hit or one collision with an enemy or a wall sends the player all the way back to the start of the stage, which can be frustrating. Nonetheless, it’s a lot of fun to play.
Demon Attack 4K is a nearly perfect port of Demon Attack (Atari 2600), a space-themed fixed-shooter that resembles Phoenix (arcade). The enemies appear in waves, each slightly more advanced than the last. Some waves introduce new weapons such as streaming lasers or pellet clusters. After wave 4, when the demons are shot, they split into 2 smaller, bird-like creatures. And if you kill a bird’s partner, the other will take a kamikaze dive into your ship. After wave 8, the bullets track beneath the demons, making targeting even more difficult.
Staying true to the original, the 4K version includes the Imagic logo and demo mode. And the game ends after the 84th wave. The only thing missing is the sound effects.
Like Jungle Hunt 4K, Keystone Kapers 4K and Pitfall 4K, this entry was created by extensively studying the game in an emulator as well as analyzing the original’s source code.
Keystone Kapers 4K is a nearly perfect port of the Atari 2600 game. It’s only missing the sound effects.
You play a security officer who needs to capture a shoplifter in a three-story department store before he escapes. Deterring your efforts are bouncing beach balls, cathedral radios, rolling shopping carts and toy biplanes, which must be jumped over or ducked under to pass. Escalators and an elevator provide movement between the floors. Along the way, you can pick up stolen money bags and suitcases for extra points. A mini-map at the bottom of the frame shows your location, the shoplifter’s location and the state of the elevator. If you catch the shoplifter, the game repeats with increased difficulty.
Like Demon Attack 4K, Jungle Hunt 4K and Pitfall 4K, this entry was created by extensively studying the game in an emulator as well as analyzing the original’s source code.
Jungle Hunt 4K is a nearly perfect port of the Atari 2600 game. And it should be noted that the original Jungle Hunt ROM is 8K. In other words, this entry miraculously fits in all 4 of the original levels in half the space. Though, it does lack the tunes and sound effects.
The jungle levels feature parallax scrolling. And, although the foliage pattern looks random, it’s actually an exact duplicate of the pattern in the original game. While creating ports, I attended to many details like that, which most players won’t even notice.
In the first level, you swing from vine to vine. If you miss a vine, you’ll plunge to the jungle floor and lose a life.
In the second level, you swing through a crocodile-infested river. Crocodiles can be attacked from below with your knife. Periodically, you must return to the surface for air.
In the third level, you jump over or duck under various-sized rolling and bouncing boulders.
In the forth and final level, you need to hop over cannibals to save a woman being held captive.
If you beat it, the game repeats with increased difficulty.
Like Demon Attack 4K, Keystone Kapers 4K and Pitfall 4K, this entry was created by extensively studying the game in an emulator as well as analyzing the original’s source code.
Pitfall 4K is a nearly perfect port of the Atari 2600 game designed by David Crane. It features all the original obstacles, maze layout and graphics, including the Activision copyright and logo. It’s only missing the sound effects.
The object is to collect 32 treasure while avoiding all the hazards of the jungle. And the only way to do it in the 20 minutes allotted to complete the game is to use the underground tunnels, which act like portals. Each screen crossed underground is equivalent to 3 screens on the surface. But the underground tunnel system is also a maze with dead ends.
Three changes were made to reduce the original game’s difficulty. First, you can change direction midair, making jumps easier. Second, the underground scorpions no longer reverse direction when you attempt to jump over them, making them easier to pass. And third, a secret compass was introduced that will guide you through the optimal pathway, which can be enabled by pressing 8.
Like Demon Attack 4K, Jungle Hunt 4K and Keystone Kapers 4K, this entry was created by extensively studying the game in an emulator as well as analyzing the original’s source code.
The 7 stages of this side-scrolling space shooter pack in a surprising amount of variety, but they can be brutal. It lacks many of the features found in its inspiration, such as the weapon bar, but it certainly maintains the high difficulty. There are lots of enemies that are hard to hit and lots of bullets that are hard to dodge. There are occasional surprise attacks that can only be avoided by sheer luck or memorizing the stage layout. And there are no intra-level checkpoints. One bullet hit or one collision with an enemy or a wall kills you, sending you all the way back to the start of the level without any powerups, making the successive run that much more difficult. The game is painful yet somehow still a lot of fun.
The graphics are a mix of sprites and procedurally generated elements. The cylindrical background effect was inspired by stage 4-3 in Super Castlevania IV (SNES). The level data is stored in the binary in the same fashion as the bitmapped sprites. The final bosses are scaled sprites, each scaled slightly larger than the last. But each of their patterns is nearly identical.
This is a demake of Wolfenstein 3D, a first-person shooter in which you blast Nazis into oblivion. Blue doors can be freely entered. But gold doors require a key that’s hidden somewhere within the maze-like bunkers. To complete each of the 6 levels, you’ll need to defend yourself against an army of Nazi soldiers as you search for those keys, pass through the gold doors and then the battle bosses behind them.
I created this game in response to Wolf5K, Lee Semel’s winning entry to the 2002 Javascript 5K contest. Semel’s game features very primitive monochrome graphics. But the size constraint for that contest applies to source code, not the executable binary. With that in mind, I realized that I could create a much richer demake.
The 2.5D effect is generated through textured ray casting. The level maps are somewhat based on the actual Wolfenstein 3D maps. And they are stored in the same way as the bitmaps.
As for gameplay, navigation could be improved. When you collide with walls, you instantly stop instead of sliding along them. Strafe would also be beneficial. Both of those features probably could have fit. The game is also a bit repetitive, but so was its inspiration.
Crack Attack 4K is a port of Tetris Attack (SNES), a tile-matching puzzle video game. The goal is to clear tiles by forming rows or columns of 3 or more of kind. But you’re restricted to swapping 2 neighboring tiles, horizontally. If you swap a tile into empty space, it will fall. The same happens to tiles above a clear and both can trigger chain reactions. All the while new tiles emerge from the bottom of the playfield, slowly causing the entire stack to rise. If the stack reaches the top, it’s Game Over.
All the graphics and mechanics are borrowed directly from the SNES game. However, in this version the cursor is controlled with the mouse.
Out Run 4K is a demake of Out Run (arcade), a 2.5D driving game in which the player controls a Ferrari from a third-person rear perspective. The road curves, crests and dips, increasing the challenge by obscuring other vehicles and obstacles near the shoulders. The other drivers become ruder the further you advance, upping the difficulty. Collisions slow the player down, wiping precious time off the clock that he races against. The run is broken up into 5 segments, each separated by a checkpoint that resets the clock. If you make it through them all, you beat the game.
The road, sky, telephone poles, trees and snowmen are procedurally generated. The road and sky textures were based off actual photographs. And the textures and trees have fractal elements. The vehicles are all the same symmetrically-mirrored bitmap with varying colors that was modeled from the Ferrari sprite in Out Run.
I created this entry to learn about the 2.5D algorithms used in arcade racing games before the advent 3D hardware. The traditional versions manipulate an image of a straight, flat road that recedes to the horizon. The road is striped, enabling color cycling to create the illusion of forward motion. For curves, scanlines are individually shifted horizontally by different offsets. For hills, scanlines are skipped or duplicated. Computing the scanline shifts, skips and duplicates does require a tiny bit of 3D math, but it’s nothing that significantly taxes the CPU.
Also note that the timer is displayed as a progress bar rather than text. Getting fonts to display consistently across all environments requires a significant chunk of setup code. Instead of risking display issues, I tried to avoid text completely in J4K2011 and beyond.
In this demake, it can be difficult to get around some of the obstacles. If you hit a car, you must wait for it to move out of the way before driving forward or else you’ll end up repeatedly bumping into it. It’s also obvious that some of the other cars are intentionally trying to collide with you. This entry would have been improved had those issues been adjusted.
Overall, this game is a fun little challenge. But the entire run can be completed in about 4 minutes and there is little reason to play again after that.
This demake of Super Mario Land (Game Boy) features 5 levels of side-scrolling platforming. All the graphics are borrowed from the original. Goombos, Bombshell Koopas, Piranha Plants, Bullet Biffs, Flies, Bunbuns and, of course, Mario and Princess Daisy make an appearance. And, unlike the original, the backgrounds in this version employ parallax scrolling.
Some compromises were made due to space limitations. There is no small and big Mario, and he can’t duck. There are no mushrooms or other items hidden in blocks. In fact, Mario can’t break blocks. Instead, he jumps right through them. Mario also has only 1 speed. The stages are procedurally generated, making them less enjoyable than the carefully crafted ones in the original game. And there is no music or sound effects.
The game is difficult yet fun. It’s worth battling through the 5 levels to see Princess Daisy in the ending.
Boing 4K is a demake of Monster Rancher Hop-A-Bout (PlayStation). It’s a 2.5D puzzle platformer in which you play as a perpetually hopping bunny that needs to cross a series of chasms. When the game starts out the platforms consist entirely of purple tiles and you simply need to make sure that your shadow lines up with one of them to avoid plummeting to the depths below. Successive levels introduce a variety of different tile types designed to make your journey a lot more difficult. For instance, tiles with green circles propel you far up into the air. Red arrows launch you in particular directions, sometimes even backwards. Yellow chevrons do the same, but at a much faster speed. Exclamation mark tiles vanish after you bounce off them. Pause bars slow you down. And question marks may do any of the above.
Boing 4K can be brutal. If you fall off a platform, the game returns you to the last-contacted purple tile. And on sections where purple tiles are sparse, a mistake can throw you back quite a distance, erasing a ton of progress. Since you race against the clock, a single error like that can kill the entire run. Worse, since exclamation mark tiles vanish after use, if you screw up around them, there may be no way to recover. Luckily, there aren’t that many levels and if you have the skills, the game can be beaten in under 15 minutes.
All the tiles and the bunny sprite use mirror symmetry to save space. I think the purple tile originated from one of the Mega Man games. And I drew the other tile symbols on top of it. The bunny might have been based off a sprite in one of the Tiny Toons games.
This demake is based on the final course in Mario Kart 64. It maintains many features of the original.
Green shells fire directly forward. Red shells home in on the opponent whose rank is one higher than the you. And blue shells navigate along the track until it homes in on the player who is currently in first, potentially hitting others along the way.
In the original game, green shells travel in straight lines, bouncing off walls as they advance. Due to byte constraints, I simplified the motion. The green shells still fire directly forward, but they will also follow the curves of the track instead of bouncing around. You can take advantage of that to target other players.
Thunderbolts temporarily shrink all the other racers making them slower and weaker. The background flashes when a thunderbolt is applied.
The player can obtain either 1, 3 or 10 mushrooms, the latter taking place of the golden mushroom due to space limitations.
To save space, all the sprites take advantage of mirror symmetry. The question mark blocks are noteworthy because the reflected icon resembles an eye bolt.
The track layout is stored in a vector graphics format. It’s a path made of straight lines and circular arcs that was constructed by manually tracing the minimap displayed in MK64. The elevation changes were introduced at runtime using a sine-based function.
Like a rigid wire, the track layout is a path in 3D space. By taking vectors that are simultaneously perpendicular to the path and to the vertical axis, the path is widened into a ribbon of polygons. Then, they are projected into 3D, where polygons behind the player are culled. Since the rainbow-colored polygons are translucent, sorting is not required during projection. However, the sprites still need to be sorted before being drawn over the rendered track.
All points on the ribbon can be specified with 2 parameters: the distance along the path and the distance perpendicular to the path. When a driver advances forward, rather than moving in a straight line, he advances along the path. When a driver steers left or right, rather than turning, he moves perpendicular to the path. With this restriction, the virtual camera only needs to be oriented in the direction of the path.
Game objects exists in a coordinate system with a changing orthonormal basis such that the first unit vector points along the path, the second points to the edge of the ribbon, and the third points up and away from the ribbon. The third unit vector can be experienced when a driver is hit by a shell, which throws him upwards. This coordinate system is the same as the one in Out Run 4K, even though its rendering is only 2.5D. Employing it greatly simplified the object interaction logic.
Packed into this mind-blowing 4K entry is an RPG in which you fight monsters, collect items, use them to progress, and freely explore the world around you. It’s a demake of the classic action-adventure NES game, featuring a ton of graphics from its inspiration and an original map. To rescue Princess Zelda, you’ll have to locate your sword, locate a torch, navigate through dark caves to find keys, and unlock and break through passage ways all while battling Octoroks and collecting hearts to replenish health.
Dord is an original puzzle-platformer featuring 56 levels. The goal is to collect all the diamonds while avoiding things that kill you.
Some levels contain keys that unlock certain areas. But they need to be collected in a very specific sequence or else some diamonds will remain forever out of reach. If you make such an error, there is a button to restart the level.
The edges of the frame act like portals. If you leave one side you immediately reappear on the opposite one, maintaining speed and trajectory. Exploiting that mechanic is pivotal to solving the puzzles.
The graphics style and gameplay are an homage to early 80’s computer games, particularly Freddy’s Rescue Roundup (PC). The spikes and appearing block sequences were inspired by Heat Man’s stage in Mega Man 2 (NES). The reverse gravity was inspired by Strider (arcade). The enemy sprites are based on Space Invaders (arcade) and the aliens in The Simpsons: Bart vs. the Space Mutants (NES). The large eyes on the player and the enemies were inspired by anime and its appearance in games like the Mega Man series. The rotating orange enemy chains were inspired by the fire bars in the castles of Super Mario Bros. (NES). The rotating yellow enemies were inspired by the Zingers (the bees) in Donkey Kong Country (SNES). In an early version, the player collected strawberries, but they morphed into strawberry-shaped diamonds after trying to come up with something more appealing.
This was last 4K entry that I ever created. It combined many of the code squeezing techniques that I picked up over the years. Low-rez symmetric sprites were used, enabling me to pack as many levels as possible. It took an incredibly long time to come up with 56 unique puzzles.
One extra bit of trivia: The title of the game comes from a meaningless word that at one time inadvertently appeared in the dictionary.
|
Copyright © 2018 meatfighter.com |