So I have been trying to create a walking system that will work for a game I'm creating but I can't get it to work properly and I have tried basically everything I can think of. Basically what I'm trying to do (for the test program) is make it so that it will only move 32 spaces left or right and 24 spaces up and down (basically being restricted to a 24x32 map). I have tried assigning sections of map to not let it move past, I have tried making it so only u can walk over 32 spaces. Nothing has worked. I have gotten close...but not quite.

____↓_________________________________________________________________↓
____0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
→0_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|←
_1_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_2_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_3_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_4_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_5_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_6_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_7_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_8_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_9_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_10|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_11|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_12|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_13|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_14|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_15|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_16|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_17|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_18|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_19|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_20|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_21|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_22|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_23|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
_24|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
→25|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|←
____↑_________________________________________________________________↑
Within those bounds are what I have been able to achieve. The problem though is that it isn't supposed to go into the rows marked with arrows.
Basically, effect wise, what I'm trying to do is that it will wrap around when it gets to row nine and seventeen but stop once you get to row twenty-four. Same basically in the horizontal just stretched out over two screens and only one wrap around. I can post sample code of what I have come up with that has failed (or I can recreate the one that got close), just ask. Thanks for anything

I also hope this makes sense haha.

Edit: so I decided I would post the code up that I just created (I thought this would work...not so much ).

