There are currently 6 programs that allow you to play/view Go games on a TI calculator.
- TI-Go - for the TI-83 and TI-83+ platforms (9x9)
- Easy Go - for the TI-83+ platform (In French) (9x9)
- Go 19x19 - for the TI-83+ platform (19x19)
- IGO - for the TI-83+ platform (9x9)
- TI-Go / TI-Go-View - for the TI-89 platform (9x9, 13x13, 19x19)
- Go - for the 83+ platform (9x9)
There is an other program still in development.
- Go - for the TI-83+ platform (for now, just available in French) (9x9, 13x13, 19x19). The 19x19 isn't developed for now, but it will. The coder is opened to suggestions...
Ti-Go is a program for the TI-83 graphing calculator that allows two players to play Go on a 9x9 board. It was written by Ben Axelrod. To download the program and see some screen shots go here: http://www.ticalc.org/archives/files/fileinfo/284/28424.html
- It displays a cursor on the board which you move around using the arrow keys
- It displays the coordinates of the current cursor position
- It displays whose turn it is
- It automatically removes dead stones
- It counts the dead stones removed from the board
- You can save and load one game at a time
- It allows a handicap
- It allows a pass
- The program is written in Ti-Calc BASIC, so it is a little slugish at times
- Does not check for illigal moves (placing a stone where it will have no liberties and ko rules)
- Undo feature
- Last move marking
- Faster opperation in assembly language (need help with)
- Calculator linking capabilites (need help with)
If you would like to help in any way (porting to another calc, converting to assembly language, adding calculator linking or anything else) please email me: email@example.com
The process of removing dead stones is essentially recursive. However, the language i am writing in does not allow this type of recursion. So the idea behind my algorithm is to build up a list of stones to be erased. The algorithm goes down this list and for every stone on the list, it looks at its 4 neighbors. If the neighbor is also of the right color, it adds it to the end of the list. If the neighbor is black or a wall, it does nothing. If one of the neighbors is an empty spot, then the list is cleared and the search is abandoned. Once the agorithm gets to the end of the list, then the stones on the list are deleted. Of course, this whole algorithm will have to be implemented 4 times: once for each of the placed stone's neighbors.
NOTE: I numbered the for loops for clarity
For_1 (the 4 neighbors of the placed stone) ;goes around the placed stone clear list if (stone is target color) Then add the stone to list For_2 (X,1,size of list) ;goes down the list of stones in the group For_3 (the 4 neighbors of X) ;goes around the stones in the list if (neighbor is target color) Then If (neighbor is not on list) Then Add stone to list End End if (neighbor is empty) ;group has liberty then clear list ;to break For_2 break For_3 End End_for_3 End_for_2 erase all stones on the list End End_for_1
What do you think about this algorithm?
Bisqwit: I recently wrote a goban simulator in Ruby. It keeps track of the stone groups on board and their respective liberties, and handles captures automatically. You can pick ideas from its source code. And then there's cgoban and many other free go-related software. Take a look.
David: I haven't studied algorithms that perform this task particularly, and so am not especially qualified to comment on yours. That said, I think it will work (I've even tested it, just now). You shouldn't worry too much about optimization. While this algorithm will visit a given stone several times, the captures of large strings that would make this a problem are not common. And in my experience, screen drawing operations are the major unavoidable bottleneck on the TI-83 (it's been years since I've used one, though).
I'm sure there are better algorithms, but most rely on maintaining data structures more complex than the TI-83 can conveniently handle. Your algorithm is novel and seems to me to be a good solution.
dmwit: When writing my own go program for the TI-83+, I came up with the same algorithm! It was good enough for me, though it was rather slow in BASIC. I am also using that algorithm in a C/assembly go board for the TI-89. Although it is still in the alpha stages, it has many nice features already. You can preview it at http://www.geocities.com/dmwit/goban89_preview.zip.
Ti-Go / TI-Go-View is a program for the TI-89 graphing calculator that allows two players to play Go on a 9x9, 13x13 or 19x19 board as well as save and view games. It was written by Alexander Nittka?. To download the program and see some screen shots go here: http://www.ticalc.org/archives/files/fileinfo/91/9130.html
By Alec Hirsch
Two Player game only!! does not support AI
This Go program allows you to play a normal game of go with all legal moves included. The program uses matrixies and lists to keep track of the pieces. Program can also save and load up to 5 games as well as edit a game from either a cleared board or a saved board.
For the non-app version, the main file is called INDEX.
Does not need any shells, game was written in TI-BASIC. --
- Displays turn
- Flawless graphics
- Ko rules
- Save/Load (up to 5 slots)
- Scoring system
- Editing interface (from cleared or saved board)
- Up to 4 handicap
- Install (for non-app version)
- Keeps track of score and says who wins at the end of scoring sequence
The program uses literaly all of the letter variables:
- A- temp for( + other crucial temps
- B- crucial temp
- C- used for original color in takepce program
- D- change in J
- E- change in I
- F- color of piece being tested
- G- total # of variables in List 4
- H- total # of variables in List 5+6
- I- temp when testing matrix J? x-coordinate
- J- temp when testing matrix J? y-coordinate
- K- temp for(
- L- temp for(
- M- current # within lists 5+6 to check
- N- cursor y-coordinate in matrix
- O- cursor x-coordinate in matrix
- P- color of whose turn
- Q- current # within list 4 to check
- R- temp for(
- S- used to store pixel X-coordinate when needed to change
- T- used to store pixel Y-coordinate when needed to change
- U- white score
- V- black score
- W- track # of passes
- X- pixel X-coordinate
- Y- pixel Y-coordinate
- Z- temp for(
- theta- getkey
- list 3- used to keep track of pieces with auto-check
- list 4- used to keep track of where in list 5+6 pieces need to be checked
- list 5- O(y-coordinate in matrix) of piece that needs to be checked
- list 6- N(x-coordinate in matrix) of piece that needs to be checked
- matrix J?- keeps track of pieces on board, matrix is 11x11, no piece=0, white piece=1, black piece=2, border=4
- matrixies E,F,G,H,I?- used for saved games
- pic7- board (only if using non-app program)
- pic0- menu (only if using non-app program)
Total group size with 17 programs: 8419 bytes (not including pics) Total space needed when using app: 4412 bytes
Note: It was completely necessary to use different variables for so many temps, I had to use many for( loops within for( loops for the autocheck and take piece functionality.
Known flaws: -None
If there are any major bugs, email me at firstname.lastname@example.org --
On the menu you will be given an option to view the instructions, do so. The F keys are on the top if you did not already know.
-- v1.1- released, I have also included the group of the actual programs, the reason i turned it into an app is because there are 17 sub programs of the game. However, the downside of this is lost processing speed. If you use the non-app version you must install the pic before use.
v1.2- Added Ko functionality and fixed up the order of scoring sequence. Drawing the board is now faster.
Enjoy!! email me with any questions/problems or if you need help using the program at email@example.com