Since I’m not going to do any further development on this (for various reasons), I have decided to release libellen - a sprite handling library for the Nintendo DS, based on libnds.

The library is released under the terms of the WTFPL.

The source and "example" are super documented, and evena Doxyfile is attached if you want to create documentations.
The library was tested and compiled using devkitARM r21 with god-knows-what libnds version. If you find incompatibilities, I’ll be happy if YOU would fix them.

Have fun and happy coding!

For those who are intrigued by the name - lib-ell-en (L - N, my name’s initials) could also be read as libellen - dutch for "Dragonfly" which is what the logo is based on. For those who wonder, the logo is also released under the terms of the WTFPL.

Some history:
libellen was first made as the low-level library for ToD2, but was quickly got good enough to be expended. My second goal was also to get people to stop using PAlib, an old, slow and deprecated library which people insisted on using. The library was not complete, but the sprite handling was. after more then 6 months of inactivity, I have decided to release the library to just handle sprites.

* fixed problem with backgrounds not loading and other weirdness

Added Lode Runner skin
Built with latest tool chain.
SoundFx and music now use AS_Lib as with latest PA Lib beta.
Save file can now be in any directory. As default the game searches for the location of a previous save then location of the nds file. If neither are found (if you rename the nds file), the save file will be created in the root directory but can be moved afterwards.
WiFi transfer now retrieves rank correctly (Up to 100, was only retrieving rank 10 maximum before).
When you win on the slots, you can now hold A or B button to make the coins count up twice as fast. (Fixed 4 slot mode, only worked in 3 Slot before).
Can hold B button to make text scroll faster in the shop.
After playing Shoot mode, the rank shown is now how you ranked for your last go rather than your best rank overall.

* Amazing new speedhacks to make some games run faster
* Fixed some graphical garbage while rom menu scrolls out
* Rom menu no longer shows game codes of GBC games

Added catalog. Added functions: abs, acs, asn, atn, mean, nDeriv, nIntegrate, rand.

based on r12452 (internal rev1926)
the NDS port now has a different toolbar, more suitable for the small screen
for better access with the touchscreen the toolbars have been moved to the bottom screen
a fully customizable on-screen keyboard has been added (click on a text field to open it)
a newsticker display on the lower screen has been added
some windows have been adapted for the NDS screen (more will follow in future releases):
- intro menu
- game creation menu
- minimap
- build vehicle window
when building depots and stations only one preview image is shown which you can rotate by clicking on it
information regarding accepted cargo when building a station is displayed as icons now
switching screens (left shoulder button L) now only switches the windows
many windows (e.g. confirmation dialogs) are now centered on the bottom screen
the amount of free ram (in kb) is displayed in the middle of the status bar. This is only a temporary change to help with tracking down a memory leak
additionally you can view some memory information by pressing the B button
always use new global pathfinder (NPF). the original TTD pathfinder crashes due to too many recursions
fixed loading screen glitch

