Worklog for bennugd-wii

La Red Resiste

2011-12-02T09:25:00.001+01:00

(This is a post about the Spanish government passing a ruling by decrete that bypasses judiciary power just to please a moribund industry and the US government, please excuse the off-topic if you're only interested in programming)

Hace exactamente dos años tuvimos conocimiento del anteproyecto de Ley Sinde. Gran parte de la ciudadanía señaló de inmediato su rechazo en las redes a través del #manifiesto por los derechos fundamentales en Internet. En estos 24 meses el debate social sobre esta iniciativa ha sido intenso y ha aglutinado a ciudadanos y organizaciones preocupados por la merma de derechos y libertades. Ahora, pocos días después de haber sido deslegitimado por las urnas, un gobierno moribundo pretende aprobar el reglamento que desarrolla esta ley en abierta connivencia con el gobierno entrante.

La Ley Sinde tendrá numerosos efectos indeseados: al introducir una fuerte inseguridad jurídica en la regulación de Internet, se dificulta gravemente la actividad de los emprendedores tecnológicos que el Partido Popular pretende que contribuyan a reactivar la economía. La redacción de la Ley Sinde señala claramente que se aplica a todos los servicios de la sociedad de la información; no deben confundirnos los mensajes que afirman que su única razón es la de cerrar webs de descargas. Nada es peor para el crecimiento de un mercado que la inseguridad de no saber si al día siguiente un negocio puede ser cerrado por la aplicación arbitraria de una norma en manos del gobierno de turno.

El panorama de la propiedad intelectual en nuestro país es atroz: la Embajada de los Estados Unidos ha impuesto la aprobación de la Ley Sinde, el canon digital a empresas y administraciones fue declarado ilegal por el Tribunal de Justicia de la Unión Europea pero tras año y medio se sigue pagando, los antiguos dirigentes de la SGAE -siempre defendida por el Ministerio de Cultura- se hallan imputados en la Audiencia Nacional por el saqueo generalizado del dinero de los autores. Este panorama cuadra con el general: una corrupción política extendida y no censurada en las urnas, unida a la subordinación de la democracia a los intereses de unos pocos con nombres y apellidos a los que sin embargo se les llama “mercados”.

Sólo con inteligencia, diálogo y trabajo se pueden resolver los actuales retos de la propiedad intelectual y comenzar a construir una salida a la preocupante situación económica actual. Como el Tribunal Europeo de Justicia, entendemos que la tensión entre la propiedad intelectual y la libertad de empresa, el derecho a la privacidad y el derecho a recibir o emitir información ha de resolverse en favor de estos tres últimos derechos. Será la única manera de crear riqueza y de mantener las libertades que tanto ha costado conseguir.

Frente a la arbitrariedad, la defensa histórica de la ciudadanía ha consistido en asegurar la garantía de los derechos fundamentales sustrayéndolos de la política, esto es, de los poderes de la mayoría y del mercado: se trata de derechos inviolables, indisponibles e inalienables.Los gobiernos van y vienen. La red resiste.

Marcos Lopez: Part II

2011-09-25T19:38:00.004+02:00

BennuGD user beredezebe has packaged mz's "Marcos Lopez: Part II" game to our loved Wii console.
You can find more details of the game here and in the meantime you can watch a video of the game in action below but you better give it a try!

Get it from here.

Updated binaries

2011-09-13T03:51:00.000+02:00

As you might now from the BennuGD-mobile blog, my most recent work on BennuGD has been focused on using the monolithic architecture I created for the Wii port to engineer the Android & iOS ports.
While most of the work has gone into those, the Wii port has also received all the updates from upstream BennuGD and the other day I made some test binaries just to check that the Wii code still compiles as it should.

I'm releasing these untested binaries just in case they're useful to anybody, but please be aware that they might expose bugs and eat your homework. Apart from that, they feature the latest and greatest in BennuGD featureness.

~~Grab the updated binaries from here.~~

[Update] Ups! Looks like I screwed up something with the binaries! thanks a lot to beredezebe for testing them.

"Morshu the MMMMMM" new BennuGD-Wii game!

2011-09-03T15:36:00.004+02:00

Reader Beredezebe writes to let us know that a new BennuGD-Wii game created by user blabla has been released. It's called "Morshu the MMMMMM" which features pretty cool graphics and is available in French and in English.

Read all the news and info about the game in the original NintendoMax thread [FR].

Meanwhile, you can see a video of the game below:

Get the game from here.

Hope you like it, and thanks to Beredezebe!

[Updated to cite blabla as the author of the game, beredezebe is the author of the port]

On the new monolithic architecture

2011-08-04T03:03:00.003+02:00

(Cross-posted to bennugd-wii and bennugd-mobile blogs).
I've been wanting to write this post for quite some time now. I feel it's time to share some of my thoughts about how the monolithic version of BennuGD is designed.
If you've followed the bennugd-wii blog since it began, you may already know that the current design is the third iteration of the monolithic version of BennuGD. This article is obviously about the current design.

Why do we need a monolithic version of BennuGD?
Some of you might know that one of the main design goals of BennuGD after forking Fenix was to become modular so, why do we need a monolithic approach?
Well, even if the modular approach seems to have many advantages over a monolithic one, not all the systems support it. BennuGD relies heavily on dynamic libraries (dlls if you're on Windows, so files if you're in most Unix-like systems or dylibs if you're on OSX) and the operating system provides a way of dealing with them.
In most systems, that way is called libdl and it works really well. If you look inside your system you'll realize that there are literally thousands of dynamic libraries lying there, so the system works.
In other -usually smaller- systems we don't have that system nor any other equivalent one and it turns out that some of those systems are particularly interesting for us in the game-making world* so we must find a way to avoid that limitation while conserving as much of the modular design as possible.

But that makes loading libraries that weren't compiled in impossible, doesn't it?

Yep, that's why I call the design monolithic. It would be perfectly possible/pretty easy to create a design based on the current one that combined both ideas by including some modules inside the main binary and loaded others from external module files, but I didn't bother to create it as I don't feel it makes much sense.

How does BennuGD handle modules?
In trying to understand how to bypass the limitation, we must first understand how BennuGD works with the modules.
This is -roughly- what happens when you ask BennuGD to import a module (let's use mod_video as an example):

BennuGD will look for a file that follows the system naming convention for dynamic libraries in a set of pre-defined directories in your system. For example, in Windows BennuGD would first look for mod_video.dll in the current working directory. Let's imagine the file is found there.
BennuGD asks the system to load the library and quits if it finds any errors.
It asks the system for a list of symbols that define compose it. For example, mod_video_constants_def** would be an array containing the constants defined by the library and mod_video_functions_exports would be an array of the functions that the module provides. There are many more that the libraries can define and they're all completely optional.
Based on the info gathered from mod_video.dll and the rest of the modules BennuGD creates a table with all the information they provide and goes on to compile your code taking that information into account.

So, how to bypass that process?

Well, the best way I could think of when creating the monolithic approach is to construct that table of symbols by hand when creating the BennuGD binaries and compile all their functionality inside the interpreter. Obviously I also had to change the code that performed steps 1-3 so that instead of looking for the symbols in the actual module files it looks for them in the array. As a result when the library loader module is asked to load a module it looks for the library in the array and returns its position in the array (it literally returns a number: look for this library's symbols in the nth row in the array).

You can have a look at that table here; lines 119 and on.

There are two symbol arrays there
It turns out that the BennuGD compiler and the interpreter need slightly different symbols: the compiler doesn't really care about what your program does as long as it is written correctly and therefore it only cares about the symbols that define how a correctly-written program should look like. So it needs to know how a function should be called (which is the function name, what type of/how many arguments it accepts) but it doesn't care at all about what it does.
The interpreter, in the other hand, needs to know everything about what that function does when called.
There are, also, symbols that both parts need to know about (which are a particular libraries' dependencies, for example) and others that are only useful to the interpreter and therefore I chose to split the list of symbols in two: one with the symbols only needed by the interpreter and another one with the symbols useful to both the compiler and the interpreter.

Defining the actual symbols
If you have a look at the code linked above, you'll find that the symbols themselves are not defined in that file but are included from another file called mod_video_symbols.h.
That file doesn't exist in upstream BennuGD and it explicitly declares the the symbols required by the BennuGD compiler and tells the C compiler what the names of the rest of the symbols are and that they're complete declaration will come from somewhere else (hence the extern word in the declaration after the #else clause).
You can see that the last column in the functions list is set to 0 when compiling BGDC. That column should tell BennuGD what C function to call when the user calls that BennuGD function. As I said, the compiler doesn't care about what that function does and therefore we don't need to declare it. If we did declare it we'd have to compile all the code for all the modules into BGDC, too. There are other more complex reasons to not try to compile all the module code into BGDC, too.

When compiling the module code, the symbols come from mod_video.c which is the unmodified module file from upstream.

So you're writing the symbols many times!
Yes. The issue would be very easily solvable if I were the main author of BennuGD and that was how the second iteration of the architecture worked.
Unfortunately that meant that any patch from upstream takes a lot of work to be integrated as ALL the symbol-defining files had to be modified by hand: when a change came from upstream I had to locate the exact line where that change was done and apply it by hand into my code. Taking into account that each patch might contain hundreds of changes split across multiple files, that made maintaining the project a huge task even if we forgot that the main goal of the project was not to create a monolithic build of BennuGD but to create a port of BennuGD to a set of new platforms, which meant quite a bit of work by itself.
Right now I can just drop the files from the upstream version of BennuGD into my source tree and upload the code to the SVN server. I still have to be careful with the patches to supoprt platforms not available upstream (Wii, PSP, iOS & Android) but this new way of working makes things much simpler than before.

Advantages of this approach
To start, DCBs compiled with upstream BennuGD work just fine -endianess issues aside- in the monolithic builds and vice-versa.
The modular approach isn't gone. Even if the modules are all inside the binaries, they won't get loaded until you actually import them. This saves memory in some systems and from the user's point of view it's transparent: both architectures behave consistently to him.
My code is prepared to be compiled as either a monolithic build or the normal BennuGD modular structure so you can compile both from the same source code.

So that's pretty much it, hope to hear your thoughts in the comments and hope I made it clear in case it's useful to anybody.

* Consoles like the Wii or the PSP don't support it and other systems like the iPhone do support it but Apple seems to be very restrictive about the use of dynamic library loading in third party applications.
** That's why you cannot just rename your modules, BennuGD would then look for the wrong symbols.

A game made with BennuGD wins the NintendoMax contest!

2011-06-26T16:31:00.001+02:00

Beredezebe writes to let me know that the results for the Nintendomax Wii Dev Competition 2011 are now out, and know what? La Momia que Fuma's "Mr. Sitwell in Turbo WC Magical Adventure" is the winner!

The judges say:

Cid2mizard: J'adore l'ambiance déjanté du jeu, c'est un shoot them up original. Les effets visuels sont super, la maniabilité est très bonne. Un jeu comme on voudrait en voir plus souvent. Je ne serais pas surpris de le voir à la première place!

beredezebe: Ça, c'est ce que j'appelle un jeu ! Pour commencer, on a affaire à un humour très fin (un type sur des toilettes volantes qui doit cracher des trucs sur un Sumo aérien), les graphismes sont excellents, la durée de vie est très bonne et la difficulté est au rendez-vous ! Je n'ai vraiment rien à redire, mis à part la voix de Mr. Sitwell (au bout d'une demi-heure, c'est un supplice) et une difficulté un peu trop grande dès le départ (on doit pouvoir s'adapter avec le temps). Mon coup de cœur pour cette année.

ConsoDreams: Un jeu bien réalisé, graphiquement c'est pas mal. Dans les bons titres.

Which -roughly, my French is not what it used to be- translates to:

Cid2mizard: I love the crazy ambiance of the game, it's an original shoot'em up. The GFX are great and the playability is very good. A game like we'd like to see more often. I wouldn't be surprised to see it in the first place!

beredezebe:That's what I call a game! To start, we're dealing with a very fine sense of humour (a guy on a toilet who must shoot a flying Sumo), the graphics are excellent, the life endurance is very good and the difficulty is fine! I really don't have any complaints except for Mr Sitwell's voice (after half an hour, it's a punishment) and the difficulty might be a bit to high at the start (it should adapt better during playtime). My favourite for this year.

ConsoDreams: A very well-done game, graphics aren't bad at all. It's amongst the good titles.

So there you have it. The jury's also noted the high quality of the entries, which makes Momia's victory even more valuable :)

Download the latest update of the game from here.

The other BennuGD-created game I know of -Pong Breaker- has rated seventh in the contest.

Have a lot of fun!

Mr. Sitwell in Turbo WC Magical Adventure

2011-06-02T00:52:00.000+02:00

The date has arrived and the game submitting phase for the Nintendomax Wii Dev Competition 2011 is now over and at least one BennuGD game has been submitted: La Momia que Fuma's

La Momia que Fuma (Momia, for short) is well known for his unique drawing style and his humorous games. He won last year's BennuGD/GPH game programming compo with EEEEK! EEEEEK! HOOOOOOK!!!. I already blogged about the game and its Wii version in this blog enntry.

You can see a video of his new game below (thanks to Cid2Mizard!).

Hope you like it.

Get it from here.

BennuGD for mobile blog, more games

2011-05-18T12:59:00.001+02:00

I've created a new worklog on using BennuGD to create games for mobile devices. The binaries published there share the same code base as those for the Wii and also come in a monolithic package.
I've written a few articles there already, so be sure to give them an eye if you're interested in creating games for mobile devices.
You'll notice that most articles are iOS-centric, but fear not Android fans! an Android port is underway and once it's usable, I'll post more info for you too.

Just a small note, iOS & Android usually work on little-endian chips so the DCBs created in your Wii just won't work there, on the bright side you can use the DCBs compiled in any other little-endian machine (your computer, that is) in you pocket computer.

Without further ado:

BennuGD for Mobile

Hope you like it.

PS: I'll update some games soon.

BennuGD to change license to Zlib (you can now create console games with BennuGD)

2011-05-14T02:01:00.000+02:00

Good news everyone!

BennuGD has changed license to Zlib. What this means is that you can now use BennuGD to create commercial games for any popular consoles.
In particular, you can now create BennuGD games for the Wii and publish them through the official channels. To do so, you need to be a registered Nintendo developer (conditions and application forms at Wario World). You won't be able to use the binaries I provide here through the original channels, as you'll need to use Nintendo's own SDK.
If you've got a developer license for the Wii or any other major console and want to see BennuGD ported to that platform in order to rapidly create wonderful games, drop me a line; we might be able to help each other.

bennugd-monolithic ported to Xbox

2011-05-02T23:39:00.001+02:00

A user by the nick of A600 has ported the bennugd-monolithic code to the original Xbox console (the one with the Intel processor, not the Xbox 360) for the purpose of running Streets of Rage Remake there.
You can grab everything needed to run the game there (the package includes full source code and a Visual Studio solution for compiling the code) from here.

A bit off-topic, but I thought it might be of interest to some of you.

How to use mod_wpad when compiling your code in other platforms

2011-04-08T00:51:00.002+02:00

Following the entry on how to compile directly from the Wii's Homebrew Channel, I'd like to comment on a little "trick" that'll allow you to compile code that uses mod_wpad both on your computer and in your Wii.
The idea is to use preprocessor macros to "hide" the code when compiling in platforms other than the Wii.
Following with the meta.xml from that example, the new one would be as follows:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<app version="1">
   <name>Compile Fancy Game</name>
   <coder>Your name</coder>
   <version>Version number</version>
   <release_date>Release date</release_date>
   <short_description>A short description.</short_description>
   <long_description>A longer description for the entry that'll compile your code.</long_description>
<arguments>
   <arg>boot.prg</arg>
   <arg>-o</arg>
   <arg>/apps/fancy_game/boot.dcb</arg>
   <arg>-D</arg>
   <arg>TARGET_WII</arg>
   </arguments>
</app>

That code would be pretty much like compiling your code in the PC like this:

bgdc boot.prg -o /apps/fancy_game/boot.dcb -D TARGET_WII

And in the code, where you do the mod_wpad import, you'd change it to:

#ifdef TARGET_WII
import "mod_wpad"
#endif

And, a little bit below that:

#ifndef TARGET_WII
#define wpad_is_ready(a) 0
#define wpad_info(a, b) 0
#define wpad_info_nunchuk(a,b) 0
#define wpad_info_classic(a,b) 0
#define wpad_info_guitar(a,b) 0
#define wpad_info_bb(a,b) 0
#define wpad_rumble(a,b) 0
#endif

The first block will only import mod_wpad in case the compiler defines the TARGET_WII macro, and that'll only happen in the Wii, if you adapted the code above.
The second block will void the wpad_* functions. For your program's logic, it'd be as if no Wiimote was connected.

Hope this helps you with the Nintendomax Wii Dev Competition 2011, where you can win a Nintendo 3DS console, and much more".

Happy coding!

Streets of Rage Remake v5 final released, it's impressive!

2011-04-05T18:55:00.000+02:00

Bomber Games have released the final version of their BennuGD game called Streets of Rage Remake v5 (remember the video I posted about it featuring accelerometer controls?). This release is the culmitaion of 8 years of hard work and features 103 stages, 19 playable characters, 64 enemies. The source code for the game is over 80000 lines of code and tries to faithfully recreate the experience of the original game.

It's really cool, although it seems to have some problem on the Wii. I'll work with BoMbErLiNk to try to make sure the game comes to our Wiis at some point.

Be sure to read their own presentation of the game in their blog.
I leave you with some media from the game:

BTW, in the meantime you can play it in your computer, download it from here.

Congrats, Bomber Games!

Compiling your code directly from the Homebrew Channel

2011-03-25T20:57:00.001+01:00

The recommended method for compiling BennuGD games in your Wii is by using wiiload to both upload your code and to execute commands there.
If your Wii is not connected to your Wifi network (or you don't have one) things get a bit more complicated and previously I created a method for compiling that was a bit complicated. Today I'm going to show you a simpler one.

First of all, make sure that your Homebrew Channel is updated as this method requires one of the latest versions available.

Then, we'll create two entries in your Homebrew Channel: one for the game itself and another one for compiling.
The first one is created just normally, and the boot.elf file that you must put there is the normalbgdi.elf file, as found in the latest available BennuGD release and you'd just copy all the game's resources there, as usual. The meta.xml file for that entry would be something like:


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<app version="1">
    <name>Fancy Game Runtime</name>
    <coder>Your name</coder>
    <version>Version number</version>
    <release_date>Release date</release_date>
    <short_description>A short description.</short_description>
    <long_description>A longer, more detailed description of your game.</long_description>
</app>

Now, in the other entry (just another directory in the "APPS" folder of your SD card) you'd place your game's source code. The boot.elf file corresponding to that entry would be bgdc.elf from the release and the meta.xml file would go as follows:


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<app version="1">
    <name>Compile Fancy Game</name>
    <coder>Your name</coder>
    <version>Version number</version>
    <release_date>Release date</release_date>
    <short_description>A short description.</short_description>
    <long_description>A longer description for the entry that'll compile your code.</long_description>
   <arguments>
              <arg>boot.prg</arg>
              <arg>-o</arg>
              <arg>/apps/fancy_game/boot.dcb</arg>
     </arguments>
</app>

Where, obviously, "/apps/fancy_game" corresponds to the location in your SD card for your game's runtime (the first entry in this example). Also, "boot.prg" is the name of your main source code file.

If everything went fine, you can now insert your SD card in your Wii and you should now see two entries: one called "Fancy Game Runtime" and another one called "Compile Fancy Game". When you click on the compilation entry, your code will be compiled and the DCB file will be generated -assuming BennuGD liked your code- in the runtime entry, which you can click right away to test your code.

This process won't save your from having to grab the SD card from your console, copying the new files and putting it back in your Wii, but I'm sure it'll somehow make testing easier for you.

Hope you liked it!

PS: Remember you can win a Nintendo 3DS console just for coding by entering the Nintendomax Wii Dev Competition 2011! Good luck to everyone!

Nintendomax Wii Dev Competition 2011

2011-03-13T15:43:00.001+01:00

The guys at Nintendomax (most of the gameplay videos I post come from their site) have organised a new Wii Homebrew development contest and it's certainly looking interesting!

You can use any programming language you want to for the game, so why not use the best one around?. You might want to use the newly released rc1 version that include mod_chipmunk physics to create stunning games very easily. It feels great and has helped bring very cool games to the Wii ;)

Prizes:
They're giving out two Nintendo 3DS consoles, accessories, 150€ in cash and more. See the link below for details.

Rules:
Here are some of the rules for the competition, but be sure to read the whole thread linked below for more info.

- Everyone can participate, regardless of the country.

- All games or applications must be totally new for the Wii. This implies that no projects have been submitted shall be posted on another site before the competition closed, the projects involved in the Homebrew Bounty taking place at the same time are accepted.

- The project progress can be posted during the contest period (WIP, Previews, videos, etc.).

- A Splashscreen will be posted april 11, 2011 after a competition for designers organized by us.

- The splashscreen will be the first image to appear in the project and will be posted at least 5 seconds. Transitions and all types of effects are allowed.

- Participants may submit 1 or more projects.

- Ranking of the contest will be defined by a jury. No public vote is held.

- The classification criteria are multiple (originality, graphics, life, gameplay, personal notes, stability / bug, etc ...), a report will be posted after the vote.

- Competition results will be posted June 30, 2011.

- The Loader or applications that enable piracy of games is prohibited.

Read all about the contest here [en] or here [fr].

Hope to see your entries soon!

BennuGD for Wii RC1+ (mod_chipmunk integrated!)

2011-03-02T12:02:00.001+01:00

Today I'm refreshing the BennuGD for Wii binaries with a very nice addition: Chipmunk physics library integration. Just in case you missed earlier posts, mod_chipmunk is a wrapper for BennuGD created by Prg that allows you to unleash the full potential of the Chipmunk physics library with a BennuGD friendly syntax.
You can see some examples of what Chipmunk can do in this video:

The cool thing about this library is that creating a reallistic physics simulation is quite complicated even for those with a clear understanding of what's going on and this library manages all the physic interactions easily and effectively.
I've adapted one of the examples Prg includes in his package so that you can run it directly from the Homebrew Channel in your Wii.

Download Chipmunk physics demo

I'm asking if any of you can create a little video of this demo, so that I can embed it in this post. I cannot do it with a good quality myself so I'd thank it if anybody can help me with that.

You can get the refreshed BennuGD binaries with mod_chipmunk integrated here:

Download BennnuGD for Wii RC1 Refresh

Please, understand that physics simulation can be a very processor-intesive process. If your game slows down too much, try reducing the number of active processes.

BennuGD for Wii RC1!

2011-02-26T12:48:00.001+01:00

It's time to release RC1 of BennuGD for Wii.
You can seed a list of changes below:

The code is now much easir to mantain thanks to a slightly redesigned design (more on this to come) and is fully up to date with the upstream sources and overall, the port should feel much more stable.
Finally found the reason to why some FNT files weren't loading: seems like there's a bug in zlib for Wii that prevents it from working as documented (try to open file as gzipped, if that fails, try to open it as a raw data file). Somewhy it ends up reading from the file in incorrect places. To avoid that, always make sure your FNT files are gzipped. You can know that they're gzipped if you open them with your favourite uncompressor and they open correctly.
Small bugs fixed here and there.

I'm calling it RC1 as I consider it to be ready for public consumption, even there's a problem triggered with multiple Wiimotes that I must fix.

To sum up, here's a full list of things that you must know when porting your existing game to the Wii.

Make sure you've read the Getting Started page on the Google Code project site.
Make sure your FNT files are gzipped. They'll also take less space. To be on the safe side, also gzip you FPG and your MAP files.
OGG might work, but it's safer to use MP3. Also, recode the MP3 and WAV files @48KHz. You can use a program like Audacity to recode your music. Module tracker formats such as S3M, IT, XM... work just fine.
The builds don't include mod_debug. If you need it and cannot compile the code yourself, send me an email and I'll send you a copy of the runtime with mod_debug enabled.
If you need a more integrated experience, you can always use the bundled mod_wpad. That way you'll be able to query info about the controllers such as battery levels, accelerometer input, available controllers...
You can open websites on the user's Wii.
If something goes wrong and BennuGD crashes badly, you can send me a photo of the crash and that'll be helpful!

Get BennuGD for Wii RC1 from here.

So what now? For the next releases I'm planning on:

Trying to fix the joystick bug in SDL. Right now SDL seems to give wrong info about the number of present joysticks and when they were pressed.
Improving mod_wpad to support button state reading and include Wii MotionPlus support.
Integrating mod_chipmunk into the build for reallistic physics simulations.

Hope you liked the news! Have fun.

Puzsion for Wii RC1 [Updated with video]

2011-02-25T14:05:00.004+01:00

After finding the cause to the FNT load bug, today I'm pleased to finally release Puzsion RC1 for Wii.
I'm calling this RC1 because the game still needs some testing and might undergo some minor tweaking to further adapt it to the Wii but to my knowledge there are no bugs and it's perfectly playable.

Please let me know in the comments section if you find any issue with the game so that I can fix it.

Download Puzsion for Wii RC1

[Update] Cid2Mizard has created this video of the game in action:

Thanks for taking the time :) Also, I forgot to mention Hokuty and Amzg for their job in the game, all credit goes to them.

Hope you like it!

As to give you a small progress update, I'll upload a new binary version of BennuGD for Wii later today, which I'll be calling RC1.
Work on Firewhip for Wii/BennuGD in general is going great; together with the author I've squashed quite a few bugs related to the Fenix->BennuGD conversion and the game feels great in the Wii. Hopefully we'll be able to relesae it soon.

FNT loading seems to be fixed!

2011-02-23T00:47:00.001+01:00

With quite a bit of help help from my brother, I've just found what appears to be the cause of the failure in font loading in the Wii!

I will do more testing tomorrow, but if this is really working we've killed the last standing big bug in the BennuGD port for the Wii.
Expect a RC very soon :)

PS: @beredezebe And Puzsion is working great now!!! I'll just make sure the musics are encoded at the right freq and release it in the next few days.

Firewhip

2011-02-21T12:00:00.003+01:00

I just took this photo of Firewhip running in my Wii.

To my knowledge, it's the first time this very cool game is being run in a Wii. There's still a lot of integration work to do (controls, mostly) and bugs to fix.

I just thought it'd be cool to show that the game seems to be running well with the cleanup I just finished doing to the new architecture (more on that to come, but to sum up I changed a bit the way the whole monolithic system works to make it even easier to mantain and updated the code to match the latest upstream version of BennuGD).

[Updated] This game's just so cool! I've adapted the controls for the Wii in a matter of minutes and spent a few minutes playing it... Things look nice!

Vigoroth le livreur

2011-02-13T02:12:00.004+01:00

Beredezebe lets me know that user blabla (cool nick!) has posted a note in the French BennuGD forum about a game he's ported from microlua to BennuGD. It's called "Vigoroth le livreur" (Vigoroth the delivery man, if I'm not mistaken) and you can read all about the game here [fr].

My french is not as good as it used to be, but from what I can understand, this is a collection of 4 mini-games where you must help Vigoroth with his deliveries.

As I'm still busy with my university exams, I haven't been able to test it just yet but I promise I'll write a post about the game after I've played it.

Meanwhile, you can get it from here, and you can see some screenshots for the game below:

I'd like to congratulate blablabla for his game and thank beredezebe for letting me know AND for packaging the game for the Wii.

Also, as I said in the last post, the project is far from dead and right after I finish my exams I'm planning on doing a few nice improvements to the port. Right now I'm using the little free time I have to clean up the monolithic design I created so that it's much easier to mantain. I'll try to write more on that later.

Also, forum user Prg has created a physics module (wrapping around the Chipmunk physics library) which seems pretty cool. I'll try to bring that to the Wii, too.

You can have a look at what Chipmunk can do in the video below:

Happy coding!

PS: Sorry for the off-topic, but IMHO it's important.

Just using the screenshots I've posted above might be considered a copyright infringement and might be used as a reason to close this blog without any judiciary intervention once the new Sinde law [en] is passed in the Spanish Congress (even if the Congress rejected it last december, the two major parties have brought it back to life). They say it's a way to fight "piracy" but it could just as well be used for censorship. This is not good. If you live in Spain, you might consider not voting for PSOE, PP, CiU or any other party that supports censorship in the upcoming election.

[Update] And the law just got passed today. As I said, if you can vote in Spain, don't vote for them [es].

Tutorial in french

2011-01-31T09:50:00.000+01:00

Just writing to note that work will resume after I finish my exams (I plan to work on fixing FNT loading, improving input handling and Wiimotion Plus support).

Anyway, if you are new to the project and speak french, you might want to check out beredezebe's tutorial about working with BennuGD in the Wii here.

Beta 3 released

2011-01-04T22:30:00.001+01:00

I've uploaded some binaries I like to call beta 3. Chnages from previous beta include:

Proper support for the Wii Balance Board (see here for a usage example). Thanks to the guys from devkitpro for fixing this in the latest libogc 1.8.6
Default sound frequency has been changed from 32KHz to 48KHz. Had to do it because newer versions of VLC refused to resample the audio to 32KHz. Also many popular audio programs seem to handle 48KHz sound much better than 32KHz ones. Please note that as OGG Vorbis sound playback was failing, you are now encouraged to use MP3 and module music formats instead.
Updates from upstream Bennu. I've re-sync'ed many things from upstream BennuGD. Please note that this build corresponds to revision 146 from SVN, and not the current one (190). The changes between this versions derive from the SDL 1.3 support I added to trunk to gain iOS compatibility and I most probably broke something so latest code is not working as expected. I'll fix this soon.
Bennu can now open websites if the user has installed the (free) Internet channel.
Some other misc bugfixing.

Hope you enjoy the changes and the proper balance board support and sorry for changing the default sound freq. it was just needed.

You can find the binaries here.

Firewhip coming to a Wii near you, plans & where have I been?

2010-12-28T03:34:00.004+01:00

Sorry for not posting in such a long time. I haven't directly coded on the Wii source for a bit of time, but I did take the Wii code and add SDL1.3 support to it, so now we have a (mostly) working iPhone port for BennuGD! Turns out that making BennuGD support SDL1.3 also fixes an annoying bug we had in MacOSX where 32bit color wasn't working at all. So you see, things fix all on their own with SDL1.3 :). The code is now in trunk.
If you have a look at the code, you'll see I've created many Makefile's, one for each supported platform. Things only get worse as now most platforms support two different/incompatible SDL versions.
I shall fix that* by dumping that system and creating a build system, probably based on CMake.

Also, a week ago or so, the nice guys from DevkitPro (the SDK I use to build BennuGD on the Wii) have released libogc 1.8.6. In their release notes, they say they've fixed something related to wrong readings in Balance Boards. Bennu was getting wrong readings from Balance Boards, so hopefully when I recompile BennuGD for the Wii with the new libogc, you'll be able to use the Balance Board correctly :)

Also, just a couple minutes ago I found out about a very cool game called "Firewhip". Have a look at the video, as it is a realy cool one:

As it turns out, this game had a pretty serious bug that had been triggered when it was converted from Fenix to BennuGD (some change in behaviour about process creation or something like that) that was pretty easy to fix once triggered, so stay tuned as this cool game is coming soon to a Wii near you!

Starting the Opera browser in your Wii from your BennuGD games

2010-11-27T20:37:00.001+01:00

The Internet Channel is a Nintendo-sanctioned port of the popular Opera browser that has been free to download for your Wii for quite some time.
With the latest builds of Bennu for the Wii, you can now launch any webpage you want from your code. To do so, just add the following line in the appropriate place:

exec(_P_NOWAIT, URL, 0, 0);

And the Internet Channel will open URL. Just remember that your game will quit right after that call and do as needed for a clean shutdown (saving gamestate, unloading resources...).

Pixbros preview release!

2010-11-16T00:33:00.002+01:00

It has been quite a while since I told you I was working with Pix Juegos' Pixel to bring you a preview release of Pix Bros for Wii, but it's already arrived for your gaming pleasure!

As I said earlier today, it's still a preview so be sure to understand that what we're releasing today is only a preview of the game: when the final version is released, bugs will get fixed and the game will look much prettier. It is, however, a very playable version of the game: It's running at 32bpp, with MP3 music and it will even open the designer's group website when asked to! (more on this on a later post. If you want to give it a try, give an eye to the game's code).

Today's preview does have a few limitations, though. Fonts are not working as one might expect them to, so we've released a version of the game that uses the default system font. That font is basically available for debugging purposes, so it is barely visible and looks plain wrong.
This game also showed some issues with the joystick handling routines which might be caused by the SDL port. To avoid them, only one player can play at any given time, sorry for that.
On a final note, the game seems to slow down a bit at certain points. This is caused by it running at 32bpp: looks like we hit the Wii's limit when processing graphics without its GPU. In case we can't solve this, we might have to release the final version with 16bpp mode set by default.

On the bright side of life, you'll enjoy the latest and greatest version of Pix Juegos' game, which has gone through major improvement since its last release. I can promise you the game is really, really entertaining. I've been waiting for it on the Wii for a long time :)

For the rest, the game is completely playable. I haven't finished the game (those Rarutos keep killing me...) but it seem pretty rock-solid. It's really encouraging to see that :)

Both Pix Juegos and me wish you an absurd level of fun, but remember this is only a preview and things might be broken. If that's the case, please let us know so that we can fix them.

The screen grab below shows the state of an early build of the game (it's really the same one as shown earlier).

Get the game from here.

WIP sign for your games

2010-11-15T13:20:00.000+01:00

When we released the EEEEK! EEEEEK! HOOOOOOK!!! preview, many people liked it and took it for what it was with bugs and all.
Many people downloaded it and found it playable to the point that some user uploaded the preview to the Homebrew Browser, the author of the game grew concerned that many people would play a pre-release version of the game that contained known bugs and featured no notification on that regard.

The final version of the game for the Wii was released a few days later with many enhancements and all the known bugs fixed, but we were left with the doubt of whether many people wouldn't upgrade from the pre-released version just because they thought it represented the overall quality of the game.

That's why, for the launch of a Pix Bros preview (coming later today) I've created a pretty straightforward sign, which can be seen below:

And here's the original SVG image. It probably won't display correctly in your browser, it works just fine with Inkscape. Feel free to add it to your projects (even if they're not Wii-related) and treat the image as public domain.

For example, here's what Pixel you'll see in Pix Bros when you download the preview:

Enough, will be back with some real news (Pix Bros pre-release, a code status update and I'll tell you how to open web addresses from your games directly in your Wii!) later today.

On yesterday's post

2010-10-28T22:02:00.001+02:00

Yesterday, I posted an entry with a photo of Pixbros working in a Wii with the latest SVN build.
There are a few bugs to fix yet, but there are some things that it's worth noting:

The game is working pretty well in 32bpp mode.
scale_resolution seems to not work at all in the Wii, don't try to use it yet :)
In the photo, you can see there are two characters playing. This is, in fact, a bug as there was only one controller present. Libjoy was reporting incorrect values for joysticks that weren't present. I've uploaded some changes to the SVN repo and this issue seems to be fixed.
You might notice that the score counter is blank. There seems to be some problem with FNT loading or displaying. I'll have a look at it as soon as possible.
The game is using music in MP3, as recommended, and those are encoded @48KHz, which is the new default frequency for BennuGD games in the Wii, starting with the next beta release.

If you really, really, want to give it a try, you can compile the latest BennuGD for the Wii from the SVN repo yourself and then compile pixbros from their SVN repo, otherwise you can just wait a little bit; it shouldn't take us long to have everything ready for release!

This game is pretty big and uses many features from BennuGD, so I'm pretty excited to see it's working that well with very little effort on the game author's side. So thanks him a lot for taking the time to make the game Wii compatible.

PS: The game is so cool that it's even been featured in Spain's public TV (Pixbros appears @ 1:21)

PS2: As the cow points ot, there are now more than 20000 users of BennuGD for the Wii. Future game release will only make that number bigger and bigger, so big thanks to everybody!

Pixbros

2010-10-27T15:59:00.002+02:00

I asked for it long ago and, well...

Have fun!

PS: It's not ready yet, but it's definitely working quite well. It'll arrive soon!

Early bennugd-monolithic builds running on a PSP

2010-10-25T16:29:00.001+02:00

I'm going slightly off-topic with this one, but as you might know, the same source code used for creating the Wii version of BennuGD is being used by Daniel Franzini to create a PSP port.
He's shared a video of an early BennuGD build running on his PSP, which you can see below.

Go, Daniel, go!

Experiencing random crashes? Use MP3!

2010-10-25T13:21:00.000+02:00

After some debugging -using the info I mentioned the other day- some game that used to crash "randomly", I've found that all the crashes I could reproduce were related to Tremor (the library used to play OGG files) and in particular to oggpack_readinit. I believe this problem arises more on games with multiple sound sources playing at once, and doesn't seem to appear in simpler games with only one or two sound channels.
This error might well be related to this other bug or even this other one.

I'm not really sure I'll be able to fix this anytime soon, but I've made some simple tests with MP3 playback and they seem to work much better; the interpreter doesn't seem to crash anymore and I believe that both bugs mentioned above might also go away. If this is true, I'll update the transcode_music scripts so that they recode&resample your music to MP3 by default.

Just one note: You will only be able to play what smpeg can: MPEG-1 - Layer III sound files (the simplest/oldest kind of MP3 available), but hopefully the transcoding script will do all the hard work converting your files so that you don't have to.

Hope this solves stability problems, in case you found'em.

Happy coding! :)

Send me photos of your crashes so I can fix them!

2010-10-24T12:48:00.002+02:00

I just found this article on the wiibrew site. It explains how to debug that ugly -but useful- crash messages the PPC CPU inside your Wii dumps when bgdi crashes.
I don't own a USB Gekko device (which is the preferred debugging method) but it should help during debugging nonetheless. Thanks, devkitpro guys!

So, if you find your Wii crashes when running BennuGD games, please send me a photo of the screen where I can read the text, and possibly the source code for your game and a little explanation or what your code was doing when it crashed.

This will help create more stable builds and might eventually help BennuGD upstream, too. So thanks for your help!

Brewing your own builds

2010-10-21T00:34:00.000+02:00

A couple of days ago I uploaded the SDK I'm using to compile the bennugd-monolithic code.

In order to install the SDK, follow the instructions to install devkitpro from here.
Download the latest copy of my DevkitPPC directory available here -it can be used in win32, linux or OS X- and uncompress it to (following the example in the Getting Started page) /opt/devkitpro/ so that there you'll have threee folders: devklitPPC, libogc & portlibs.
Now, set the DEVKITPRO & DEVKITPPC environment vars as described in the Devkitpro "Getting Started" page.
Get the latest bennugd-monolithic code as described here.
Last, in your favorite console, and from the bennugd-monolithic-read-only/core directory type make. That's it! After that, your binaries will be in core/bgdc/bgdc.elf & core/bgdi/bgdi.elf.
Should you want to create a monolithic build for Linux (which should work just as fine as the normal BennuGD build, as you won't experience any endianess issues), type make linux instead of make.

Hope you find this info useful, I'll use this same info in the Wiki page.

On the lack of updates

2010-10-09T13:30:00.001+02:00

Sorry for the lack of updates lately, I've had a lot to do in my university (again) and couldn't work much on this. I did get to touch the code a bit, with mixed results:

I will probably change the default sound frequency from the current 33KHz to 48KHz. I've done this primarily because recent versions of VLC refuse to transcode the audio files to 33KHz but are happy with 48KHz. Also, many audio programs can use 48KHz just fine. For example, if you use my FMOD Ex bindings (they include spectrum analysis support for both the available mics and for the playing songs!) for BennuGD in your normal computer, you can use the same audio files in your computer and the Wii; you might have to code a couple of ifdef's to handle the API differences, though.
Sorry for that, I expect not to have to touch the audio frequency again.
I've found out that set_volume doesn't work as expected, if you use it you'll just hear a very nasty noise... Will have to have a look at it.
There have been some pretty important changes in the most basic libs used by the Wii version of the port... I'm trying to update SDL and libogc in order to get things working again.
I've been integrating some changes to the code that Daniel (the guy working on getting this working on the PSP) passed me, and we've been trying to set up my development environment to be able to code for the PSP, in case I can help him at all.
I mostly completed the port for Puzsion. I contacted the author and they're happy to replace some graphics for some more... Wii-specific. This is on top of the to-do list.

So you see: not much coding, but still a little bit of progress.

PS: As for the PSP SDK, we're using this one.
PS2: I would really LOVE to integrate my VLC module into this Wii port, and now that VLC has been released for the iOS (which doesn't allow dynamic linking, either) that seems to be possible. If anyone can help me with getting the iOS libVLC.a to compile for the Wii, I'd be REALLY grateful.

Pixdash

2010-08-30T00:26:00.000+02:00

The guys from Pixjuegos have released a BennuGD tech demo for a platform game. It's still in a very early phase of development and I really hope that the graphics are not final but most of the gameplay is there and working well.

The interesting part is that all their code is open source and can be retrieved from their project page, so you can use it as an starting point to create your own platform games or as an entry point for BennuGD programming.

In case you want to have a look, a Cid2Mizard from Nintendomax has been kind enough to upload a video of the gameplay and upload it to Youtube:

Thanks, Pixjuegos! But you know that's not the game I'm expecting from you ;)

More than 12000 users!

2010-08-26T13:17:00.001+02:00

According to these stats more than 12000 people have, as of this writing, downloaded a copy of any of the games that are available for Wii through the Homebrew Browser!

Most of them have downloaded the impressive "King of Fighters: Flames of Courage" game and as more great BennuGD games get packaged for the Wii that figure should just keep increasing.

I shall soon package and upload Puzsion, you can see it running on my Wii below:

I'm also eager to get Pixjuegos' excellent PixPang and Pixbros running on the Wii again, I really enjoy playing them. The author is busy porting his game to the Caanoo right now, but he's promised he'll get the games running on the Wii ASAP.

Impressive KOF v5f video and Wii version download link!

2010-08-23T16:00:00.005+02:00

If you like this video of "King of Fighters: Flames of Courage v5f", a game for Wii made with BennuGD (of course)...

...you can get the full Wii version from here.

Project webpage here.

PS: This version fixes a couple of bugs from the previous 5e version, which was also available for the Wii, full source code is available.

EEEEK! EEEEEK! HOOOOOOK!!! version 1.2 released for Wii!

2010-08-16T17:27:00.001+02:00

I've just committed the last changes to EEEEK! EEEEEK! HOOOOOOK!!! and I've finished uploading it.
We're calling this version 1.2 and includes quite a few changes from what you could see in the preview version. Most of them are small bug fixes, but there are a few graphical changes that are important for the game consistency too (Wii specific controls in the tutorial, for example).

You should also expect a minor update soon which should bring a few extra features such as warning the user when the batteries of the Wiimote are about to drain.

You can get the game from here, and it should be soon in the Homebrew Browser, too.

EEEEK! EEEEEK! HOOOOOOK!!! preview video

2010-08-12T12:51:00.000+02:00

An anonymous reader has uploaded a video showing the eek preview I uploaded the other day running on his Wii. Thanks a lot for your support!. Here it is:

I'll soon upload a final version of the game to the proper channels with some minor changes made by the original author, including changes to the initial tutorial so it doesn't show a mouse cursor, but a Wiimote.

Preview of EEEEK! EEEEEK! HOOOOOOK!!! released for Wii

2010-08-11T00:43:00.006+02:00

[EDIT] This is old, get the final release from here.

I've just uploaded a preview release of EEEEK! EEEEEK! HOOOOOOK!!! for the Wii to megaupload. I haven't yet uploaded it to more proper channels as there are still some annoying bugs to iron out; nothing critical, but the lasers seem to be a little bit out of control. For the rest, I believe it works pretty well.

I've modified the code a bit to detect clicking even when the Wiimote is not pointing at the screen and a remapped a few Wiimote buttons to their respective functions. Which reminds me that I should create a version of jkeys.lib specifically for the Wii :)

You can get your copy from ~~here~~, and as soon as it's ready, I'll upload it to the Homebrew Channel and to the BennuGD projects page.

PS: If anyone can upload a short video/photos of the game running on his Wii, I'd be really grateful as I don't currently have the means to record the videos myself. Please post them in the comments section and I'll post them :)

Comments on Beta 2 and a refresh to the second beta.

2010-08-11T00:31:00.001+02:00

As a first note, I'd like to comment that I've uploaded a beta 2 refresh. This is to solve a very small yet annoying bug I had missed: OS_WII was not being defined (ups!). It also includes small updates to libjoy and mod_joy coming from upstream.

As for the changes included in beta 2 with regard to beta 1, I'll highlight a few:

Exported mod_wm symbols. These where being compiled, but I forgot to export them, so they were unusable.
I also touched get_desktop_size() to return the size of the mode SDL has set. I wanted to have this return the Wii's native resolution for you, but this seems to not be easy as of now, so at least you've got a mode you can set_mode() to.
I also changed the dependency map so mod_mouse and mod_wpad both now depend on libjoy. This is to ensure correct hardware initialization and to improve compatibility with newer versions of the Homebrew Channel.
Speaking of mod_wpad, I improved it a bit. Now you can check if a particular controller has a Guitar Hero 3 guitar or a Classic Controller attached to it with:

WPAD_INFO(int channel, WPAD_HAS_GUITAR);
WPAD_INFO(int channel, WPAD_HAS_CLASSIC);

A few corresponding functions has been added to query those devices:

WPAD_INFO_CLASSIC(int channel, int info);
WPAD_INFO_GUITAR(int channel, int info);

info can (as of now) only retrieve the battery level from those, with the value:

WPAD_BATT

mod_wpad can now also report the acceleration, as read from the Nunchuk. Please remind that the Nunchuk can only read acceleration in one axis, the rest will be 0. To get those readings, use:

WPAD_INFO_NUNCHUK(int channel, int ACCELX);
WPAD_INFO_NUNCHUK(int channel, int ACCELY); and
WPAD_INFO_NUNCHUK(int channel, int ACCELZ);

We can now also read the orientation of the Wiimote (in thousandths of a degree, I must double check this is coherent with Bennu's way of doing things). This works with WPAD_INFO_NUNCHUK() too but again, the results will only be valid on certain axes. Here are the new functions:

WPAD_INFO(int channel, int WPAD_GX);
WPAD_INFO(int channel, int WPAD_GY); and
WPAD_INFO(int channel, int WPAD_GZ);

I believe that's pretty much it for the changes. Bugs have been solved, and some initial work has been done on integrating more unofficial modules, namely mod_image, mod_iconv and mod_sqlite3. But that's incomplete and has not been compiled into this release.

For a real example on how to use the new mod_wpad functionality, check this examples code.

Also, mod_debug has been left out in this release just because it makes the binaries bigger and I believe it'd be a pain to try to use it in a real Wii. If you need those, please let me know and I'll send you a copy of the binaries with mod_debug integrated.

I believe that's pretty much it, as always, you can get the binaries for the beta from the google code page.

Beta 2 released!

2010-08-06T02:46:00.002+02:00

I've just uploaded Beta 2 of the BennuGD for Wii interpreter.

More details&test version using libELM to come soon, please note there's a known endianess bug when using short data types (like BYTE others possibly affected too) in local variables. For the moment, please replace them with INT and things should work fine.

PS: I'll also upload EEEEK! EEEEEK! HOOOOOOK!!! & Puzsion for Wii soon :)

The monkey is coming...

2010-08-04T15:50:00.000+02:00

Yesterday I worked a bit on this and I finally got to understand what was going on with the bug I blogged about. More detail will come, but you might like to know that it's now fixed.

I also found the bug that prevented eek from working correctly, so you'll be able to have some Wii-monkey fun soon.

Please, expect beta 2 to arrive later this week. More details to come.

I broke something....

2010-08-04T02:43:00.000+02:00

I seem to have broken something (possibly related to the new libglob I'm using) and newer builds don't work as they should on the Wii. I'll try to fix this asap but it might take a bit of time... sorry!

Beta 1 released!!

2010-07-14T12:39:00.001+02:00

I've just uploaded the first binary beta to the new project page.
I'm in a bit of a hurry, so I'll write about it later, but it basically has all the official modules in BennuGD, and the wpad library (used to handle Wiimote input, it was inside the previous builds) has been extended to support Nunchuk input and gravity detection for both your Wiimote and your Nunchuk (i.e: how your controllers are oriented in the real world). Readings are only valid on some axis, but that's a limitation of the controllers' hardware, not a bug.

More wpad support should follow, as to be able to handle more controllers, like: Classic, Wii MotionPlus, Guitar Hero....

There are a few bugs here and there, but nothing is critical and the port is working pretty well :)

Rearchitecturing the port for the future

2010-07-12T21:05:00.000+02:00

The day for the big news has arrived!

Today I've finally completed integrating all the modules inside the new architecture. This new architecture has a lot of advantages over the previous one, to name a few:

The code is much easier to mantain now (it involves many less modifications to the original BennuGD source).
The interpreter (bgdi) can now be compiled without the modules you don't need, so it can be a lot smaller.
Up to where the endianess issues in BennuGD allow us, the DCBs generated with this new version are completely compatible with the official standard version.
This new version includes all the modules from the official Bennu version (minus mod_crypt).
Modules only get loaded when you import them (they were always loaded, which meant more unused RAM in a system without resources to waste).
Me messing around less with the code means a much more stable version.
This new architecture is much more friendly to others creating monolithic ports for other platforms.

And here is where I wanted to arrive; in some quick tests, this new version is extremely more stable: it fixes random crashes and misbehaviours of the previous versions whose origin I couldn't trace. Please understand that this new version has been completely rewritten in under a week -so there are still some bugs- but when bugs get fixed, this new version should be as solid as upstream BennuGD.

I'll comment on some particular examples; take a look at the screenshot below:

EEEEK! EEEEEK! HOOOOOOK!!! by Gabriel Garrote

In the latest build with the old architecture, the left eye appeared in the upper-left corner of the screen, for no particular reason. This works now just fine, as you can see from the screenshot above.

I'll probably "test" Pixbros later (and for "test", I mean play). Pixbros used to crash after a certain amount of playing time. I'm pretty confident it'll work just great now.

As for another example, Puzsion used to crash horribly when loading, so it was completely unplayable. As you can see from the screenshot below, it's now working perfectly.

Worked great until my Wiimote ran out of battery :'(

Also, speaking of better mantainability: I've been working with Daniel Franzini and we're now hosting a common code repository for both the Wii port and the PSP port (the new architecture is awesome :).

You can find the new code here, and this new repository superseeds the older one.

There are no released binaries yet because mod_wpad has not yet been integrated, but I'll probably dump the old code and start using Grisendo's mod_wpad, which is much more complete.

Anyway, don't take my word, as soon as I upload the new binaries, download & start using them, you'll see how much better they work compared to the previous version.

Hope you find the news interesting :)

Have fun!

Soon

2010-07-10T22:40:00.000+02:00

A very big update on the code front should arrive very soon (around next week) so stay tuned... :)

23/45

Wii menu update

2010-06-23T13:14:00.000+02:00

It seems like Nintendo has issued a system menu update (version 4.3) which -in their own words- doesn't update pretty much anything but deletes the Homebrew Channel (and thus will make using bennugd-wii much harder).

It still seems to be possible to install the Homebrew Channel back but, if you can, don't upgrade to the latest menu version

PS: Some important updates on the project will come in the following weeks.

Progress

2010-04-28T14:44:00.000+02:00

Even if I've not written about it lately, there's been some very interesting progress lately.
I released alpha 5 of Bennu, which includes and improved version of mod_wpad. This new version allows you to query your Wiimote for the raw accelerometer data, make it vibrate...
A few days later, my brother found the cause of the bug that was triggered when using save and load. I released alpha5~1 which solved it and integrated mod_iconv (a wrapper around iconv I created some time ago).

For alpha 6, I'm working on making module loading dependant on your code. Right now, all the bits from all the supported modules are loaded when you fire the interpreter.
This is suboptimal as you may end up initializing things you won't be using later; and memory is an important concern in this particular platform. So, from alpha 6 on, if you want to use the functions in -say- mod_wpad, you'll have to import it.
This'll make the code more compatible with upstream Bennu, and less cluttered.
Also, mod_wpad will be expanded to allow reading the data from the Nunchuk'saccelerometers and a way to find the appropriate resolution for each Wii.

Now, some people have been working with the latest alphas in the BennuGD forums, and they've shown the things is quite usable, already.
Have a look at this video by BomberLink that shows an arcade game he's currently working on where he's using accelerometers to control the main character.

Also, Me Matsusaka has ported his KOF Flames of Courage v5 (a King of Fighters clone) to the Wii. You can get it here:
http://www.megaupload.com/?d=ZZKFY5VL

I have not tried it myself, but hope to do it this evening :)

The first game

2010-04-20T20:55:00.000+02:00

Carles V. Ginés has released the first BennuGD game for the Wii, called Garnatron
It's a very small one and leaves a lot of room for improvement, but it's fun to play :)
You can see a video of Garnatro in action in the link above.

Also, Pixel has added Wii as a platform for your games to the BennuGD projects uploading form, so now you can just add your BennuGD Wii games to the list :)

PS: Don't tell anybody, but full WPAD support (rumble support, accelerometer data reading, angle checking....) is done and should come as a binary soonish.

Alpha 4 released

2010-04-16T22:21:00.002+02:00

Today, I'm releasing alpha 4.
This version changes the way mod_say works: until now, it'd just do a printf(). This caused artifacts onscreen. From now on, mod_say will output text to a file named "stdout.txt"
Also, this version includes a new module: mod_wpad. This Wii-specific module tries to provide much more info about the controller input than what the normal Bennu version would.
This is a very preliminary set of functions, and seems to not be working perfectly right now:

WPAD_IS_READY(int channel). Will return 1 if channel channel is available and started. Otherwise, it'll return <0.
WPAD_IS_BALANCEBOARD(int channel). Will return 1 if channel channel corresponds to a Wii Balance Board.
WPAD_QUERY_BALANCEBOARD(int channel, int data). Will query info from a balanceboard. Data can be:

0: X position of the center of gravity.
1: Y position of the center of gravity.
2: Weight measured on the TOP-LEFT base.
3: Weight in TOP-RIGHT.
4: Weight in BOTTOM-LEFT.
5: Weight in BOTTOM-RIGHT.

WPAD_BATTERY_LEVEL(int channel). Will return the battery level for a particular channel. 0<level<256.

Other functions will come, and you'll be able to get info on Wiimote acceleration, and other data. Also, as I said, the function names or return values are not done yet. It's a beginning, though.

Alpha 3

2010-04-08T22:31:00.000+02:00

Today I released alpha 3 for BennuGD-Wii (can be found at the google code project page).
Alpha 2 brought some upstream fixes to the BennuGD core (including Splinter's own fix for the endianess issue, which is believed to be solved both upstream and here).
Alpha 3 brings just a quick fix to the wrong ALPHA_STEPS behaviour present in previous builds. Now FADE's should work fine.

Endianess, color and mod_effects; let's call it the alpha 1 release

2010-04-07T00:09:00.001+02:00

Yesterday, my brother found the solution to the endianess bug (that resulted in Bennu displaying the wrong colors) that you can see in the video I posted a couple of days ago. So, big thanks to him!
I also integrated mod_effects and now te vast majority of modules that apply and are needed for creating 2D games have been integrated.
There are many things that don't yet work as expected -the most notorious of which is sound, that always plays @ 30KHz, no matter what your music files want-

However, I'd like to call this alpha version 1 of BennuGD for the Wii. It's now very buggy but usable, and you're more than welcome to test it and start creating your BennuGD games targetting the Wii.
If you get'em to work fine with this version, fear not, they'll work in the final version. Should you find any bugs, please report them in the project bugtrack.

So, go get the alpha 1 release at the google code project page.

Pixbros working on the Wii

2010-04-05T00:36:00.000+02:00

A shortish video that shows how the port is doing. You can see Pixjuegos' Pixbros working on the Wii. As you can see in the video, some colors are now showing well (I did some digging and some things got fixed) but I must work on others.

Judge for yourself:

One short entry more today

2010-04-02T02:52:00.000+02:00

mod_blendop is in.

The future

2010-04-02T00:13:00.000+02:00

After yesterday's post with some screenshots of different existing games running fine in the static version of Bennu, I wanted to share some thoughts/questions about the future of the port and the work that needs to be done.

First of all; soon after posting the message, I fixed the scrolls. This was particularly easy. Most of the times a module acts weird it's because I screwed something in core/includes/offsets.h. I just opened that file and changed [83+16=] 98 for [83+16=] 99. Problem solved :)
My brother sent some code that adds some support for bigendian systems. Will have to test it on a real Wii.
If you think about the Wii controls, I can think of at least 5 different ways of controlling your game in a Wii, depending on how many accessories you plug in your Wiimote and how you grab your Wiimote.
I will have to write some helper code to make control handling easier for bennu newbies.
There are a few modules I'd like to create specifically for the Wii that add support for some very interesting Wii features. These include:

Reading Mii info. It'd be based on Matthew Bauer's libmii.
Reading Wiimote's and Nunchuk's accelerometer output.
Reading output from things like the Wii balance board. According to wikipedia, it creates a virtual device by emulating two joysticks.
I'd like to find out how easy/difficult it is to play sounds in Wiimote's integrated speaker.
Others? Stub implementation should also exist for your pc, to make game creation/debugging easier.

I'd like to integrate some video functionality into the port. Currently Bennu natively supports some prehistoric video format, but that's really not enough. I have created a video module based on VLC that works great on both Linux and win32, but I don't think porting that would be easy.
I might go for mpeg support. We've got a couple of mpeg implementations that might fit in here perfectly.
I'd like to make the port's code cleaner and bring it closer to the upstream BennuGD code. Ideally this would mean that given the right compilation script, my code could generate both the upstream modular BennuGD release and the Wii-specific monolithic Bennu version. This would make it easier to keep sync with future upstream changes.

I think that's pretty much it :)

libkey, mod_key & a few shots

2010-03-31T23:52:00.009+02:00

I've integrated the keyboard handling functions. I've not tested them on a real Wii yet, but the same code in my Linux box seems to be working fine.

As I wrote earlier today, I wanted to share some screenshots of actual games with you.
The first one comes from a fighting game called "Fostiator" (don't ask) which is a very old fighting game that came as an example for the program that inspired Fenix and then Bennu:

The code is the same one you'll be using in your Wii and should work just like it, with the sole exception of the endianess bug that'd make colours look pretty broken right now.

The following screenshot comes from a game called "EEEEK! EEEEEK! HOOOOOOK!!!" by Gabriel Garrote and won the first BennuGD/GPH game programming contest. I had to patch this one a little bit so that it wouldn't use some functions found in mod_wm, but the rest of the code is untouched.

The main motivation behind testing this code is to be able to play some cool games in my computer. The "other" motivation is to test the scroll functions.... Well, here's the result:

As you can imagine, the scroll is pretty much broken right now. There's a lot of working code there, however! :)

I will let you know when I fix the libscroll code, in the meantime, you might like to play Gabriel Garrote's EEEEK! EEEEEK! HOOOOOOK!!!.

Seriously, it's a great game (that you'll soon be playing in your Wii :).

PS: One more

mod_scroll, OS_WII and a small coming surprise

2010-03-31T17:57:00.000+02:00

Just wanted to let you know that I've integrated mod_scroll, so now scrolls should be working.

Instead of writing some test code that would leave most people wondering if I'll ever get to a point where this thing become usable, I've decided to recompile a very old fighting game (directly ported from DIV Games Studio code).

It won't yet work in your Wii for two main reasons:

The endianess bug (that's being worked on).
It needs mod_key (I should integrate this sooner than later).

mod_key should be very easy to integrate, so I'll soon post some screenshots of how the game will look once the endianess bug is solved.

I've also talked to Splinter (the main BennuGD developer) and we've agreed to use OS_ID values over 1000 for unofficial ports, so now OS_WII=1000 (up until now, OS_WII was 9).

signal working now?

2010-03-31T02:02:00.000+02:00

After a few hours of reading and re-reading Bennu code and even reimplementing mod_proc, I think I finally fixed the regression in mod_proc that caused signal not to work.

This was a stupid bug. It was caused by me not knowing well enough how C works. Should I have read and understood how enums work in C, I wouldn't have redefined some internal value that told Bennu to kill a process when told so (I was instead messing with some other internal var).

Well, I just wanted to let you know that I think I fixed it.

mod_draw, mod_screen, mod_path & a few small fixes

2010-03-28T13:54:00.001+02:00

The other day I integrated libdraw. That same afternoon I integrated mod_draw, so that's done and you can now paint those beautiful Bezier curves in your Wii.

Also, yesterday I integrated mod_screen (regions, backgrounds...) & mod_path (path finding module). I added some test code for mod_screen and it seems to be working fine. I will have to write some code for mod_path too, just to be sure.

I also uploaded a wiki page in the google code page to keeo track of the modules that are already implemented and the modules that need to be integrated (or won't get implemented at all, like mod_wm).
You can compare how big both columns are here.

Again, if you want to start porting your games to the Wii, please let me know.

PS: Endianess bug is still there, and even if I fixed some minor bug with mod_grproc, some process will refuse to die.

libdraw is in

2010-03-23T09:46:00.000+01:00

Just a fast update to let you know that libdraw is in. Libdraw is the low level stuff used inside the mod_draw module for drawing primitives (simple geometric elements such as lines, rectangles, circles...). This one was particularly easy, so you should get primitive drawing today or so.

Also, it looks like signal is not working as well as it should for processes with a GRAPH assigned to them (processes without GRAPHs seem to get killed as they should). I'm also trying to find a solution for the endianess issue in the blitting functions that pretty much ruins all the experience with Bennu in the Wii.

Collision, signal fixed!

2010-03-09T19:09:00.000+01:00

Ok, I finally fixed the signal and collision bugs. At some point during the integration of mod_proc & mod_grproc, I had broken a few things. What I'm not really sure of is why signal was working before...

Both 09_mod_proc.prg and 20_mod_grproc.prg work now as expected.

Wow! I did a few things in under an hour of coding today! :)

PS: BTW, this thing is starting to look usable (if you don't take colours being broken into the account) so if you want to start porting your games to the Wii and help test the port, please get in touch with me.

mod_regex

2010-03-09T18:08:00.001+01:00

I owed this one to you since New Year's day. Test code seems to be working fine.
I'll try to work a bit with mod_grproc to see if I can fix it. Using collision results in core dumps right now.

Happy coding!

PS: Advance seems to be working fine, it's not the whole mod_grproc that's broken :)

A few videos of Bennugd-wii in action

2010-03-03T17:49:00.001+01:00

Below are a couple of videos I've created with my phone (sorry for the blurriness).
The first one runs this code & shows the cursor moving after applying a graph I loaded from a PNG image. The video has no audio, but there's some music in the background, too.
If you look closely you might be able to see that the colors in the mouse cursor are wrong, that's a result of some endianess issues I must solve.

The second video shows some text being written in the Bennu standard font (although others should work, too) and in red colour. When you press the right mouse button (button B in your wiimote) the text moves to a random position.
This one also plays some music. You can find the code here.

I have removed the console initialization code because it caused artifacts, as SDL is the one that initializes all the graphics stuff now.

So, when I solve the signal&endianess bugs and integrate just one more module (mod_grproc) most of the 2D games created with Bennu should start to be playable!

libtext & mod_text in

2010-02-25T20:43:00.000+01:00

I've integrated libtext and mod_text. This means that you can now use write, write_var and similar functions.
The test code sets the text color to red, and moves it when you press the right mouse button. Then deletes it. Seems to be working pretty well.

Things are starting to come up nicely so if you want to give it a try, I've uploaded new binaries to the google code page for you to give'em a try.

Fixed librender, mod_map working (minus byte-order). Regressions in mod_proc.

2010-02-25T16:03:00.001+01:00

Today I fixed librender, there were a few thing I had omitted, the most important of which was telling Bennu to redraw the screen every FRAME.

So after some rough testing, I believe that mod_map is working fine. I'll have to do more thorough testing, though.
I'm expecting to find problems with mod_map when working in a real Wii (I tested the code in my linux box) because of the different byte-order it uses. Colours will most likely seem broken. Expect a couple of demos about this later today or maybe tomorrow.

I've also found a regression in mod_proc. signal seems to not be working as expected. I'll have a look into that.

Also, the module dependency diagram is growing :)

libmouse, mod_mouse, libfont & mod_map

2010-02-24T22:16:00.000+01:00

Today I've integrated libmouse into the core & runtime. I didn't need to integrate mod_mouse as it has no real code and all it does is declare its dependency upon libmouse.
Also, while doing yesterday's changes to the way the offsets were defined, I pretty much broke all the GLOBALs because of a stupid error. That made Bennu think the mouse was static at (9999,9999) and make it not detect mouse events such as clicking. That's fixed now.

So now that the mouse is working pretty much as expected, I've integrated libfont into the runtime & compiler. No major hiccups with that and it was a required step for integrating mod_map.
Mod_map is in and parts of it work fine. Other parts don't, yet. So for example, you can do a png_load and a png_save but you cannot display GRAPHs onscreen. I'll have to look into that a bit further, but I think I'll post a small surprise after I get mod_map working, so that you can get an idea of the real state of the port, in case you don't care at all about/understand all the technical jargon.

To sum up, things are going great! :)

libblit, libvideo, libgrbase, librender & video initializarion

2010-02-22T22:33:00.000+01:00

It's been a long time! But well, I bring good news :)

Today I finally integrated libblit, libvideo, libgrbase and librender into the runtime. The test code works fine in my linux box and graphics are initialized to the default resolution (windowed+320x240) so it seems to be doing well.
The code needs to be tested in a real Wii, but I'll wait until I integrate mod_video (and probably finish integrating mod_mouse&mod_text) so that I can check that my code is running properly.

It took me longer than needed to complete the integration of these modules today as I hit a problem with the GCC preprocessor. The problem is that Bennu defines the byte offsets in the DCB files incrementally. So if you want to read property C from the DCB file, that property will be located in position: B+32bits.
B's position will itself depend in A's position. So to calculate the position of C, the GCC preprocessor had to do:
C=B+32=(A+32)+32=A+64

This method works well if you don't have too many properties and is very easy to maintain, but it has its limits, and while integrating more and more properties -coming from more and more modules- I hit that limit. Now I'm defining the fixed location of the properties by hand (A=0; B=32; C=64....), which is pretty painful to maintain.
It compiles, though.

Just in case you want to have a look, you can see how the offsets file is looking right now here.

Second article on BennuGD in the TodoLinux magazine, status update

2010-02-03T00:07:00.000+01:00

Remember that the second part of the article Osk wrote should now be available in a store near you. In this second part you'll be able to create a complete (although simple) game with Bennu.

Related to the status of the project I'm currently busy with my exams in the university so I'm not working on it. Doesn't mean that the project is dead; it's just on hold until I finish my exams.
That means that you should hopefully have a feature-complete -and probably buggy- native version of Bennu for the Wii by march or so.

BennuGD in the Spanish TodoLinux magazine

2010-01-07T21:53:00.000+01:00

Sorry to be a bit off-topic with this one, but the news are pretty exciting.
One of the users of the BennuGD forums has written an article for the TodoLinux magazine that is on sale in Spain.

If you want to know more on the issue, go to the main news piece in the main Bennu website, here.

Some work on video

2010-01-01T18:15:00.002+01:00

New year: more work done.

I've integrated libgrbase, libvideo & libblit into the runtime. As you can see from the module dependency diagram above, only librender rests to be integrated before I can integrate mod_video and do a set_mode() (or others, of course).

On a couple of related notes, on the last post I told you that all the modules that didn't depend on libgrbase that I wanted to integrate were already in. Well, I realized a bit later that mod_regex
(which only provides one funtcion, but a very useful one: split()) isn't in and should be. I'll fix that as soon as possible.

On an unrelated note, the main idea of the modular design behind Bennu is that the user should only load the modules they need, so no resources are wasted moving parts of Bennu that won't really get used.
Well, as you might know, the Wii has a pretty limited amount of RAM (~88MB) and therefore memory is a pretty serious concern here.
So, as this project basically takes all the modules and integrates them into the Bennu core, that main advantage of the modular design will be lost. To fix that, Splinter (the guy who does all the real Bennu hacking) has suggested that I find a way to only integrate -at Bennu compilation time- the modules the user will be needing, so that you can get a version of Bennu tailored to your particular needs.
I have a couple of ideas of how to implement that, as it seems pretty reasonable so expect to hear more on that when the project advances.

PS: Oh! And happy new year!

Finally! The all-text release

2009-12-31T04:23:00.000+01:00

Today I integrated the last three text-mode-only modules left I had planned to integrate before starting work in the graphical part of Bennu: mod_sort, mod_mem & mod_timers.

This means that most of the non-graphics related part of Bennu for the Wii is now done -just in time to celebrate the new year- and now it's time for me to focus on the part of Bennu that you can actually show to other people.

I also updated mod_sound and fixed a couple of bugs I had put there.

Last but not least, I did the same offsetting for the GLOBALs as I had to do for the LOCALs.

Happy new year, and say welcome 2010: the year of graphics for Bennu in the Wii! :)

