I like option 2 the best, because that seems more automated and the user still gets to see that it is in fact asmdream doing the work.


Also, Update: I removed the keyMask port. Really, it isn't needed since it was actually faster to just scan all of the keys without checking if it needed to be read. In fact, I optimised the key scanning routine to be even faster and smaller than what I originally thought it could be:
     ld bc,0701h
     ld a,$FE      ;test the keys
     ld hl,saveSScreen+key0
KeyUpdateLoop:
     out (1),a
     rlca
     nop
     ini
     jr nz,KeyUpdateLoop
I replaced the byte with something else, explained later. For now, the next update is indirection:
I added in the ind1() and ind2() instructions. They have more complicate abilities, but the easiest way to use them is something like:
     ind2()
     lda(addr1,indirect)
ind2() says that the second argument passed to the processor will be read as indirection. How that may get complicated is with something like this:
     ind2()
     inc(addr1)
     inc(indirect)
The first increment works as normal, but the second one has indirection. Internally, ind() instructions rotate a bit into an indirection counter (up to 8 bits). I did this on purpose, instead of simply setting bit 0 or bit 1 accordingly. It is just as easy to rotate the bits in, so why give the extreme coder the ability to use all 8 bits? With this in mind, you can make both arguments in an instruction read as indirection:
     ind1()
     ind1()
     lda(indirect,indirect)
The way that works, is first a bit is rotated in, then another bit is rotated in, leaving the lower 2 bits of the indirection byte set, so the next two addresses will be computed as indirection. Even better is that the indirection byte is what has replaced keyMask, so you can control indirection a little more and save bytes in some cases.

The attached file has an updated Jade.inc with all of the supported instructions, as well as some documentation, a 'readme' an example, and the associated asmdream macros and equates that have been updated. No new screenies yet, sorry

What if you did ind2() \ ind1()? That's a cool idea, though, and definitely something that will make writing more complicated games easier

Ah i misunderstood how it works, so the ind1/2 instructions don't update the indirection counter! That makes more sense. So ind1 is essentially:
ld hl,indCounter \ scf \ rr (hl)
...and ind2:
or a \ rr (hl) \ scf \ rr (hl)
...where you just rotate a byte in. You're not setting that specific bit but rather rotating it into that position.

I'm preparing asmdream 1.00.
The 8xk will be ready in one or two days (other files later).
It'll include support for automatic assembling from external code (program or other app).
The hard part was to be able to actually tell asmdream that an automatic assembling was requested.
I finally found a way to pass that info using iy (the only register that is not overwritten by _executeapp bcall).
So it'll be quite easy for you xed =]

Yes, but iy must then point to a safe ram location because that routine actually writes there.
Asmdream will then restore iy to $89F0 and then alter the same flags the routine normally do.
The thing is, i don't know yet if _executeapp "reads" the flags but i'm pretty sure it doesn't.
Anyway, i think that's a nice trick to pass parameters to an app.
I also found a way for an app to know if it was executed from external code just by checking if sp is different than $FFE3.

Thanks, I will see what I can do! I will also try to see if there is a way to make it return to an app, too. If it doesn't return because of bcall(_JForceCmdNoChar), then that would be an issue for programs because it would eat a little RAM. For an app, I can just temporarily create a GetKey hook to automatically re-enter the app.

EDIT: One solution might be to make it so that your app starts with:
     jp Start     ;go to the normal start of the app
     jp Compile    ;jump to the compiling code
If your compiling code is a subroutine that ends with an RET, then people can simply use 'call 4083h' to compile a program.

Found a bug where a few stack entries were wasted when the goto feature is selected.
I totally recoded that feature (now using a temp hook).
There you go...

EDIT :
A few precisions if you intend to use some temp hooks for returning :
When asmdream exits normally (no goto), it is done with the regular _jforcecmdnochar.
When asmdream exits with goto, it is also done with _jforcecmdnochar, but before that, hook $9B88 is installed (which automatically opens up the prgm editor at the homescreen).
Note that the previous hook is automatically restored (if any).
That means you will probably need 1 hook for each case.
For the goto case, i thought maybe of a hook that checks for [2nd]+[quit], but there is still a very slim chance the user exits the prgm editor with [2nd]+[off]...

I haven't added in any of the shell parts that I wanted to add in, yet, but I did rewrite parts of the graphics code. I am emulating the screen with a different approach and that allowed me to make a slightly faster LCD update routine and a much faster clipped sprite routine. The end product is about a 23% speed boost in my pong example

Also, going through the code, I think I can try to give it much better organisation and possibly reduce the size and increase the speed. It is quite a mess at the moment.