What are some ideas, none that are unreasonable (can't think of any like that right now) and none that someone else is doing. I would like to make this on the graphscreen with the use of a graphics library like xlib. I would also like to implement jumping in some way, and use sprites.

Code:


will add more later, give feedback please

We need a good Mega Man game, definitely.

what size sprites should I do, I'm thinking of using 12x12 or 16x16. But 16x16 will be way too big, and I think 8x8 are too small. Also what would be the best sprite routine to do these?

A Pocket BomberMan clone has not been done before either and would be a cool idea if one managed to pull it off, plus the small level size would make it more manageable.

I think that you should start with one of those concepts, but take it in your own direction.

8x8, or 9x9 character on 8x8 background (In Desolate, the player was 16x9 and the map was made of 8x8 tiles, which was a nice touch)

The sprite size really depends on the language you code it in, and/or the utility. But since this is TI-BASIC, I would suggest 16x16 on an 8x8 background, or maybe 12x8 on an 8x8 background.

Though, if you do 16x16 sprites, and use an XOR or an OR+XOR method, then in reality your sprites could be anywhere from 9x9 to 16x16, as to not make them too big. But then hit detection gets fun

Personally I'd vote for bomberman using 12x8 sprites on an 8x8 background, or something like that. Bomberman was a fun game

I totally missed the TI-BASIC part.

As did CDI, it seems. OR+XOR and pixel-based collision detection are quie the challenge in TI-BASIC. I guess Xlib would ease the pain a bit.

Now then, we've got that out of the way. OR+XOR just implies how you'd draw the sprite. You'd OR a "shadow" of your character, and then XOR the parts that should be white, to get a sprite displayed, then you could re-draw that part of the map. Mind you the only thing with an update of the LCD attached would be the XOR, and to redraw that part of the map I'd suggest storing the current screen to a pic and then go from there.

As for hit detection, fancy math would be leagues faster than testing for pixels, and lead to better graphics.

Of course if you don't feel the need to have any sort of background layers to your game, just go with a simple XOR and then re-XOR, applying the screen refresh on the first one, but not the second. And then fancy math with a pxl-test( would get you far, but that also depends on how fast pxl-test( is, I forget. And how you manage where the player is on the screen, compared to how the screen is drawn.

Definitely Megaman Zero.