ClrHome
DelVar CDelVar DDelVar EDelVar F1→A
1→B
Repeat K=45
Output(A,B,"_
A+D→A
E+(A=9)-not(A→E
If (A=9) and (not(E) or (E=1))
A-8→A
If (A=9) and (E=2)
A-1→A
If not(A) and ((E=2) or (E=1))
A+8→A
If not(A) and not(E
A+1→A
B+C→B
F+(B=17)-not(B→F
If (B=17) and not(F
B-16→B
If (B=17) and (F=1)
B-1→B
If not(B) and (F=1)
B+16→B
If not(B) and not(F)
B+1→B
Output(A,B,"*
Repeat Ans
getKey→K
End
(K=34)-(K=25→D
(K=26)-(K=24→C
End
Note: I realize this is very unoptimized. I also realize that this could potentially contain errors that I just didn't catch. Cut me some slack though, I created this at three in the freaking morning (I really need to sleep better...)

Anywho, thanks again for any input/help/anything.

So here I am again explaining another bit of code. This time instead of just basic movement though I will be describing a basic way of collision detection.
Note though that this way is not the most efficient way of doing this and this way only works as long as you have a border all around the outside. If there is a gap and you go off screen it will result in ERR:DOMAIN. (Ztrumpet provided some code that adds in the limitations and if I have time (and his permission) I will post an explanation to that too.)

Ok, so to start lets see the code:

PROGRAM:MOVE
"//////////////// //I broke this string down into rows of 16 (the first line is 17 though) so it is easier to follow. It would normally be typed on one line.
/___///___///__/
/_///___///__/_/
/______/////___/
/__///__///__/_/
/_////__//__////
/______________/
////////////////?Str1
Output(1,1,Ans
2?A
2?B
Repeat 0
Output(A,B,"*
Repeat Ans
getKey?K
End
Output(A,B,"_
A+(Ans=34 and sub(str1,16A+B,1)="_")-(Ans=25 and sub(Str1,16A-32+B,1)="_?A
B+(K=26 and sub(Str1,16A-15+B,1)="_")-(K=24 and sub(Str1,16A-17+B,1)="_?B
End
"characters in sting"?Str1: The basic function of this is that we are storing those 128 characters into Str1. What this string is though is our map for what we will be maneuvering around when the program is executed. If you hadn't guessed / are walls while spaces are where you can move. These can be changed for any single slot character (ex. =, +, ?, etc.).
Output(1,1,Ans: Quick explanation of the Output( command. Basically it will display *insert what ever being displayed* in row what ever and how ever many columns out (Output(row number (1-8), column number (1-16), thing to displayed). I explain it much further here. Something I haven't explained though is that if the Output( would (in theory) go offscreen it will wrap around and continue onto the next line. Ok, so the Ans here is the string and it is being placed into row one and in column one too. Since the string is 128 characters long (8*16) it will fill in the whole screen. It will basically display like this:

////////////////
/___///___///__/
/_///___///__/_/
/______/////___/
/__///__///__/_/
/_////__//__////
/______________/
////////////////
2?A: Pretty simple, stores a value of 2 to the variable A.
2?B: Again, simple. Stores a value of 2 to the variable B.
Repeat 0: This starts a Repeat loop. As covered here it is the only post test loop. Meaning, I believe, that it checks the statement before running again and will exit once true. To be perfectly honest I'm not entirely sure why Repeat 0 creates an endless loop like While 1 creates a endless While loop. To me it is saying "repeat until false" ("repeat until true" for While loops) but this doesn't make sense to me. If some one can explain that please tell me and I will change this. Anyways, this just creates an endless loop.
Output(A,B,"*: This displays a * in row two in column two. We are displaying it here because our map from Str1 has a border around the outside parimeter. This * is also our object that will be moving.
Repeat Ans: This loop will repeat until key is pressed (the key code is stored to Ans completing the loop).
getKey?K: The getKey command is what will tell the calc to collect the key code of what ever key is pressed. This value is then stored to the variable K.
End: This ends the loop that needs a key to be pressed.
Output(A,B,"_: This will display a space over the * from the previous Output(. It effectively erases it so you don't have a trail.
Now for the doozies...haha.
A+(Ans=34 and sub(str1,16A+B,1)="_")-(Ans=25 and sub(Str1,16A-32+B,1)="_?A: So I already went over boolean logic/piecewise espressions in here so I'll just do a recap. If the statement is true it returns a 1, if false a 0. The only new part here is and and sub( commands. I will explain these independently.
-and: When this is used in a boolean logic/piecewise function expression it means that both conditions must be true to return a 1. If either or both are not true it will return 0. Pretty easy. An example of this would be:

PROGRAM:TEST
randInt(0,100?A
Disp A>25 and A<75
-sub(: This itself as a few different uses. I'll explain the one most people use it for, then the one that is used here.
--The usual way sub( is used is to display text. It will pull a certain amount of a string and display just that part. The way this works is there are three arguments: the string or list of characters, the point it is starting at, and how many characters it will go out to. For example:

PROGRAM:TEST
"ABCDEFGHIJKL?Str1
sub(Str1,3,8 //The string, starts at the third character, goes eight out.

This will display:
prgmTEST
CDEFGHIJ
Though this command can also be used with things other than just strings. For an example of this we can simply optimize our last code:

PROGRAM:TEST
sub("ABCDEFGHIJKL",3,8
It will display the exact same thing.
--The way it is being used here is similar but not quite. We are looking through the string but not to display. We are testing to see if the space to the left, right, above, or below the character that is moving is either a / (a wall) or a space. If it is a space then it will return 1 (assuming the correct button was pressed). (As a side note. You can replace all the ...="_" with ...?"/".) The position of the character you're looking for is done with math which you should be able to decode. I will explain it if you need me too. Just ask.
--So there is a third use that is new to one of the OS updates. If you use sub( with only one argument it will divide it by a hundred. It might save you a byte or two if you need to do that.
Ok, so in essence this line is just testing for the key pressed and if the space to where your moving is a space or not. Phew. Finally haha.
B+(K=26 and sub(Str1,16A-15+B,1)="_")-(K=24 and sub(Str1,16A-17+B,1)="_?B: This works basically the same way as the above line. Just for left and right instead of up and down (which is what the other does).
End: This completes the endless loop.

Yay, finally done I hope this makes sense and explains some things. I also hope this helps some of you too
If you see any mistakes please let me know and I shall fix them.

Again, this is not the most efficient way of doing this. This is just simply what I had come up with (with some help of the guys over here ) Enjoy

Oh ya, one more thing. I thought I would throw this in here too. If you want to make a little game out of this and have score associated with it you can simply make a few changes to the code:

PROGRAM:MOVE2
"////////////////
/___///___///__/
/_///___///__/_/
/______/////___/
/__///__///__/_/
/_////__//__////
/______________/
////////////////?Str1
Output(1,1,Ans
DelVarC2?A
2?B
Repeat AB=30
Output(A,B,"*
AB?D
Repeat Ans
getKey?K
End
Output(A,B,"_
A+(Ans=34 and sub(str1,16A+B,1)="_")-(Ans=25 and sub(Str1,16A-32+B,1)="_?A
B+(K=26 and sub(Str1,16A-15+B,1)="_")-(K=24 and sub(Str1,16A-17+B,1)="_?B
If AB<D or AB>D
C+1?C
End
ClrHome
Disp "YOUR SCORE:",C
Hopefully this is pretty self-explanitory. The only part of this that is worth explaining, I think, is the Repeat AB=30 part. This basically means when you move to the spot where that statement is true it will exit the loop.

The other day Ztrumpet gave some TI-BASIC code for moving something on the homescreen over at United-TI. I went and fully explained both these sets of code in great detail (the first was more detailed than the second). I'm not sure how many people will find this usefull but if you're new to programming it might help.

I will be working from the top line to the bottom line. Also, please let me know if anything is incorrect, I will change it.

This is the first example he gave:

8→A
ClrHome
Repeat K=105
Output(1,A,"*
Repeat Ans
getKey→K
End
Output(1,A,"_
A+(Ans=26 and A<16)-(Ans=24 and A>1→A
End
8→A: This is pretty easy. You are storing a value of 8 to the variable A.
ClrHome: Again, a pretty easy one. This just erases all the data on the homescreen. So say you have a bunch of equations and answers there from math and then you run that all of it will disappear.

Before ClrHome:
_____521.3144122
prgmBINTODEC____
?100101_________
______________37
prgmDECTOBIN____
A=?764__________
1011111100______
________________

After ClrHome:
________________
________________
________________
________________
________________
________________
________________
________________
Repeat K=105: Well like ztrumpet said earlier Repeat loops are basically loops ran until the condition is met (post-test apparently). Post-test, from what I understand, basically means that it will check to see if the statement is true at the end of the loop, instead of first.
As for the next part of that, the K=105, I think it was basically covered. But as you saw later in the code getkey is getting stored to the variable K. This means that when [Enter] is pressed (the key code for [Enter] is 105 (without using other things, but that's more advanced stuff I don't even understand currently)) the loop will finish and finish the program (since nothing is after the loop).
Output(1,A,"*: So Output( was also kind of covered. Output( has three basic components to it: the row number, column number, and the thing to be displayed (in that order). For example:

The program:
PROGRAM:TEST
ClrHome
Output(4,7,"HELLO

What it displays:
________________
________________
________________
______HELLO_____
________________
________________
________________
________________
The Output( here is basically placing the word "HELLO" the fourth row down and starting the "H" at the seventh column. If you didn't know the homescreen of the calculator is on a axis from 1-16 horizontally and 1-8 vertically (the graph screen is something like 0-94 horizontally and 0-62 vertically, I think).

_1234567890123456 //The "0123456" after the "9" stand for 10, 11, 12, 13, 14, 15, and 16.
1________________
2________________
3________________
4________________
5________________
6________________
7________________
8________________
Make sense?
Ok, back to the Output(1,A,"* in the program. This line basically just displays a * into row one and in column A.
Repeat Ans: This basically does what ztrumpet said. It stays in this loop until you press any key. The reason for this, though, is that a key press is a form of Ans. An example to show this would be:

PROGRAM:TEST
Repeat 0 //Starts an endless loop.
Repeat Ans //Starts another loop that waits till something is stored to "Ans."
getKey //Gets the key code of the key that was pressed.
End //Ends the "Repeat Ans" loop.
Disp Ans //Displays the value stored to "Ans." In this case it is the key code value.
End //Ends the "Repeat 0" loop.
getKey→K: This is what triggers the loop it is nested in. When you press a key the getKey command will capture this code (hence it being called getKey haha) and store it into Ans AND the variable K. This is because it is the answer from getKey but getKey is storing it's information to the variable K. You technically don't need the ...→K part of this, but you will run slower if you don't.
End: This basically just lets the program know that is the end of the loop. End commands are needed at the end of each type of loop (whether it is While, For(, or Repeat). You need it at the end of other things but I'm not covering that now. Sorry.
Output(1,A,"_: This is basically like the other Output( command, just instead of displaying a * it displays space. The point of this one though is that it erases the trail that would normally be there. Quick recap: 1 is the row number, A is the column number (this changes with the next line), and a space is what is being displayed.
A+(Ans=26 and A<16)-(Ans=24 and A>1→A: Well this one is going to be a doozy haha. I'm going to try to split this up.
-(Ans=26 and A<16) and (Ans=24 and A>1: So this is definitely better explained here (Boolean Logic) and here (Piecewise Expressions). But I'll try to explain this some. Basically when you have a function that uses =, ≤, and anything else in the [2nd][MATH] menu (in both TEST and LOGIC list) you will return with either a 1 (meaning the statement is true) or 0 (meaning the statement is false). A quick program to show this is:

PROGRAM:TEST
Repeat 0 //Enters endless loop.
Prompt A //Prompts for the value of A.
A≤50 //If A is less than or equal to A then it returns "1" as an answer. If A is greater than 50 it returns a "0."
Disp Ans //Displays the answer. Will be either "1" or "0."
End //Ends "Repeat 0" loop.
Essentially this means that the (Ans=26 and A<16) and (Ans=24 and A>1 can be replaced with "1's" and "0's" depending on which is true when. That covers that part.
-The next part I'm going to explain is the individual parts (not the "1's" and "0's" aspect though). First, the Ans=24 and Ans=26 pieces. Basically Ans right here is the value of getKey or K because that was the last thing to be stored to it. Easy enough, right? The A>1 and A<16 are easy to understand too, I hope. A is the column number, as I have said, so this is making sure it remains above 1 but lower than 16. otherwise you will get a ERR:DOMAIN error (I'm pretty sure that is the correct error). The only part left of those commands is the and part. This is pretty self-explanitory. Basically you have to have both the conditions met (to obtain a 1 for an output) otherwise the whole condition will be a 0 output.
-Finally, to put that all together. Depending which condition is made true ((Ans=26 and A<16) or (Ans=24 and A>1) you are adding or subtracting 1 (or 0 if neither are met).
I am hoping I explained that line of code well enough.
End: Finally, the last line of code haha. This one is simply ending the Repeat K=105 loop.

I believe I covered all of the lines of code, also I hope I explained what they do and how they work thouroughly and correctly. Please let me know if I have made a mistake somewhere, I will fix it.

As a final little thing, I will explain what each line of code does in the actual program just briefly. As a final recap.

8→A //Stores a value of 8 to the variable "A."
ClrHome //This clears the homescreen completly.
Repeat K=105 //This loop is repeated until the [ENTER] button is pressed.
Output(1,A,"_ //Displays a space in row one, into column "A."
Repeat Ans //Repeats this loop until any button is pressed.
getKey→K //Stores the key code value to the variable "K."
End //Ends the "Repeat Ans" loop.
Output(1,A,"* //Displays a "*" in row one, into column "A" (replacing the space).
A+(Ans=26 and A<16)-(Ans=24 and A>1→A //Adds or subtracts either "1" or "0" to "A" depending which condition is true, if any.
End //Ends the "Repeat K=105" loop
Here was the second example that I explained:

8→A
ClrHome
Repeat Ans=105
A+(Ans=26)-(Ans=24
Ans-16((Ans=17)-not(Ans→A
Output(1,Ans,"*
Repeat Ans
getKey
End
Output(1,A,"_
End
Ok, well like last time i will go line by line, but probably not into nearly as much detail. Lets start:
8→A: Pretty simple. You're storing a value of 8 to the variable A.
ClrHome: This clears the homescreen of everything that is currently on it. For more detail look at my last explanation.
Repeat Ans=105: This is the beginning of the a Repeat loop that is waiting for you to hit [ENTER] (since it's key code is 105).
A+(Ans=26)-(Ans=24: Little trickier. A currently has a value of 8 (when the program is run) so when you hit the left or right arrow key (which will be stored in Ans because getKey is the last line of the loop) you will either add 1, -1, or 0 to A. This answer will now be stored to Ans which sets up the next line.
Ans-16((Ans=17)-not(Ans→A: Even more tricky. This is the line that lets the * wrap around. Like I had said the new value of A has been stored to Ans in the last line. You are essentially adding either 16, -16, or 0 and then storing it to A. How this works is that it takes the value in Ans and if this value is equal to either 17 or 0 you are multiplying 16 by 1 or -1 (thanks to the Boolean Logic I explained earlier with conditions). The reason this works with zero though is because of the not( command. This essentially reverses the Boolean Logic and returns the opossite (true becomes false and false becomes true). Now, to be honest this doesn't make the most ammount of sense to me but I do know why it is used here. Using the not( command in this way lets you replace the statement Ans=0 (because they return the same answer). It's used as an optimization right here.
Output(1,Ans,"*: This outputs a * into row one, Ans number of columns out. You can use Ans here because of the last line. You are storing the value of A to Ans because it is a math operation basically. Hope that makes sense.
Repeat Ans: This starts a loop that waits for you to push a button. It does this because the value from getKey gets stored to Ans.
End: Ends the Repeat Ans loop. As specified earlier (in the previous explanation) End's specify the end of code inside loops (or a few other things that require them).
Output(1,A,"_: This displays a space into row one and in column A. The reason for this Output( is to erase the * that would normally trail behind.
End: This ends the Repeat Ans=105 loop. This completes the code so if you hit [ENTER] it will end the program (since nothing is beyond the End).

So, quick recap:

8→A //Stores a value of 8 to the variable "A."
ClrHome //Clears the homescreen of anything that is on it.
Repeat Ans=105 //Begins a loop that waits for [ENTER] to be pressed to end the program.
A+(Ans=26)-(Ans=24 //Adds 1 or -1 to A depending if [◄] or [►] is pressed. "A" gets stored to "Ans."
Ans-16((Ans=17)-not(Ans→A //This adds or subtracts 16 from "Ans" if "Ans" is equal to 17 or 0. Adds nothing if it doesn't equal either one. Stores the answer to "A."
Output(1,Ans,"* //Displays a "*" in row one and "Ans" columns out.
Repeat Ans //Starts a loop that waits for you to press a button.
getKey //Stores the value of the key pressed to "Ans."
End //Ends the "Repeat Ans" loop.
Output(1,A,"_ //Displays a space in row one and in column "A." This erases the "*" left behind.
End //Ends the "Repeat Ans=105" loop.
I hope this helps anyone who had stuff to take away from this. Again, just thought some might like this. Enjoy

Hello all. I'm brand new here, obviously haha. I recently became a member of at United-TI and have seen this site a few times and thought it looked cool so I decided to join. I am a beginner-intermediate at TI-BASIC but still closer to the beginner level (mostly due to the lack of ideas of what to actually program haha). Basically the only programs worth mentioning that I've created are a Binary to Decimal program and a Decimal to Binary (shocker ). Anywho, I am out of things to say now. Have a nice day