new game : Dragon's Lair !

Ah .. such a nice game to play on the Bitbox ! (see Angry Video Game Nerd or Joueur du Grenier reviews ;) ... )

The game is open source and the release is here : https://github.com/makapuf/bitbox-fmv

For more info about the game see : http://www.dragons-lair-project.com/games/pages/dl.asp
for Bitbox itself see main repo / wiki : https://github.com/makapuf/bitbox/



 


This game / engine is aimed at reproducing the dragons lair game on the Bitbox. It's only compatible with the standard bitbox since the data is streamed from SD card.

New game : Alter Ego

Hi all !

A new game has been published ! It's a port from the Alter Ego NES game (with reused graphics but the code is entirely new). It runs on the bitbox micro as well as the bitbox (as every micro game).

have a look at its gameplay

• The original (non-opensource) game is featured here : www.retrosouls.net/?page_id=614
• The page for the opensource NES port, upon which this project art is based, can be found here : http://shiru.untergrund.net/software.shtml#nes
• Of course the game is opensource : https://github.com/makapuf/bitbox-alterego

 

A longer is also available on youtube 

(The game has currently no sound but that shall be improved upon soon !)

New game : rapid ball !

Hi, you may be remembering rapid ball on old nokia phones, here is a simple version for the Bitbox ! You just guide a ball falling platform to platform (not the spiky ones) get new lives and avoid touching ceiling or floor ! What score will you do ?

makapuf

Developing Memory Matrix

Hello, my name is Lucas (not makapuf) and I wanted to walk you through my experience developing a game for the bitbox console.

Intro screen.  Prepare to memorize!

Let's get started!

ZX Spectrum emulator !

BitboZx

Hi, here is the first release of the BitBoxZx, a 48k ZX Spectrum emulator !

New game : Polar !

Polar is a small game written in ~ half a day.

Here is the link to the github project

Here are some screenshots - a very simple game indeed, <200 lines of C and a few sprites.

 

The game is still missing sound, music and more levels .. but the few levels are perfectly playable !