PS: Just like it happens with the MacOSX platform (which isn't compiling right now in Bennu but has a lot of supporting code inside) memory_total() and memory_free() are placeholders and always return 0. I might be able to implement those, but I am not sure.
PS2: The text-only modules I have not yet implemented fall in one of these categories:

Either they don't make sense in the Wii (mod_wm, mod_sys). These will just be a list of placeholder functions that will only return default values and run no code.
Or they provide functionality not always present in the Wii (mod_key, mod_cd).
They're mod_debug, This one is big&complex and even if it's very useful, I want to focus on the rest of Bennu first.

Upsss! mod_proc is now working

2009-12-28T01:29:00.001+01:00

mod_proc seems to be working now. I will have to do more testing, but LOCALs such as FATHER seem to work now.
The problem was that when I inserted the code for the LOCALs defined in mod_proc, I had not taken into the account how their values where referred in the DCB (file offsets.h).

This was quite a complex bug in the sense that it would've been very hard for me to find. I have created a modified Makefile so that now I can compile and test most of the code without having to be in front of my Wii.
That helped a bit to find the bug but it was my brother who did most of the debugging this time, so thanks to him :)

So now, only mod_sort, mod_mem and mod_timers are left before I start with the graphical part of Bennu!

mod_proc is in, but it has problems with signal...

