No, it isn't. Rect is 112 bytes large in total. The routines are only added to your program if they occur at least once in the source. So basically using two times Pt-Off will only add one Pt-Off to the program, and every times you need it, the function is called (like a subroutine).
You can save bytes by using only one type of routines (e.g. all Pt-Off or all Rect) instead of having different.

Writing some program in axe, I needed a fast vertical line routine to substitute this:

The routine should draw a vertical, at y=22 centered line expanding E pixels up and down to a total length of E*2+1 in column X.
This is my idea:


I hope somebody can help me finding the error, I'm stuck

Edit: It doesn't crash immediately, it does it when the program returns. The error is before lineloop I think

They are the same, just a different header I think. Both is z80 asm, but Ion gives compatibility to other shells.

It's fun to play against your neighbors in our math course

Things planned atm:

• Landmines as another powerup

The last screeny should be it except for the machine guns.

I think DJ meant the diagonal walls. Would it be faster if you could reduce your algorithm for only perpendicular walls?

I couldn't do much on this, I've been working on another "scientific useful" project for some time now, but nonetheless here is an update:  

Added:

• Automatic Archive/Unarchive safe file (no big deal, but was missing before)

Changed:

• Fixed phantom grenades / grenades exploding much too late / grenades disappearing (occurred when both players throw a grenade the same time)
• Downgraded the machine gun: only 9 shots, fire rate reduced from 200% to 150% (recommended by a friend)
• Reduced grenade timer by 20% (explodes after 80 frames)

Since it isn't an update with changed graphics / major changes on game mechanics, I won't add a screeny.

Download:

Could be better, but it's enough for me

If you have a second memory location to store the sorted array, this might be useful:

Pseudocode:

Awesome! Text input and custom buttons! Can't wait to try it out

What flicker? There shouldn't be any flickering except when your loop is two slow. Can you post your code?

Yeah, remove the dots (you can add other code in there, like movement)
Make sure to initialize X and Y or replace them with constants.

Pt-Off is slightly faster than Pt-On (when X is a multiple of 8 ), so that's why I used that for the example. But doesn't really matter.

Hex:
[FFFFC3C3C3C3FFFF] for front buffer
[FF81BDA5A5BD81FF] for back buffer

That should be a neat little box with all colors!

Here is a more in-depth how-to:

The TI-83 series doesn't support grayscale natively, but axe has some functions to alternate checkerboard patters, but that is so fast (and the screen is blurry too), so that it looks for the human eye like it is gray.

Because one buffer can only store data for two colors, you'll need two buffers for 2² = 4 level grayscale. Depending on the pixel combination of both buffers you can get black, dark gray, light gray and white. The easiest way (for me) to remember the combinations is, that the main buffer has a higher "priority" or "level" than the back buffer, so if you change a pixel on the front buffer, it'll cause the result to change more than when you do it on the back buffer.
Here are the combinations for 4 level grayscale:

Front buffer:  Back buffer: Result:

off off white

off on light gray

on off dark gray

on on black

In order to display a 4-level sprite, you have to create two 8x8 sprites, one for the front buffer, one for the back buffer. With the table above as reference, you can make your 2 sprites out of the one desired gray sprite.

To display them, you need two Pt-commands:


For 3 level grayscale you need DispGraph^r, for 4-level you need ^rr. Same when you use the DispGraphClrDraw.

Every time the DspGraph^rr is passed, the checkerboard pattern is changed.

That should be it.

For "+" always, but for the multiplying I have to admit that runer's right. Take the bitwise "and" when you compare booleans.


Note:
"2 and 1" would be true in boolean, but you have to use multiplication because the bitwise "and" would return zero.

Whoa, didn't know that! 

Stupid mistake 

And for the "3"-key mistake: I just copied from the source, but you can blame me for not checking it

Thanks runer, you make me always learn new things!