Problem Statement
This first competition is about plotting the Mandelbrot set, which is a noteworthy fractal that is both simple and complex at the same time.
First of all, this is a speed optimisation contest; so, the winner will be the entry which completes the tasks set before it the fastest. There are lots of ways to improve the speed of such a process, and it's a classical mathematical and computer programming problem, so I thought this was appropriate to start the competition with.
Here are the specific requirements of the code to be optimized:
* It needs to plot a rectangular section of the Mandelbrot set into an array (That array may be rotated or scaled, it's not axis-aligned)
* The rectangular section will be defined by top left point ( a complex value ), complex step values in the X and Y directions, and the width and height (in array elements) of the output
* The top left point and step values will be complex numbers represented by 2 64bit values (one for the real, one for imaginary dimension), each value being defined as a 4:60 precision fixed point number (-8 to +7.999...)
* The output array will be an array of 16bit values corresponding to the number of iterations before the value at that point diverges (up to some cap given in the function parameters) (this is defined more specificly in the section below)
* You will be given a 512kiB block of contiguous memory, which is aligned to a cache line boundary. You don't have to use it, but if you need to use a lot of memory, it's where you should be putting things.
* Regarding precision: You must keep 64bits of precision through all operations, the C code will do this, so if you don't, your submission will probably be disqualified. Without some guarantees on precision, the code isn't going to be very useful. Also, since it's a speed optimisation contest, you are welcome to make your code more precise, but you're probably better off not doing so. Good luck! A small amount of difference is understandable, too, given differences in math that can be used, so your output won't have to be exactly like the example code, just not completely different.
* Here's the function prototype for the function that does all this: void MandelFunc(u32 * rectangle, int max_iteration, int width, int height, u16 * output_array, void * workram);
* Rectangle is a list of 64bit numbers, 64bit numbers are stored as the low 32bits followed by the high 32 bits - the numbers are topleft_real, topleft_imaginary, stepx_real, stepx_imaginary, stepy_real, stepy_imaginary (total of 6 64bit values, or 48 bytes)

To make this process a lot simpler, I've written a small program for DS that can run code snippets in a rather controlled environment. It's in a zip file package below. This package contains the test engine, which is a bit hacky and slow ;), it also contains 2 other important elements: the example C++ code that does everything an entry needs to (you could submit it if you want, but then we might laugh at you.) - also included are some templates, bare bones C++ and asm files that show you how to start your own routine. The test app can be easily built with the latest versions of devkitARM and libnds, and will allow you to test the speed of one or more implementations you have created. The test app uses seeded random data to compare the output of your functions to the reference function, so you also get verification of whether or not your code is working correctly.

Download the Source package here (version 3) - This includes a test application which has a reference implementation of the function to be optimised as well as some templates to choose from.
Note about the source package: First version was really rushed and missed a trivial optimisation - so version 2 of the package has been released with example code that's roughly 6 times faster - It will no longer be quite so painful to test things, previously this code was a limiting factor for testing, taking 30+ seconds to verify the tests, now it should only be around 5 seconds.
Note 2: Version 3 fixes a glaring bug in the fixed point multiply. On a related note, precision isn't tested very well in the current test package, there will be another test project release in a few weeks that will better verify precision.

Now, about Rules:
Every compo needs 'em!
CAN means you may; SHOULD means you are probably missing out if you don't, MUST and MUST NOT indicate mandates from the heavens; ask me before doing the opposite and be prepared to be told not to.
* You MUST NOT use any global variables (besides constant data)
* You MUST NOT put any code or constant data in ITCM or DTCM
* You CAN have constant data, but not too much, 64k is more than enough space
* You CAN use the hardware divide / sqrt capabilities of the DS
* You MUST NOT use timers, graphics hardware, or other DS hardware outside of the hardware math functionality. I can't think of any useful exceptions but may be willing to grant some if I'm wrong.
* You CAN use malloc/free/new/delete, and other standard library functions in either the C or C++ standard libraries. It's your cputime, who am I to stop you ;)
* You CAN use stack-allocated memory, just be aware that the full 16k of DTCM (where the stack resides) may not be available to you.
* Your code can't be too terribly big. I'm thinking 64k is the threshhold of "starting to get too big" and 128k is the threshhold for "yeah, that's just too big." - if you do manage to use that many instructions though, you won't lose that much speed by halving the size of your unrolled loop anyway :P (And I mean compiled size, not source size)

