I know that everyone is going to be sad to see this, and I can't tell you how sorry I am.  But my laptop was stolen.  All my current work--except backups--were on my laptop.  I am afraid that I will not be able to finish Seek and Destroy or Correlation, not by myself at the very least.  This is because I lost several weeks of work, and I am not persistent enough to redo everything I had previously fixed.

I promise you that THIS IS NOT THE END of my contributions to this website.  I have a small project I plan to work on, codenamed Crabcake.  It's a secret one, but I'll let you know what it is in time.  Furthermore, I will be touching up my ASM lessons to make them error-free and easier for people to get help with.  An Xlib version of Calsiah is not unreasonable either.

Also, I will heavily comment source code for Seek and Destroy and Correlation Beta, and release the source code to people on this website.  If you want to work on it, be my guest.  But unless my laptop magically returns, I am not able to continue working on them on my own.

Thank you all for understanding, and I am very sorry that it has come to this.  Runer112, Iambian, Cooliojaz, Matthias and Buckeye Dude, thank you all for the time you spent to help me, and I am sorry that you spent time and hard work giving to projects that just halted.  I can't tell you how upset that I asked for help only to have it go down the tubes

In a further attempt to speed up text-based games, I'm working to add some code for Correlation to compute arguments inside of ln( and e^(.  This will happen only if your arguments are simple, otherwise Ti-Basic will compute the arguments.

By default I'll allowing addition, subtraction, multiplication, variables, abs( substrings, parenthesis, Ans, L1-L6, Martices, strings and temporary strings.  For instance, this would be totally valid:

Output(2M,17-Ans,L1(Ans

I know that these appear a lot in games.  However, is there anything else that you guys use A LOT?  Please vote, and give suggestions of your own if you think of them.

Any guesses (or facts) as to the fastest Ti-Basic command to run?  My guess is Lbl __

Thanks to Runer112 and calc84maniac, my new Output( routine displays characters at speeds TI can't even begin to compete with.  Yet even with their horrible Output( code, they beat me by two seconds.

My guess is that if I return nz with the result of my computation in OP1, there's a HUGE amount of code the calculator goes through before continuing to parse the Ti-Basic program.  

Is there any routine or code or something to speed up the process, that is, by avoiding Ti's "parser-is-done-go-to-next-line" code?  Unfortunately, reset numOP1,(iy+ParsFlag2) is not an option for me.

I want to work on a timer that triggers interrupts about every 1/100000 of a second.  I know how to set the timer speed, so suppose I have the counter set to 1 and divisor set to CPU speed / 16 (That is, 937500 HZ in fast mode).

But I'm a little lost for the rest of the steps.  What do I need to do to make sure that my interrupt routine will always run every 1/100000 of a second?  Assume the routine starts at Start_Routine, and the routine ends at End_Routine.


Start_Routine:

;Code
;Code
;Code

End_Routine

Correlation is going under some major tire-changing in terms of homescreen-game designing.  If you are writing a game that uses the homescreen it is very important that you take note of the changes being made.

First of all, I apologize to those of you who used ln( only to find that the parameters were mixed up.  That bug has been fixed, and I'll release the new version when I can.

Secondly, in an effort to make Correlation homescreen games faster than their pure Ti-Basic counterparts, the following modes will, from this point on, NOT be available for designing homescreen games:

* XOR, OR, AND, Mask sprites
* Word Wrap
* Lowercase Letters
* Customized Windows

If you want the above features, you should display a 6x8 font with e^(.

The following features will still be available for homescreen games:

* Wrap Mode
* Map Mode
* Clip Mode
* Animated Text
* Negative Coordinates
* Run Indicator On / Off


If you are converting an old TI-Basic game that uses the homescreen, you need not worry about removed features.

I am sorry for any inconviences.  And as always, thank you for being patient as I try to make Correlation the best it can be.

Is there a B_CALL routine or a function someone wrote to relocate a program in RAM?

For example, say I have these five variables in RAM:

A  (located at $A000)
C
[D]
RUNNER
DOORS

Is there a routine that exists to move pgrmRUNNER to $A000 while shifting the other variables further down into RAM?

RUNNER
A
C
[D]
DOORS

For those of you annoyed by multiple-page applications, I know that some of you are probably wondering why you need to go through all this trouble when you have to write a big application.  Well, here's the deal. 

There's at least 32 KB of RAM (sometimes more) on the Ti-83+/Ti-84+, and there's at least 160 KB of user ROM on the calculator (again, sometimes more.)  However, The Ti-83+ and Ti-84+ can work with only 64 KB of memory at a time.  This can be ROM or RAM, but only up to 64 KB at once.

There are 16 KB of ROM that the calculator must ALWAYS have access to because of the operating system.  So the 64 KB of memory must always include these 16 KB.  That means there are only 48 KB of memory left for reading stuff all at once.

For the average user, the calculator must ALWAYS have access to 32 KB of RAM.  8 KB are needed by the operating system, and of course, 24 KB are available for the user.  So 48 - 32 = 16 KB left.

That's only 16 KB left to access all the rest of the ROM on your calculator--all 160 KBs.  So this is divided into ten 16 KB sections (or pages), and the calculator can only read from or write to one section at a time--IT CANNOT READ TWO SECTIONS AT ONCE!  With a one page application, the calculator only needs to look at one page.  But with a bigger application, there's more than 16 KB to work with, and again, the calculator can't read the whole application at once.  So it needs to switch between different sections.