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

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.

Well, you can scroll greyscale images with ::*ptrToLayer2*->MapPtr
:prgmSMOOTH
:StorePic
:*ptrToLayer1*->MapPtr
:prgmSMOOTHIt's just mapping the grey layer to L6, copying this latter to L3 then mapping the black layer to L6. It's just going to be slow.

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.