People generally like using max(K={24,25,26,34 as the de facto arrow key test.

I've put forward K=34 or 2>abs(K-25, which is three bytes less, but it never seems to stick.

Maybe they'd prefer instead to use not(fPart(1806/(5K-127? I think it has enough of a coolness factor.

It's only one byte smaller than the first one, but it's also faster to execute by 12 seconds over 10,000 iterations.

(It's still slower than the second one by 20 seconds over the same number of passes.)

I won't post the Mathematica code that I whipped up to find this, but it did involve PrimeQ. Hooray PrimeQ!

Very nice, Weregoose! I can't say I've ever used an arrow-key getkey loop; I usually just loop until any key and then apply the standard two-line code to increment or decrement the x and y variables based on the arrow keys pressed, also checking what happened with enter and escape type keys simultaneously.

Do pardon my noob-likeness.

What does an arrow-key getkey loop look like? I've never seen or used one so I don't exactly know how they work.

the classic arrow movement code being used often is generally

X-(K=24)+(K=26->X
Y-(K=25)+(K=34->X

Or even less optimized

If K=24
X-1->X
If K=26
X+1->X
If K=25
Y-1->Y
If K=34
Y+1->Y

Gotcha. Sorry, it took a minute but I understand how that works. I didn't quite break it down in my head before I kinda just stared at it.

And weregoose's check would just be slapped on an IF statement before reassigning the coordinate variables?

EDIT
Example:

Code:

Maybe something like this, Swivelgames (to avoid that DISGUSTING abuse of labels):


Code:

Haha, I never was very good at optimizing source

Thanks, Kerm! XD

No worries. I'm sure that Weregoose could still own that code in some strange, eyelash-bending way. When in doubt, avoid Labels/

Probably. "eyelash-bending"?



Btw, Kerm, your code would show a blank screen until the user pressed a button.

Good catch.


Code:

Sorry if this seems obvious, but I still haven't figured out which one I should use: using the overall loop to check for getKeys, as in


Code:

or having a loop for just the getKey, as below?


Code:

I don't mean with this code specifically, but in general (e.g. in a platform game, when testing for keypresses to move the character).

Well, generally the first one is better, because the program will be that much faster to respond once you actually press a key (for example, if you press a key when it's at the "I-(K=25)+(K=34->I " line in the first program, it will have to loop all the way around to If getKey again before it starts processing the key). Also, that first chunk of code has a bug, it should be If K (or If Ans), not If getKey. In the second piece of code, you're running a much tighter loop around the getKey, so it will respond faster when you begin pressing keys. Of course, if you were constantly holding down keys, the second program would be ever so slightly slower, but that's not generally the case. If you have a more complex game where other things are moving and changing while the getKey loop is running, it gets somewhat more complicated, but the same rules of thumb still hold.

use multiple loops if you're looking for speed (which is usually more important than the relatively minor increase in file size).


Code:

Even better than using multiple while loops is to just use a Repeat loop with Ans as the condition. I have not done any calculator programming in a while, but I am fairly certain using Ans is faster than storing to a variable, also. Could anyone confirm this?


Code:

Well, I suppose that could make sense. But if you're just going to use the variable later, is it not faster to store it in the loop instead of calling it twice (one inside the loop, and one after)?

I still think that 2 loops would be faster, especially in situations like text entry. The idea is that rather than wait for the next keypress, assume that the user will press the next key almost instantly.



Not really, because then while in the getkey loop, the calculator will be storing a value to K repeatedly, making it ever so slightly less responsive. You'll notice this especially if you have something else going on in the loop.

For example, if I put a time limit on it, the first example (which uses Ans) will be significantly faster/more responsive than the second.


Code:


Code:

If you don't need the key value at all, such as for a "press any key to continue" screen

Code:

Most definitely, elfy. I've used that plenty of times before. Works perfectly

Harq, gotcha! That's one thing I was thinking about but I wasn't sure how greatly that affected it. Makes sense, though

So if I were to make a simple example out of an X moving about the screen, this is what I think you mean:


Code:


Never thought of that. I'll try it.

EDIT: WOW THAT IS FAST. How did I never learn that?

Shouldn't it be this? It doesn't look like there is any way that K would become 0 in that second inner loop.


Code: