I've got a little under a month 'till school starts and haven't done anything programming related in a while. Computer chess has always fascinated me but is largely impossible in TI-BASIC. However, I am considering doing a minichess variant which would exponentially lower the game-tree complexity.

I was thinking:
RNBQK
PPPPP
______
______
PPPPP
RNBQK
As the board layout. Which is similar to the left half of a chessboard squished together. I've actually come across some things about this being a pretty popular chess variant in Italy for a while and opening theory was actually developed. I have tons of ideas about possible algorithms and ways to approach computer chess i'm quite excited. Any comments?

Sounds like a good idea. But its going to be a challenge to have it figure out whether not there's already a piece there or not, and which team's piece it is. You'll probably have to throw in some pxl-test stuff and what not, but I'm sure somebody here could figure it out.

@Svakk
Thats a terrible idea. Keep track of the pieces in a matrice/list/string, not pixels. Also, I'm sure he'll be using some asm lib for sprites, faster refreshing, etc...

Matrices++ although I /could/ do it with pixel tests, however that would be much more difficult.

But on to the actual progress.

The things I will need for a chess engine are as follows:
-Available move finder
-Evaluation function
-A glimpse into the futtuuurrreeee (probably alpha-beta pruning)
-Modified rule set for minichess


The first one is the most difficult actually. It shouldn't be /toooo/ hard though. What i'll probably do is for every move, i'll look at only the pieces that could be affected by that move (pieces horizontal to, vertical to, or diagonal to) and update their respective possible move lists. Alternatively I could simply create the possible moves as I search, as their shan't be many. The maximum number of moves possible is a queen in the center of the board, 17 moves. I am actually considering removing the queen and adding a second bishop, because bishops need pairs ;P

An evaluation function simply looks at the board and says the value of it. By value I mean which side has what kind of advantage. There are many things you can evaluate, such as territory controlled, piece count, active pieces, safe king, etc. One can weight these differently in an evaluation engine. I intend something like this.

60% piece count
20% spacial control
10% active pieces
10% king safety

What I intend to do for foresight is a simple alpha-beta pruning search. By pruning I mean, if for example, I look at the move "queen to a6" and on the opponents move he has the option to take it, and on my next turn I cannot either take his queen back or checkmate him, I know that queen to a6 is a garbage move and I don't need to explore that line any more. An alternative would be a monte-carlo approach, I take all of my moves, and from each of those moves play that move + 10 random moves into the future and evaluate that position. Do this a few times for each for each possible move and you get a good move (hopefully). I will probably do the first method (or a combination of the two).

My modified rule set is as follows:
When pawns get to the last rank they turn into rooks. 'nuff said.
Pawns only move forward 1 square, all the time
No castling
If you 'bare' the opponent, that is, kill all their pieces except their king, you win
A stalemated player loses

I think my final board setup is this:
RNBBK
PPPPP
_____
PPPPP
RNBBK
Which will greatly speed up the move process. It may look a bit crampt, but it's a subtle game ;P

I can help you with that acid thing since I work at a pool store, http://totalpoolcarewi.com/, we sell hydrochloric acid by the case for lowering PH and Alkalinity.