2009-12-13T22:30:00.000+01:00

mod_proc is now in, but there seems to be a problem with signal...
Processes seem to be affected by signal, but they won't die; their id changes but nothing else.
Also, when a process is called, their father local var is not set correctly (it's always set to 0).

let_me_alone does kill the processes that you didn't try to kill with signal before.

There's also some other function that I've not yet isolated that results in an unhandled exception...

Will have to look into this....

A bit of hacking with globals, locals and DLVARFIXUP, in general

2009-12-13T20:14:00.000+01:00

I'm not having much time lately to work on Bennu, but today I got to hack a bit on it.
Basically, what I've done is finish the mod_sound module (remember some time ago I said there were some bits left?).

What I've one is implement the code that initializes the global variables. The mechanism is the same as used for initializing local vars, so those should be easy to do now, too.

This is, however, a more important change that it can appear to be, as this was basically the only thing I didn't really understand about the new Bennu modular architecture (as opposed to the old Fenix static design). This means that I can finally also try to finish mod_proc.

So I'm hoping on having all applicable non-video related modules done very soon so that I can start with the code that makes Bennu so great: graphics :)

Happy coding!

Mod_dir is in & you don't want to move files

2009-11-28T22:14:00.000+01:00

Mod_dir is in, just remember that you don't want to move files around the filesystem or rename them.... It seems like those functions won't work as we're dealing with a very minimal C library.
You can create those functions with Bennu code, though, by opening the destination file+copying contents+deleting original file.

Long time, a few modules

2009-11-28T21:10:00.000+01:00

Got a bit of time to work on this today:

I worked a bit more on mod_proc. Now bgdc, bgdrtm and bgdi compile. I wouldn't say it's working yet, as there are some values that have to be defined at runtime that are not yet being defined, but it's a start.
Also, this modules defines some LOCAL vars. They're defined right after the GLOBALs.
A funny thing I noticed about how Bennu works is that these vars are defined, from within C code, with Bennu syntax. What that means is that the compiler adds that Bennu code in the Process declaration, as if you'd written it there.
Got mod_rand in. This one was really easy :)
Started working on mod_mouse. mod_mouse has no real code or definitions, all the code is in libmouse. It won't work, yet, as libmouse depends in the graphical part of Bennu and work on that has not yet started.
The compiler & interpreter will, however, be fine with you messing around with the MOUSE struct. Obviously the values you'll get are default ones and won't bear any resemblance with your mouse's position.
Fixed a few warnings.

