Rotation

I've made a few tetris games in Basic, let me share the way I did it.  First off, the way I stored my pieces is in 2 lists, 1 for X offset and 1 for Y offset.  Each list had 4 coordinates, 1 for each piece.  These values would look something like this:

X = {-1,-1,0,1}
Y = {-1,0,0,0}
Note that these coordinated would make some form of the L shape, to output them, we would do something like this:

For(I,1,4)
Output(X(I)+S,Y(J)+T)
End
It's important to see that I have 4 variables here, the two lists X and Y, and then the two variables S and T.  The lists hold the shape of the piece, while the variables hold the Location of the piece.  This is a good thing because this is what allows us to rotate our pieces quickly:

X->Z
Y->X
-Z->Y
That code operates on the lists, and rotates the shape clockwise, you can switch the negative sign to the Y instead of the Z to rotate the other direction.

Collisions

I am a bit unfamiliar with Casio homescreen text commands, so I will assume there is a way to detect whether a single space is filled.  Whether you utilize some sort of Pixel Test function, or use a Matrix, the logic is the same.  There are two conditions for a collision, you either move a piece into a wall, or rotate a piece into a wall.  Assuming we have a way to detect whether a position is filled, collision checking is simple.

First we merely move or rotate the object blindly, then loop through all positions of the new piece position and check if any of them are filled.  If any of them are, we reverse the object operations and resume the game.  Because of this, you will need a way to rotate both directions.

Line Detecting:

Because of the size of the tetris field, it might be difficult to check every line every time a piece is placed,  so instead we will check only the lines that possibly could have a completion, and these are the lines that the piece ends up in.  The piece is made of 4 blocks, which means at a maximum we will have to check 4 lines.  

When we check for lines, we take the Y locations of the object, remove duplicated, and sort them from top to bottom.  The we loop through each Y position from top to bottom.  For each Y position we check all of the blocks in that line, if any of them are empty, we skip this Y position and go to the next.  If we are at the last Y position, we move on to playing the game.

If, however, all of the blocks are filled, we move onto the line clearing algorithm.  It consists of mostly a line shifting algorithm, and this is how it works.  If a filled Line was detected at location Y, we go through every block in that line and replace it with the one above.  We then do that for every line above Y until we encounter an empty line, after which we are finished clearing and shifting.

Once we check and clear every line we need to, we can choose the next piece (which can be done from a lookup table) and start the next turn!



Does that all make sense?  Hopefully it helped Just ask if you have more questions ^^

Ah that's clever!  That would make things significantly faster during line checking ^^

never mind about negatives, I was wrong, thats not the prob.

S and T had to be 2 not 1.

OK, thanks. I made a program, but I think I'll start from scratch and perfect it.(I've been embellishing too much and some stuff won't work now.) Thanks for all your help Bboy!!!

Yeah. I'm realizing that! Man, those programmers in the 80's must have been good!