http://www.omnimaga.org/index.php?action=downloads;sa=view;down=624

Axe Memory Mapper v1.1 allows you to look at every address (0000 through FFFF) of your calculator's RAM and their contents. (Like Calcsys' hex editor, but more Axe user friendly)-The useful part is that it shows you the offset of the bytes you are viewing from common saferam areas.

It shows both the decimal and hex value of the highlighted byte, along with the binary translation and the 8x8 sprite of the 8 bytes following the highlighted position. The pointer is displayed in decimal, hex, and L*+offset format. Navigation features include membank switching, a goto function, and a comprehensive search function for programs/appvars as well as strings of up to 8 bytes in ASCII or hex. See readme for full features list and controls

Here are some of the sprites that need to be completed for Ash:Phoenix  . I would greatly appreciate any help anyone could offer
Normally I like to sprite everything myself, but as you will soon see, the sheer magnitude of the amount of pixel art that needs to be

done makes this rather impractical. This list will be edited as time goes on; as more tiles arise and other tiles are finished.

Everything is in 3lvl grayscale.

As a side project, I was thinking about creating a utility for Axe programmers that would enable you to run your source code through the program, and it would spit out:

The commands and the number of times they appear in your program.
The variables you use (and how many times you use them)
The amount of data in the program

and possibly....(using Runer112's documentation on Axe command speed/sizes) the iterations per second of loops in your program. (This could get messy, I think maybe I would have the user instead mark off a section of code with special comments and then Axalyzer would return the iterations per second (and Tstates) of that section perhaps)

I have a basic idea of how the program will work and read tokens and stuff: it's a variation on the NPC system of Ash:Phoenix actually

Yeah so I'm just starting a topic to gather my thoughts...and you can discuss/request features here.

For this one too, play the Lavender town theme while reading:




"I’m what you could call a collector of bootleg Pokémon games. Pokémon Diamond & Jade, Chaos Black, etc. It’s amazing the frequency with which you can find them at pawnshops, Goodwill, flea markets, and such.

They’re generally fun; even if they are unplayable (which they often are), the mistranslations and poor quality make them unintentionally humorous.

I’ve been able to find most of the ones that I’ve played online, but there’s one that I haven’t seen any mention of. I bought it at a flea market about five years ago.



Unfortunately, when I moved two years ago, I lost the game, so I can’t provide you with screencaps. Sorry.

The game started with the familiar Nidorino and Gengar intro of Red and Blue version. However, the “press start” screen had been altered. Red was there, but the Pokémon did not cycle through. It also said “Black Version” under the Pokémon logo.

Upon selecting “New Game”, the game started the Professor Oak speech, and it quickly became evident that the game was essentially Pokémon Red Version.

After selecting your starter, if you looked at your Pokémon, you had in addition to Bulbasaur, Charmander, or Squirtle another Pokémon — “GHOST”.

The Pokémon was level 1. It had the sprite of the Ghosts that are encountered in Lavender Tower before obtaining the Sliph Scope. It had one attack — “Curse”. I know that there is a real move named curse, but the attack did not exist in Generation 1, so it appears it was hacked in.

Defending Pokémon were unable to attack Ghost — it would only say they were too scared to move. When the move “Curse” was used in battle, the screen would cut to black. The cry of the defending Pokémon would be heard, but it was distorted, played at a much lower pitch than normal. The battle screen would then reappear, and the defending Pokémon would be gone. If used in a battle against a trainer, when the Pokéballs representing their Pokemon would appear in the corner, they would have one fewer Pokéball.

The implication was that the Pokémon died.

What’s even stranger is that after defeating a trainer and seeing “Red received $200 for winning!”, the battle commands would appear again. If you selected “Run”, the battle would end as it normally does. You could also select Curse. If you did, upon returning to the overworld, the trainer’s sprite would be gone. After leaving and reentering the area, the spot [where] the trainer had been would be replaced with a tombstone like the ones at Lavender Tower.

The move “Curse” was not usable in all instances. It would fail against Ghost Pokémon. It would also fail if it was used against trainers that you would have to face again, such as your Rival or Giovanni. It was usable in your final battle against them, however.

I figured this was the gimmick of the game, allowing you to use the previously uncapturable Ghosts. And because Curse made the game so easy, I essentially used it throughout the whole adventure.

The game changed quite a bit after defeating the Elite Four. After viewing the Hall of Fame, which consisted of Ghost and a couple of very under leveled Pokémon, the screen cut to black. A box appeared with the words “Many years later…” It then cut to Lavender Tower. An old man was standing, looking at tombstones. You then realized this man was your character.

The man moved at only half of your normal walking speed. You no longer had any Pokémon with you, not even Ghost, who up to this point had been impossible to remove from your party through depositing in the PC. The overworld was entirely empty — there were no people at all. There were still the tombstones of the trainers that you used Curse on, however.

 

You could go pretty much anywhere in the overworld at this point, though your movement was limited by the fact that you had no Pokémon to use HMs. And regardless of where you went, the music of Lavender Town continued on an infinite loop. After wandering for a while, I found that if you go through Diglett’s Cave, one of the cuttable bushes that normally blocks the path on the other side is no longer there, allowing you to advance and return to Pallet Town.

Upon entering your house and going to the exact tile where you start the game, the screen would cut to black.

Then a sprite of a Caterpie appeared. It was the replaced by a Weedle, and then a Pidgey. I soon realized, as the Pokémon progressed from Rattata to Blastoise, that these were all of the Pokémon that I had used Curse on.

After the end of my Rival’s team, a Youngster appeared, and then a Bug Catcher. These were the trainers I had Cursed.

Throughout the sequence, the Lavender Town music was playing, but it was slowly decreasing in pitch. By the time your Rival appeared on screen, it was little more than a demonic rumble.

Another cut to black. A few moments later, the battle screen suddenly appeared — your trainer sprite was now that of an old man, the same one as the one who teaches you how to catch Pokémon in Viridian City.

Ghost appeared on the other side, along with the words “GHOST wants to fight!”.

You couldn’t use items, and you had no Pokémon. If you tried to run, you couldn’t escape. The only option was “FIGHT”.

Using fight would immediately cause you to use Struggle, which didn’t affect Ghost but did chip off a bit of your own HP. When it was Ghost’s turn to attack, it would simply say “…” Eventually, when your HP reached a critical point, Ghost would finally use Curse.

The screen cut to black a final time.

Regardless of the buttons you pressed, you were permanently stuck in this black screen. At this point, the only thing you could do was turn the Game Boy off. When you played again, “NEW GAME” was the only option — the game had erased the file.

I played through this hacked game many, many times, and every time the game ended with this sequence. Several times I didn’t use Ghost at all, though he was impossible to remove from the party. In these cases, it did not show any Pokémon or trainers and simply cut to the climactic “battle with Ghost.

I’m not sure what the motives were behind the creator of this hack. It wasn’t widely distributed, so it was presumably not for monetary gain. It was very well done for a bootleg.

It seems he was trying to convey a message; though it seems I am the sole receiver of this message. I’m not entirely sure what it was — the inevitability of death? The pointlessness of it? Perhaps he was simply trying to morbidly inject death and darkness into a children’s game. Regardless, this children’s game has made me think, and it has made me cry."

I'm sure this has been asked before..but...

Nooby question: How do you sign apps ?  I downloaded wabbitsign but I can't figure out how it works. (Specifically Axe generated appas that are already in .8xk format, not in .bin or .asm format) I don't want to use ducksign (because it doesn't get rid of the 16use limit, right?)

Optimization Compilation: The Quick & Dirty Guide to Optimizing in Axe

This is intended to be a guide for every Axe programmer with general optimization  

For demonstration purposes, I will always use the variable A. Of course, you can do these optimizations with any other var or memory address. Most opts are either in code boxes or on bullet points.

Part I: The BASIC Stuff
Many of the tricks we've learned from BASIC can also be applied to Axe. However, not all of them are applicable. Let's take a look:
Boolean Stuff: As with BASIC, we can optimize If VAR?0 to simply If VAR
However, be warned that this may not always work with compound statements (If A and B). Because the logic operators are bitwise operations, the statement "2 or 0" will return 0. This means that unless you are certain that A and B are always boolean values (1 or 0), you need to do If A?0 and (B?0) instead of If A and B

Another random thing is to ALWAYS CLOSE YOUR QUOTES AND PARENTHESES. Unlike BASIC, the store arrow does not close them for you. Unlike BASIC, leaving them out does NOT improve the size of your program; it is unrelated to optimization but I figured I'd just stick it here since it is a good coding habit and makes code more readable.

Pre-evaluating expressions: Especially in games that heavily reference arrays throughout a section of code, it is often good both for speed and memory to pre-evaluate expressions that do not change throughout the loop. Look at this code for drawing a scrolling 16x16 tilemapper with X and Y positions in pixels: For(A,0,11)
For(B,0,7)
If {Y/8+B*16+(X/8)+A+L1}
Pt-On(A*8-(X^8),B*8-(Y^8),{Y/8+B*32+(X/8)+A}*8+Pic0
End
End
EndThere is a HUGE speed gain from simply preevaluating some of the expressions before entering the loop:
X/8->E
Y/8->F
X^8->I
Y^8->J
For(A,0,7)
For(B,0,11)
If {F+B*16+E+A+L1}->C
Pt-On(A*8-I,B*8-J,C*8+Pic0
End
End
End
Pixel Testing

Pixel testing can be a mean and nasty cycle stealer from many programs. But never fear, it can be optimized...a lot. Remember that we have access to the screen buffer in L6.

If you are pixel testing a constant pixel, like pxl-Test(20,20), you can more than halve the speed of this command with the following optimization: {20*12+L6+2}^^re4 This optimization relies on the fact that the numbers can basically be pre-computed: use the following formula to derive the numbers you should use: {Y*12+L6+(X/8)}e(X^8) So for another example, the command pxl-Test(8,1) becomes {12+L6}e1.

The speed gain from this is so great that you can even still save (although not as much) even with a variable Y value. How you treat the constant X value remains the same as before, but simply substitute in your variable Y value in the above code. So for example, pxl-Test(31,Y) becomes {Y*12+L6+3}e7.



Part II: General
Equality Checks:
If A=EXP optimizes to !If A xor EXPNote that you should use !If A – EXP if it is an optimized addition/subtraction (See Optimized Math)
If A=EXP and (B=EXP) optimizes to !If A-EXP + (B-EXP) where + is the 16bit 'or' operator.
Now, if you are checking the same variable for more than one possible expression, then it yields a greater optimization to do this:
If A=EXP1 or (A=EXP2) to If inData(A,Data(EXP1,EXP2,0)) You just have to make sure that you take care of the 0 case first, since this will return a non-zero value if the variable=0 Also, as Quigibo pointed out, this only works with constant, 8bit values.

Simple Math Stuff

• If you can, always put the constants last in your expressions:CONST+A to A+CONST
• Use two byte vars over one byte vars or nibbles if you can afford the free RAM; it will be slightly smaller and faster. (but only by a little)
  Note: As far as I can tell the speed difference is negligible. Unless you’re raycasting or something
• Avoid parentheses as much as possible when writing expressions. Use Axe's left-to-right order of operations to your advantage. This is in the documentation.
• A quick way to determine the sign of a value (better than >>0) is EXP//32768 It will return -1 if the value is negative, and 0 if the value is 0 or positive
• The new ++ -- arguments are a smaller and faster way of doing {EXP}+/-1->{EXP}. In the old form, EXP had to be evaluated twice. Now, it only needs to be evaluated once.
• One random trick is if you need to initialize a 1-byte variable to 0, the line and 0->{EXP} will be smaller than 0->{EXP}

Optimized Math

Some operations are hard-coded optimized versions that don’t use the usual arithmetic operations. A complete list of them can be found in the following spoiler which I stole from Runer112’s handy list of command speed/size

Part III: "HL is the Ans of Axe" -Runer112

Like BASIC, Axe also has an Ans-counterpart, a register called HL. It is written to every time you "load" an expression or constant. This yields a multitude of
small optimizations:
-Duplicate Arguments: Text(0,0,PTR) optimizes to Text(0,,PTR)See how that works? When Axe goes to parse the second argument of Text(, it would normally load the second argument into HL and then use that as the Y position of the text. However, in the optimized piece it doesn't find anything to load for the second argument, so it just uses what was already in HL, namely, 0.

This, extended, yields further optimization opportunities:
-More Omitted Arguments: Not only does loading arguments in commands write to HL, so does loading arguments in normal math and control structure operations. This means that we can omit lots of things, saving more space and speed. For example...
If A>3: 1?B becomes If A>3: ?BBut wait! What if you want to use this optimization on an equality check? Normally, If A=1:?B would work, but if we wanted to optimize the equality check as well, it doesn't work quite right. !If A-1 returns zero if true (or rather, if false), so you might then think that it's probably best to skip this particular optimization and go !If A-1:1?B However, although it may seem counterintuitive, the following is actually smaller and faster: !If A-1:+1?B Similarly, If EXP: -1?B:End(with a minus sign) is preferable to If EXP:0?B:End

0?B: 0?A becomes 0?B?Anote: When initializing variables that are 2 or less apart, it also yields further optimization to do this:0?A: 1?B: 3?C to 0?A+1?B+2?CAn example of HL abuse in a subroutine:
sub(LBL,EXP).....Lbl LBL: EXP*2?{L1} to sub(LBL,EXP)....Lbl LBL:*2?{L1]
-Here's another abuse of HL, creating the fastest and smallest loop structure (by Runer 112)

It will execute the loop n times, with A starting at n-1 and decreasing down to 0:

Code: [Select]

n
While
  -1?A
  ;Code
  A
End

Moving around a sprite
Check this out: again courtesy of Runer112: (comments by me)
:.SMILE
:[004466000000817E]->Pic1
:DiagnosticOff
:0->X->Y
:Repeat getkey(15)
:ClrDraw
:getKey(3)-getKey(2)+X //check getkeys for X. But we're not going to store the value just yet...
:!If +1                         //First, check if X is negative one; that is, we'll check if X+1=0
:+1                             //if so, add one to make the value in HL 1 (!If statements return 0 if true)
:End
:-1                             //subtract 1 since we added 1 earlier
:Pt-On(min(,88)?X,getKey(1)-getKey(4)+Y+(=?1)min(,56)?Y,Pic1)    //now we'll use the smallest value of either HL or 88 as the X position. For Y, we'll first handle keypresses, then add 1 (the boolean value of y=-1) if Y=-1. Then we'll use the smallest value of either HL or 56 as the Y position.
:DispGraph
:End
I can't post every possible abuse of HL here: there are so many ways to use it. Study these examples to see how they work and you can apply it in your own programs.


Much of HL abuse has been obsoleted by Axe's peephole optimizer. However, you can still make use of some of these tricks. While the weird syntax is not always necessary, remember to arrange your code and operations such that the peephole optimizer can target it. I left the section somewhat intact so that you can look through it to understand the concept; the optimizer is useless if your code isn’t written intelligently.

Part IV: Subroutines
Subroutines probably are capable of saving the most space than any other type of optimization. And they are easy to use, too. There are only a couple rules of thumb to follow:
1. If you are rewriting a section of code more than once (and it is more than just one command), best put it into a subroutine.
2. If you aren't, then don't put it in a subroutine.

Routine calls are around 3-5 bytes, and an additional 3 bytes for every argument you load. Using the recursive subroutine feature that saves your arguments (sub(LBL^r....) costs you 15 bytes per argument.

Tail Call Optimization
 This is lesser known and lesser used, but it is still worth sticking here I guess: If you are calling subroutines from a subroutine as the last line, then you can use a process known as Tail Call Optimization to change this: Lbl A : Stuff : sub(B) : Return to this: Lbl A: Stuff : Goto B The Return is not needed because you end up "stealing" subroutine B's return instead of having to return to A and then return again to the main program.

Part V: Speed over Size
These are all optimizations for aggressive speed gain at the expense of size.

Short Circuit Evaluation:
In most cases, it yields a (rather impressive) speed gain to change If EXP1 and EXP2 to If EXP1 : If EXP2 Make sure to have EXP1 (the outside If block) be the expression that is less likely to be true to gain the most speed.

Factoring Constants (and powers of 2); When multiplying and dividing by multiples of powers of 2, it yields an optimization to factor the number first. EXP*96 to EXP*32*3

With powers of two, this is only advantageous with *64 and *128 (Check the auto-optimizations list for the list of numbers that this applies to).

Part VI: Miscellaneous
All the stuff I couldn't fit into another category...

• If you need to draw horizontal or vertical lines, use the Rect() function with a width or height of 1 instead: Line(0,,20,0) to Rect(0,,20,1) This improves both speed and size
• Use ElseIf and DS<( if you can. That's why they're there. They are surprisingly useful.
• The Text() and Bitmap() commands are slow because they are TI's routines. Avoid them if possible. (I know, it's hard not to use Text(...but do your best ).
• Note about the Fill() command: If you are initializing less than 10 bytes of data, it is better to just use ->{}^r 5 times instead.

Also, a little-known fact regarding printing text at constant coordinates:
[/list]

Code: [Select]

.Coordinate=Y*256+X
Text(30*256+20)
Text "Stuff"
Is 7 bytes smaller than:

Code: [Select]

Text(20,30,"Stuff")
The same applies for text drawn to the home screen:

Code: [Select]

.Coordinate=X*256+Y
Output(20*256+30)
Disp "Stuff"
Is smaller than:

Code: [Select]

Output(20,30,"Stuff")


By even more, 8 bytes.

• The new DispGraphClrDraw command is the same as DispGraph:ClrDraw but twice as fast. Use it.

However, remember each new command you use in Axe creates its own subroutine in your program. Thus, (for size reasons) it’s best to avoid using Rect if you've already used Line and Pt-On instead of Pt-Change, (and preinvert the sprite).

One major optimization that usually gets ignored is recycling large axe commands.  Axe is not like BASIC and so each command needs its own subroutine to add to your program.  For instance, lets say you use Pt-On() and Pt-Mask() in your code.  Each one has to bring its own 100+ byte subroutine into your program.  But you can probably get away with having just a Pt-Mask routine, recycling it to act like Pt-On by simply adding a 2nd layer to your sprite which is only 8 bytes extra instead of 100ish.  Or you could do the opposite too and only have Pt-On() and Pt-Change() to manually change both buffers at once.  This generally reduces the overall size of the program by a lot when you use the routines only once or very rarely in your code.  And I don't mean calling it rarely, it could be the most used routine in your code, I just mean rarely appears in your source.

...And that's all I've got. Happy coding! Let me know if you have any questions, comments, additions, or corrections and I'll be happy to accommodate you This post will also be updated with any new major optimizations found.

Also special thanks to Quigibo and Runer112 who are the main contributors of all these optimizations

Oh and....666th POST
[/list]

Not exactly an asm question, but I figured I'd have the best audience in this board.

So my question is, how do apps run without using up user RAM? Are they copied to a page reserved for apps? And if so, at what location/address is that?

Which choice would you prefer? discuss, thanks