I plan on getting all the modules that don't depend in libgrbase in soon, make sure they work and then proceed with the remaining modules.

BennuGD-wii, "Comes With Music" edition

2009-11-04T23:53:00.000+01:00

After the guys from SDL-Wii fixed the sound initialization code, sound is working better than ever (well, it's working for the first time).

To commemorate this event, I've uploaded a new version of BennuGD-WII code-named "Comes With Music". Basically, what this is is a version of Bennu that integrates the functionality found in mod_sound (minus a few bits related to the definition of these globals that I'll hopefully add sooner than later).

The code uploaded comes with a module tracker example song that will play when you unpack the contents of the archive to the APPS folder of your SD card and load it through the Homebrew Channel on your Wii, but the binary should allow playback of many other song formats: OGG, WAV, MP3, MIDI...

Hope you like it!

mod_sound might get fixed soon

2009-11-04T11:53:00.002+01:00

Looks like I might be able to fix the problem with mod_sound soon. There was a bug in the SDL code for Wii that caused the sound to initialize incorrectly when trying to play an ogg sound... This resulted in a very crappy sound, as described here.
Will report on progress and upload some test code when I get time to test this.

PS: To clarify, the code is really inside the binaries I uploaded a few days ago, I just need to link that code to a newer revision of the SDL code and hopefully, that will give us sound support.

