Quick try, non-tested (admits that you want to apply the effect to the current content of the screen) :62->A+1
While 1
Copy(-1*12+L6,+12,63-A*12)
DispGraph
End!If A--+1

Faster, not sure. More featured, well yours can't redraw the whole screen each frame nor take variables images or sizes. Easier to use, probably.

Alright, so I took a screenshot and made a program, but really it's waaay faster on-calc ...



What you have to do is define °MapW, °MapPtr, °CamX and °CamY to the bitmap's width in bytes, the pointer to it, the X coordinate of the pixel to display to the top-left and its Y coordinate respectively, then put prgmSMOOTH where you want to draw the map.

It's based on a "real" game, you know I didn't get the idea.

Bumpity bump,

Big bunch of updates !

• Added a timer !
• Added a finish line !
• Added a lap counter !
• Added a per-lap timer !
• Added checkpoints, to make sure you're not cheating
• Added actual acceleration-based movements !
• Added animations for the ship (improvements will come) !

Don't worry, it's fast and good-looking on-calc, my PC is just not changing from being shit.

Hello Converge, welcome to Omnimaga

Unfortunately, I don't know much about Lua in general. I use to use OCLua to code Lua on-calc via the classic Notes tab, but it's pretty outdated. If you want to have the features of Notepad++ (or nearly) on your TI-Nspire, you should take a look at Jen's Script Editor, which is an on-calc editor including block collapse for instance.

Hey guys,

As it turns out the bitmapper I wrote for Worms was respectabily fast, I thought that some people would like to use it for their projects. It has ASM in it, so be sure you copy it correctly.

So first, here's the actual code. Sorry to not provide an 8xp file, but I'm posting from my phone as I have no PC for a while instructions on how to use it are below it.

:~1
:For(64)
:+1
:Asm(E5)
:Copy(->r₁+CamY* MapW + (CamX/2/2/2)+ MapPtr, r₁*12+L₆, 12)
:Asm(E1)
:End
:
:If CamX^8
:->r₃
:For(r₃)^r
:Horizontal-
:End
:
:~1
:For(64)
:Select(+1,{->r₁+CamY* MapW +(CamX/2/2/2+12)+ MapPtr} and (e^(8-r₃->r₄)-1 xor _EFF)Asm(5D)r₄Asm(45CB3B10FC6B) or {r₁+1*12-1+L₆->r₂}->{r₂})
:End
:End

At least it's more understandable than Runer's code.

So yeah, don't worry, I had a hard time copying it here too

How to use that thing :

• MapW is the width of your map in bytes. It can be any unsigned 16-bit number.
• CamX and CamY are the coordinates in pixels of the top-left pixel displayed on the screen. You'll have to make sure yourself that they won't go over MapW-96 for the former and MapH-64 for the latter.
• MapPtr is simply a pointer to your MapW*MapH map.
• Just to make sure, ~ is the negative sign, not to confuse with the minus sign.

Just copy-paste that bunch of code at the place in your program where drawing occurs, and since the whole screen is covered with the map, you don't need ClrDraw anymore, and don't need to maintain the map in an external buffer either. Just keep your plain map for the engine, no need to modify it for scrolling.

If you use that code in your program, it'd be cool to give me credits just for it

I can't really know how fast it is, since a whole physics engine runs on top of it in Worms (but it's still fast, so I thought it would be worth posting). So, since I have no PC, could someone post speed tests and/or screenshots, to see how fast it is ? Kinda like Runer did for his own bitmapper one year ago

Share your comments

Okay, that'll be helpful for full models animations, things like wheels and stuffs.