I suggest we discuss here about the best hardware for the eZ80 version. Well, the processor is already pretty much decided isn't it?

• Processor: eZ80
• RAM: ?
• (Flash)ROM: ?
• LCD: ?
• LCD Driver: ?
• Keypad (view details below): ?
• Linkport (view details below): ?

(S)(D)RAM details: how much ram, how fast/slow read write cycle and which manafacturer?
(Flash) ROM: how much ROM? do we want Flash ROM or just "regular" ROM? read/write cycle? manafacturer?
LCD: resolution? refresh rate? manafacturer? (I keep asking that because we don't want to cheaply made crap that breaks easily)
LCD Driver: buffer size? r/w cycle? manafacturer? compatibilty with LCD (pretty much a must)?
Keypad details: specifically how many keys and seperate keys for letters? or a alpha mode switch like on the TI83/84+(SE)?
Linkport details: do we want a old IO port (probaly not) or mini-usb, or even 'full' usb? and do we want a mini-jack for the sound? or something else? someone even suggested SD-card compatibilty...

I probaly forgot some important stuff but this is all I can think of now.

Well here is a complete suprise release. Sometimes when you have alot of free time (like now) and have some old unfinished projects laying around then sometimes you suddenly finish it.

The engine surely uses a very slow method (matrix based worlds) but I already figured a map compression technique that should ease the pain of the massive size of matrices (not implented in source below). Second, this engine was mostly intended to be used by the beginners in Basic who just want to create a game and not having to go through the process of creating collision detection, movement etc. So here it is! SkyBox2D V1.0!

prgmSKYBOX2D
ClrHome
1->L
"_NP[-]+I=*->Str0
prgmSBLEVELS
For(A,1,16
For(B,1,8
Output(B,A,sub(Str0,[A](B,A),1
End
End
2->X:2->Y
Lbl SB
0->K
While not(sum({24,25,26,34}=K
getKey->K
End
X->C:Y->D
X+(K=26)-(K=24->X
Y+(K=34)-(K=25->Y
If sum({4,5,6,7,8,9}=[A](Y,X  // every number in this list is a tile number that is collidable. The next and previous level tiles are non-collidable tiles and are thus left out of this list
Then
C->X:D->Y
End
Output(Y,X,"M
Output(Y-(K=34)+(K=25),X-(K=26)+(K=24),sub(Str0,([A](Y-(K=34)+(K=25),X-(K=26)+(K=24))),1
If [A](Y,X) = 2 or [A](Y,X)=3
Then
L+([A](Y,X)=2)-([A](Y,X)=3)
prgmSBLEVELS
For(A,1,16
For(B,1,8
Output(B,A,sub(Str0,[A](B,A),1
End
End
Goto SB

This code manages five things.
1. It draws the Map that is in [A].
2. It moves and displays the main character (the letter M in this example)
3. It does collision detection
4. It handles going to the next or previous level depending on the tile you step on (tile #2= next level, tile #3 = previous level)
5. It leaves no traces of moving the main characters around. It just copies the previous tile you were on to its original location.

Levels are set up as follows. Create a prgm called SBLEVELS (or name it otherwise in the source above) and insert the matrices. All matrices are 8x16 in size. Every element in the matrix represents a tile at that location. So [A](1,1) = 1 means that the tile pointed to by number 1 is drawn at position 1,1 on the homescreen.
L increments by one if you step on a next level tile and decrements by one if you step on a previous level tile, Therefor this could be level code:
If L=1
Then
If not(LDATA(L
Then
1->LDATA(L
Pause "You are in level 1 atm and I wont say it again!"
End
[[....
.....
...
....
]]->A
End
If L=2
Then
If not(LDATA(L
Then
1->LDATA(L
Pause "You are in level 2 atm. This message is only displayed once"
End
[[....
.....
...
....
]]->A
End

IMPORTANT this post is incomplete but I am running out of time and on the other hand couldn't keep my excitement about this engine. I promise to provide additional (required information) as soon as possible.

My entry for the Axe contest will be an attempt to port this AWESOME game:

I will not stick to the official levels very strictly but I'll try

here is a mockup/eye candy of some spriting I did.

EDIT2: Seemingly my explanation is not really comprehensible because this topic has been viewed alot but 0 downloads so far...
or: is there simply no intrest in this? tell me!
One of the most difficult aspects of asm is its final output. it is just a sheer list of hexadecimal characters. There are some on calc converters that allow you to write ASM but they compile slow and are slow to write in unless you can type blindfolded on your calc. I never tried to code directly in hex but yesterday was my first try and it went suprisingly good! One problem was in looking up all the hexadecimal codes for the commands (i try to avoid bcalls altough they are pretty easy in hex).

So I wrote a program that could look up commands for me. Currently I have a 382 byte string that contains the first 20 commands of TASM80.TAB
It works as follows. It looks up the command in str0 and outputs the correct hex format. BCALL's are yet unsupported since the hex digits are swapped and well..I just ahve not included that yet. If one were to include all the commands into str0 (no bcalls, only the commands) it would take up about 6KB. However not every command is really needed/ a lot used so currently I am writing a Limited instruction set into str0 that has all the basic asm commands. If you however wanted to add a command you'd only need to typ '^' into MASM (that is what my program is called).

Well enough talk lets get down to the action:
Before you boot up make sure you have string 0 declared, if you don't use the supplied string in the attachments just store something like ":" to it.'

As you boot up MASM you get a Command Line Interface (that is a pretty glamourous description of the Input command but enver mind). You can do 4 things from here.

Q              | quits
C              | clears string0
^              | Add a command to the library
[command] | outputs the hexadecimal code for [command]

Q and C are pretty obvious but '^' isnt. Whenever you add a command you are prompted 'C:' and 'H:'.  Make sure you open up TASM80.TAB or something else, just don't make mistakes in the input...some errors are catched but a wrong hexadecimal code might eventually crash your calculator.

C: [type number here][type command here]
H: [type hex equivalent here. lenght of this must be equal to "[type number here]"]

the command is now added to the library (aka string0)
lets for example add the command EX DE,HL

Tasm80.tab says this: EX   DE,HL   EB   1 NOP 1

There are two ways to deduce the number you need to type BEFORE the command. 1 way is to multiply the number BEFORE "NOP" (or ZIX sometimes) by 2. In this case 1*2 = 2 so the number would be 2. The second method is to look at the hex-code. in this case EB = 2 characters long. I highly recommend the first method because sometimes with commands with * in it (which means something like: fill in the blanks with a hexadecimal code of a number).Now we type the command:

C:2EX DE,HL

hit [ENTER]

then the hex equivalent:

H:EB

hit [ENTER]

So now the command EX DE,HL is added to the library. We can now recall the hex code for it by typing:

EX DE,HL

which will print

EB

BCALLS use the following syntax:

EF[last two digits][first two digits]

ClrLCDFull for example = 4540h

in hex that would be:

EF4045

This program is to be a digital replacement for TI83PLUS.INC (not yet) and TASM80.tab
I consider making an app out of it eventually to avoid the use of str0. For the moment however this program must be seen as a quick and easy lookup for Z80 commands.

Feedback and critique are welcome but just remember this is a unoptimized, pre-alpha and around midnight created program which lacks optimization.

EDIT: I think AXE is just perfect for this. it allows to insert large amounts of data without using user ram and it allows me to output to an app. I think I'll have to learn axe then....