Binary release for the Homebrew Channel with bundled happiness. mod_joy is in :)

2009-11-01T23:31:00.003+01:00

Haven't fixed mod_sound yet, but I've included mod_joy and think it might be a good time to release a binary version of the package, as it starts to be usable.

I have provided, as with most modules, some test code for the functionality inside mod_joy.
This library has been a bit more difficult than previous ones to integrate, as I had to do a few new things:

mod_joy depends in libjoy, so I had to get libjoy working first.
libjoy depends in libsdlhandler, so I had to get libsdlhandler working first.
The initialization code for libjoy is a bit more complex than the one found in other libs, so I had to add some functions to the header for libjoy.c that declared the initialization and finalization functions.
That also made me think that the way I was initializating the module code was not correct (as I was doing it from within bgdi code, not bgdrtm code).
So I moved all the initialization code into the correct place in core/bgdrtm/src/sysprocs.c.
Also, libsdlhandler gets in charge of updating the SDL event list (a "list" that keeps track of things that change and should be noted, like pressing a key in your keyboard, moving your mouse or using you joystick, to name a few). So it has a function that must be ran every FRAME.
I had to find the way to tell bennugd-wii to do it.
Basically, you just have to use hook_add() in the initialization code with the correct hook, but that hook was in modules/libsdlhandler/libsdlhandler.c, so I had to declare the HOOK in modules/libsdlhandler/libsdlhandler.h.