This game has been inspired by Polarity, a game written for ludum dare 23 by nornagon (
http://nornagon.net/games/polarity/ https://github.com/nornagon/polarity. ) but the code and GFX are original.

New Game : Boulder Dash clone

Why, yes a clone of boulder dash was one of the simple games I wanted to implement.

It's not completely finished (missing new sounds, levels, and ennemies), but the main elements are here in their 640x480 glory, inc. sound&music, basic gameplay, intro screen

Here is the repository (including a binary release for eager testers :)

Everything in the game is tile-based, and the whole game data is in fact just a uint8_t[] array of tile references, with its small finite state machine. The main and only .c file is 380 lines- not that I am so proud of it, it grew quite organically, but eh : now is better than never.

Demo (click on it to see fullscreen)

BitBoy : a gameboy emulator for bitbox !

BitBoy is a port from the gnuboy emulator heavily modified to fit in the Bitbox console.

The Gameboy emulator successfully emulates several games and homebrews for this venerable console.

Screenshots

Screenshots of the emulator.

The menu to select the on-chip games


NB :  Emulators are standard SDL games built with all bitbox programs running on the bitbox kernel with no modification of the game source code as the normal build of any game.
Meh, an emulator. But not only, it runs also on the real hardware : 

Available features

• Based on (heavily modified to fit in memory constraints : 1MB incl. games & vga generation+ 192k RAM !) gnuboy emulator, as GNU GPL code available on github
• Working Commercial and homebrew GameBoy titles (public domain homebrews or rightfully licensed games !)
• 4 color palette B&W display, with custom palettes (fixed colors by game) to colorize the games.
• Working on rev1 hardware including gamepad
• Several ROMs can be embedded in on-chip flash (up to 1MB), with a selection menu

Source code

Code (including original very good gnuboy emulator heavily modified) is available here : https://github.com/makapuf/bitboy

Making of 

The adaptation of gnuboy to bitboy consisted of : 

• mapping the inputs to bitboy rev1 gamepad
• rewriting the main loop & main function (from command line to bitbox kernel frame interface), remapping time-relating functions.
• interfacing the sound callbacks of bitbox to gnuboy engine generation.
• removing / disabling all file related functions. Some could be re enabled to save some backup RAM to SDCard by example or load data cart from SD Card.
• rewriting all the display code, not to fit bitbox display model -this adaptation was done quite simply by blitting a virtual framebuffer, but to make it faster and not depend on huge (100k) in-memory precomputed tables. Now only B&W GB has been done, but color could be done.
• writing a blitter for the gnuboy pseudo-vram to Bitbox graphical kernel. Maybe this step (and the 2 VRAM buffers) can be skipped and real Bitbox lines be generated on the fly by the new gnuboy, faking Gnuboy v-syncs from the real Vsync bitbox interrupts.
• modifying the memory mapper to use bitbox flash / Ram & mapping some RAM data (2 VRAM buffers) to ccm ram in order to save place in sram, disabling many functions like rom compression, battery-powered ram.
• making a menu loader of ROMs in Flash, replacing the file loader. This is currently done by embedding roms as C data. Some quick "compression" could be done. (removing zeros or const data at end of pages)
• menu selection of ROM as several ROMs can be placed in flash
• linking ROM to custom palettes : Color games are not supported yet (colorized games using custom palettes are supported however), but given the size of those color games, they often wouldn't be able to be stored on the box anyway.
• cutting color gameboy features to simplify development and lower memory requirements (standard GB has 8k, GBC has 32k of RAM, which could fit in CCM RAM, 16k VRAM vs 8k, and much larger games - often starting at 1MB).

Future work

Many things could be done (contribs welcome ! ) to further development :

• Some graphical glitches on games (or frankly ugly artifacts), yes, they exist.
• Sound has been neglected, ie should work, has worked, but now doesn't.
• Loading ROMs from SDCard to RAM (64k max cartridges) - or even flash programming from uSD ?
• Saving games states as  SDCard files
• HiDef Scale2x type graphical output ?
• Support of GBC seems doable, maybe in a future release, this would include working around memory limitations and reimplementing color GB features in graphical layer, on the fly loading some pages in RAM from SD to handle large ROMs?
• Maybe adapting this emulator or graphical engine for NES ?

New game published : Fire !

Fire game has been published !

It's a simple game described in a series of tutorials.
The engine is very simple and all code is about

The game runs at 640x480, 4096 colors 60fps. Here is a record of the simulator running under linux.

Code, Graphics by makapuf

To compile it you'll need embedded-gcc and python (image to C scripts)
The .bin file is 136k, available on github (as well as the source & graphics) ; upload to bitbox using SWD interface by example.



The game is currently made for bitbox rev1 (but as all games, will be adapted to rev2).

Tutorial : Creating a small game from scratch : game logic

Hello all !

In order to let people know about the process of making a game for bitbox (or a toy 2D Game in general, this post will have very few specifics to bitbox, next ones will be more involved) , I'll blog a few times to show you that in detail.

The game will consist in a bunch of people jumping out of a building on fire, and a team of two firemen who will make them bounce to the ambulance. It'll be programmed in C99, without any complex techniques.

Sounds familiar ?

First bitbox simple game preview : Jump ! (video)

I programmed a simple, very bare tile/sprite engine+game to test everything : JUMP !

Screenshots from the emulator

The game is a very simple vertical scrolling platformer where you only control left/right and die if you touch the base of the screen. Different platforms types make you jump higher, ... and there are other types :)

Debugging using gdb on the board itself is possible through SWD (the kernel giving you some perf data stats), but for game devel, I also developed a simple SDL-based emulator of the kernel for on-computer tests. Of course it's certainly not accurate but it can be useful for graphics and gameplay-related tuning.

Now, the game is playable - although still very rough - level needs a bit of work, there is no sound (edit : yes there is now !) , imperfect collisions, need to add some bonus, maybe particles, ...- but stays enjoyable nonetheless.

 Sample screenshots from the game, and a video (no sound).





bitbox first game prototype ! from mak apuf on Vimeo.