About the Mandelbrot set
I'm sure some of you have run into the Mandelbrot set before, either plotting it with some trivial code or just tinkering with some fractal generator, but it's unlikely you remember exactly how it works off the top of your head. So, this section is all about how it works.
The Mandelbrot set is a fairly simple relationship based on complex numbers (see link for more info). In short, complex numbers are 2-dimensional numbers, with one dimension in the "real" plane (normal numbers), and one dimension in the "imaginary" plane (numbers multiplied by "i", or sqrt(-1) ).
So, adding and subtracting complex numbers works a lot like normal 2d vectors; (a+b*i) + (c+d*i) = ( (a+c) + (b+d)*i )
Multiplication and division are more complex though. Multiplication winds up looking like a polynomial expansion: (a+b*i) * (c+d*i) = a*c + a*d*i + b*c*i + b*d*i*i, and since i*i is -1, you're left with = (a*c - b*d) + (a*d + b*c)*i;
And division is even more complex, requiring first a step to reduce the denominator to a real number: (a+b*i) / (c+d*i) = (a+b*i)*(c-d*i) / (c+d*i)*(c-d*i) = ((a*c+b*d)+(b*c-a*d)*i) / (c*c+d*d) - Which is just a multiplication problem and division by a constant, so I won't complete the expansion here.

Fortunately, the Mandelbrot set only uses Multiplication and Addition, which are both generally pretty easy.
Specificly the Mandelbrot set consists of all of the points in the complex plane where a specific recursive relation never diverges to infinity. The relation that defines the Mandelbrot set is P(n+1) = P(n)*P(n) + c, where P(0) is 0, and c is the value of the point you're testing in the complex plane.
The Mandelbrot set exists completely inside a circle with radius 2, the furthest point in the set is (-2 + 0*i), so if P(n) is ever outside of that circle, we know that point will converge to infinity and not be in the Mandelbrot set.
We're not purely interested in whether the points are in the set though, we want to know how many iterations it took if they were pushed out of that circle, that's how we get the fancy colors! So, for this problem store the first "n" that was outside of the radius-2 circle into the 16bit array value for that location. You will be given a "maximum" value, and if your n passes the maximum value, you should set the maximum value for that array element and move on.

Wrapping it up
Ok, this description went on a lot further than I expected!
I do realize that this is a pretty tough problem! If you'd like to be involved in an optimization contest but this is too hard, tell me! I'm currently considering opening up a second "branch" of competitions, for easier optimization contests, and whether I do will depend on if anyone bugs me about it!

This competition is going to be running for 2 months - which should be long enough to implement and optimize something like this; I'm mostly using 2 months because I figure I'll have more time around then, the next month looks pretty hectic for me.
Also, I have planned to create an update for the test application, to allow timer-sampled profiling (with profiler in ITCM so it doesn't screw up the cache profiling much), which should prove a powerful tool for finding issues and optimizing code! look for that around a month from now.

Notable Questions
I've received a significant question that I think the answer should be easy to access, so I've added this section to keep track of important questions and their answers:
Question: Is it ok to use other people's publicly available code for this competition?
Answer: Technically yes; as long as it has a license that's compatible. See the Rules page... Just copying the code goes against the spirit of this competition site, the goal is to learn something and produce new code; but I won't disallow it.
Question: Can entrants work in teams?
Answer: Yes. Only one account may be tied to an entry though, so you'll have to credit teammates in the title or the source code that's submitted. (Inappropriate team names may be moderated, you know who you are :P)
Question: What do I have to submit to enter?
Answer: Only the source files you created/modified, in one of the supported archive formats (zip, rar, tar)
Question: Will there be prizes?
Answer: Not in this competition. I'm considering it for future competitions though.

SECOND TO LAST UPDATE

OK, I have completed everything except for adding other characters.

Here's what I have:
_1) 3 levels with 4 rounds a piece.
____a) On the first level simply jump on all of the blocks once to clear the round.
____b) On the second level, you have to jump on them twice.
____c) You only have to change a square once, but if you jump on it a second time you clear it and have to jump on it again.

_2) On the left, QBert faces that show how many lives you have. If you fall, they disappear. You get 3 lives.
_3) On the right you see which level and round you are playing.
_4) Before each level, there's a little demo, like in the arcade game.
_5) The disks have different y positions on each round, although it's the same for all 3 levels.
_6) For now, when you complete all 3 levels, you start back at level 1 again.