By the way, I must take the function declaration out of core/bgdrtm/src/sysprocs.c as the code is getting pretty nasty. I will probably create a header for every modules (that doesn't have it) to declare all those needed externs.

For the brave, I've released a package with a binary snapshot of today's SVN code and the test code.

You can directly use it in the Homebrew Channel provided you read the included README file.
You can get it from the project homepage here.

Hope you like it.

sound is crappy

2009-11-01T18:36:00.001+01:00

I more or less integrated mod_sound into bennugd-wii. The functions are there, and sound playback starts, but the only sound playback is a horrible static noise.
It might be related to this advice on the SDL doc and other people seem to have this same problem...

I will post any updates when I get it working.

mod_file is in, in the form of a poem

2009-10-31T21:50:00.001+01:00

I got mod_file inside Bennu.

The example code for this module is just the typical code that opens a file, read it's content and printf's -well, say()'s- it. As I had to choose some random text to put in the file, I chose José de Espronceda's famouse Canción del Pirata poem (instead of the typical lorem ipsum stuff; there's a small artist inside me :).

Also, I found a bug somewhere (libfat?). If you try to fopen() a file whose name is long, it will crash :(

Stay tuned for more updates on the Wii front.

SDL has now been initialized

2009-10-31T20:42:00.001+01:00

I finally got a bit of time to get mod_time working.
The functions seem to work fine, so now the three functions it contains (ftime, get_timer and time) seem to work fine.

The nice thing is that this means that SDL is being initialized at the program startup. This is important as SDL is the main library behind Bennu, so it's always nice to see it not crashing.

I also added the test case for this library (examples/05_mod_time.prg, 04_mod_math.prg is missing, sorry for that) in case you wanna give it a try.

More updates to come.

mod_time in (will crash) and mod_proc thoughts

2009-10-27T12:55:00.001+01:00

Spent a bit of time today getting mod_time to work with Bennu.
This module makes use of SDL for the ftime function, therefore I've had to make bgdi link to it.
bgdi will crash if you try to use it as it is (get_timer and time should work fine, though) because I SDL must be running for this function to work, and I don't yet initialize it, but that shouldn't be too hard to do.

Also, spent a few minutes looking at mod_proc. It defines a few LOCALs and GLOBALs, so I have to find the place where they belong to.

Stay tuned for more updates.

PS: re-reading this, get_timer will also crash, as it also uses SDL. Initializing SDL isn't hard to do, at all, so these crashes should be easy to fix.

mod_math is in, or how to define constants

2009-10-22T02:55:00.001+02:00

I just committed a new revision of the code that integrates mod_math.

For mod_say and mod_string, integrating the module involved:

Adding the function definitions and callback functions to the sysprocs table in core/include/sysprocs.h. This is easy because that info is already defined in the mod_*.c file and I just have to add a few other fields that are trivial to guess.
Adding the function prototype to core/bgdrtm/src/sysprocs.c. This is also quite trivial. I will probably add another header to the source base with the new function prototypes so that I don't spam the code too much.
Adding a #ifndef __STATIC__ block around the __bgdexport block in modules/mod_*.c so that code is ignored during compilation (as the functions are now declared in core/includes/sysprocs.h).
Modifying the Makefiles so that the appropriate files are compiled into bgdrtm.a

I chose to go with mod_math this time as it declares one global variable (the value of PI. For whatever reason, Bennu seems to define PI to 180 degrees instead of the classic 3.141592654.... radians, which is kind of weird) which is something mod_say and mod_string didn't do.

To define such constants you have to add them to the table in core/bgdc/src/main_core.c with the appropriate value, which involves copying the line directly from the module source code.

As you can see, its pretty straightforward to integrate modules inside Bennu once you understand how it's done.

Looking forward, I have to find where to define functions that are run on specific moments (most importantly, functions that are run each FRAME) for other modules that need such functionality like those drawing into the screen.

On the following days, I'll write and upload a test case for the functions included with mod_math and make sure it runs in my Wii as today's commit has not been tested in the real hardware yet.

Welcome to my worklog

2009-10-21T01:59:00.001+02:00

Welcome to this worklog. Here I'll write about my progress with getting Bennu to work natively in the Wii.
If you want to know more about Bennu, go here and if you want to go to the project page for the port, go here.