Seems great and even has some planned features I never used like the Documentation Generation...

A feature more time saving and I don't see much is after you compile, it directly send the file to emulator and set breakpoints. I think buckeye's IDE has that but I never tested. Maybe is hour for me to check it. Hopefully you have it planned, too.

Omnimaga still grows, and now making records with users.
I am there.

I commented even more the source code and optimized further in size. (I think there is still some ways)
I cleaned the source, added the defines and final tested.

Now write the readme, do the batch files to compile , decide the program names and upload.

The interesting now would be someone help me debug the TI-83 build. For the TI-83 there is few documentation on bcalls, but I will try to compare to TI-83+ to see what differences come out. Debugging on calculator and watch the entire bcall disassembly is a thing I won't do. Maybe it is not worth to put on TI-83 nowadays.

That is a nice trick/exploit in tower defence games and general RTS.
In map making may also mean more eye candies.

Kidding, the game design is very good I loved the menu to select buildings. It remembers some old RTS I played like Metal Marines.

Mhmm strange I wonder if someone could help

Hopefully it can't repeat the error.
I will try to mess a bit with code to see if it triggers. It is probably because between assembles and debugs there was one that deleted equation vars without recreating them with 0 bytes. The TI-OS always assumes graphics equations are created and if aren't the SDK warns it will crash.
EDIT: nevermind, it crashes but doesn't give that odd screen.

If this contributes to on topic:

Welcome! Have a good stay.

Maybe this could be integrated in future Celtic III versions too? In hook form, it would eliminate the slowness of the Asm() command and be blazing fast. Celtic III games could run this when exiting so all unused vars are cleared

Sure. Cool idea. The code is to be used. But the 2 uses I though were:
-use for quick deletion of the variables (and small oncalc)
-games like Escheron if at first attempt don't have enough free memory, can free sometimes enough with this routine (optionally prompting the user)

And UPDATE!

I did it! Only 135 bytes of assembly! Deletes everything I planned: Real and complex numbers, real and complex lists, matrices and all graphical equations. Preserves ALL of them if archived.
I will try to come with ClearEntries in assembly but I don't know the bcall. Maybe I can access it through TI-BASIC interpreter.
Who wants the program to delete GDBs, Strings and Pics? (strings and pictures sometimes hold important data)
And maybe even delete LRESID (a list made by TIOS) and other custom lists (LL1,LL2,LA,etc..)?
Yes, I am happy with the code. The way the subroutine is reused is a bit smart.

I will polish the source code, divide into 2 programs (one just for A-Z and theta vars) and another for all. Then I release in ticalc.

This code and program is beta. Due to the weirdest and most artistic bug I provoked and I can't replicate and don't have an heck of a idea why occurred. TI-OS was ok until I entered equation editor.
;Clean Up Basic Variables
;all numbers A-Z /theta/, lists L1 to L6, matrices [A]-[Z], Ans, graphics functions
cleanupBASICvars:
bcall(_CleanAll) ; delete all temp variables
bcall(_OP1Set0) ; This will set OP1 to 0,$80,0,0,0,0,0,0,0
bcall(_StoAns) ; Ans will be equal 0 (Ans can be a huge list or string and take huge space)

; b_call(_ZeroOP1) ; OP1 needs to be zeroed or it will not work for some reason
ld ix,OP1 ; the pointer
ld d,0 ; a flag for activate equ create with 0 bytes (needed to not crash TI-OS)
; it is preserved in deletevars2
ld c,RealObj
ld a,tA ; (OP1+0) = $00 = RealObj, already
ld b,tTheta+1
call deletevars2
ld c,CplxObj
ld a,tA
; ld b,tTheta+1 ; it was preserved!
call deletevars2

;these vars have 3 bytes, so a smart solution is coded
inc ix
ld e,RealObj
ld c,tVarLst
ld a,tL1
ld b,tL6+1
call deletevars3
ld e,CListObj
; ld c,tVarLst ; it was preserved!
ld a,tL1
; ld b,tL6+1 ; it was preserved!
call deletevars3
ld e,MatObj
ld c,tVarMat
ld a,tMatA
ld b,tMatJ+1
call deletevars3

ld d,1 ; activate bcall(_Create0Equ)
ld e,EquObj
ld c,tVarEqu
ld a,tY1
ld b,tY0+1
call deletevars3
; ld e,EquObj
; ld c,tVarEqu ; it was preserved!
ld a,tX1T ;\tX1T to tX6T
ld b,tY6T+1 ;/tY1T to tY6T
call deletevars2
; ld e,EquObj
; ld c,tVarEqu ; it was preserved!
ld a,tR1
ld b,tR6+1
call deletevars2
; ld e,EquObj
; ld c,tVarEqu ; it was preserved!
ld a,tun
ld b,twn+1
;fall back

deletevars3:
ld (ix-1),e
deletevars2:
ld (ix+0),c
deletevarloop:
push af
push bc
push de
ld (ix+1),a
bcall(_FindSym) ; look up
jr c,cdelarc ; if doesn't exist, then skip
inc b ;\
dec b ; | if b!=0 (it is in flash), then skip
jr nz,cdelarc ;/
bcall(_DelVar) ; delete variable
cdelarc:
pop de
inc d
dec d
jr z,notequvar
bcall(_Create0Equ) ;OP1 destroyed, OP4 has variable name
bcall(_OP4toOP1) ;restore OP1 ^^
notequvar:
pop bc
pop af
inc a
cp b
jr nz,deletevarloop
ret

cleanupBASICvarsend:

 .echo "code and data size: ",cleanupBASICvarsend-cleanupBASICvars
;

Enjoy!
EDIT: finally uploaded files! I will update first topic when I finish some things...
EDIT2: I assembled for TI-83 (Regular) too! It seems the bcalls exist for it.
Now how the heck I test it in emulator? I have to install a shell... Anyone willing to give the steps or tutorial? Or there is some wacky exploit to run easily?
EDIT3: Used Venus shell and I did it. My program does nothing on TI-83. Either delete variables or crash TI-OS. Nothing I can see. Unless someone request I will not debug soon.

interesting, I wonder how fast will it be compared to using several dozens of delvar commands, since it is actually larger than those delvar commands? (81 bytes total for all 27 vars). Does it also delete archived vars?

It is always faster than TI-BASIC because of the interpreting overhead but it shouldn't be a hell lot faster. The routines (bcalls) used are the same...

No, it don't delete archived but if you want I can very easily change that. Just use bcall(_DelVarArc) instead of bcall(_DelVar) and comment 3 lines of the check if it is in RAM. (minus 4 bytes, bonus!) I might do that for A-Z variables. Later when I add deletion to lists, matrices, etc I will preserve archived ones because it probably means the user wants to preserve them and not take RAM.

ahh okay. Yeah, it's something about searching through the whole program list to find the asm program, right? So if you have a lot of programs, than it takes long time to load the program... Got it^^

Yes, the bcall to search the list of programs and other variables deserved more speed (MirageOS uses its own routine to that) and moving the programs around in RAM takes some time when you have few RAM left.
When finally the fixed location of the assembly program is free it needs to get copied there.


Clearing Ans is easy. Two bcalls and is done. I know the format of the other variables names. >_> I just need courage to mesh all everything into one loop. (I am trying to reuse DelVar)