Now, I know that only having the playfield 1 color sucks, but I can't do anything about it. It's OK until the second level. In the real game, you have to change colors twice. Since I can't change colors what I did was, the first time QBert lands on a square, it's partially filled in as normal. The second time, it completely fills in. It isn't pretty, but it works.
Also, there's only 2 disks throughout the game, instead of some rounds having 3 disks like in the arcade and 2600 versions.

Since it only goes to 4 cubes across, and the arcade had 7, I'll make up for it with the following:
_1) Red balls can now chase you up the pyramid, unlike in the arcade where they can only move down.
_2) There will be no randomness. Enemies will aim directly for you, and the beneficial green ball that freezes time will run away from you.
_3) In the arcade and 2600 version, on the second level there's a round where the walls of the cubes disappear. In this game, a round in the second level has the whole pyramid invisible.
_4) You get 3 lives only. No extras.

Well, guess that's it. I won't be posting another update until the other characters are added (and I'll also try to add a "splat" sound when QBert or Coily fall to their doom).

Here's a major bug fix update with a sexy new feature as well :)

This release should resolve issues with the Mad MP3 Player for those that were hanging onto V12c, so newer features can be used.

Also, there is now a graphic display for the Heart Rate Monitor mode for the limited number of people using it. This version also has the ability to save a Heart Rate logfile to MS if configured to do so, making it possible for a Windows programmer to make use of it.

Heart Rate/Activity Graph Screenshot is attached.

This screenshot represents a brisk walk becoming a medium jog up a steady incline, and then settled down to a slow walk. All in just under fifteen minutes. The display can currently represent up to eighty minutes workout session time.

Thanks to MjW for his recent Memory Stick donation. They are much appreciated. Although I maintain the program will recieve no more major updates, another donation might just prompt another one, and get your nick on the greetings screen.

Time Baby is tested with 3.03 OE, and 3.52 M33 firmware versions, and may also work with newer firmwares that support the 1.50 kernel mode addon. It is not compatible with the PSP Slim & Lite.

Download Time Baby V13e from Rapidshare:
http://rapidshare.com/files/104030615/Time_Baby_V13e.zip.html

Download Time Baby V13e from MegaUpload:
http://www.megaupload.com/?d=1Z0SPD7Q

Download Time Baby V13e from sendspace:
http://www.sendspace.com/file/512nj4

- Quick VGA support, nothing major, and non-optimal (just upscaling for now)
- New graphics by TWolf
- Cloning now also clones the static state
- Fixed bug when moving objects
- Action button now pauses simulation
- Added gravity control !!
- Added gravity to saves and undo/redo
- New exe icon
- More accurate saving/loading (experimental)
- Multiple pages on save/load
- Fixed save/load of more than 16 scenes

Not an April Fool joke...
After several weeks effort, finally, we make pspkvm 0.3.0 released before April 1. The new release is combined of two JavaME porting on PSP: pspkvm 0.1.0a and pspME 0.2.1, and come with some new features, e.g networking and user-defined key mapping. Since it's a big jump from previous pspkvm, the user experience is completely changed, I'd suggest to read the "Getting Started Guide" before you change to 0.3.0, you can find this pdf file on download page.
Plz don't surprise if you see some regression in the new release, e.g "Game ABC cannot run now but run well in previous version", or "Loading speed is slower than before". Feel free to report any of such bugs or regressions in the SF.net forum, on bbs of pspkvm, or directly email to us, we'll appreatiate your report to help us finding out all the regressions, which will be our target of the next release.

Enjoy!
M@x

thx to BRP for helping with the Sys_reset function ;)

Yes, this is a fake, but i still want ppl to try it :)

So plz dont remove the page :(

+[Askot]
- Fixed/changed SDCARD slot selection for searching roms, at
start you will be prompted for this option.
- Code cleanup.

+[dsbomb]
- Added Wii mode support.
- Joystick fixes due to libogc r14's changed stick values
- Rearranged menu to make more sense, and consistent with FCEU
- Add "Reboot" menu option
- Removed "." directory from SD card listing, it's pointless
- Expand DVD reading to DVD9 size (one DVDs are working again)
- Added option to go back a menu by pressing B.