(Editor's Note - this article requires additional formatting work and is incomplete)

[size="5"]Where Did We Leave Off?

Up until now we have made some good progress. We have a nice framework for our game to sit in, and, more importantly, we are all set to create the actual game. Which, coincidentally, is what we are going to do in this article. So, instead of just "good" progress ... be prepared for some extraordinary progress.

Here is the current line-up ...

Leading off today is Animation. He is a very important player on our team so we want him up first. Without him we won't be able to play at all.

Next up, we have Mr. Structures. Mr. S, as he is often called, has the job of keeping everything organized. He is the guy in the dugout often stacking things, or keeping track of statistics. He plays a more important role later in the season when we start playing "real games" and keeping score.

Third, we have the New Shape maker. He is responsible for setting things up for the later players. He is often overlooked since he works behind the scenes.

Batting cleanup for us is Update. Update is a big boy. He has a large job but does a great job of delegating things he needs to other people. Often known as our power hitter, he is the most recognized of all members.

Batting fifth and sixth for us are twins Move Shape and Rotate Shape. They are the ones we rely on to keep things going. If they strike out we know something has gone amiss somewhere along the lines.

The seventh in our line up is Line Test. He typically will clear the bases ... but only if certain conditions are met.

The eighth and ninth positions are filled by another set of twins, Draw Grid and Draw Shape. They are the publicity freaks on the team and make sure the fans can see everything that is happening.

Our manager is of course "the loop." He is the leader and holds everything together. It is his job to dictate what needs to be done and make sure nobody fails. He will not hesitate to act upon any error and is very demanding ... likes to make sure everything is done on his clock.

We have a good solid team and are ready to take a look at their statistics, background, and of course ... how they think. Are you ready ... play ball!


[size="5"]Stepping to the plate...

Animation is a very complicated player. He can play in many different ways, and has numerous styles. On our team, he has adopted the style commonly referred to as "Pre-Set." What this means is that everything that he does was determined before the game has even been started. This occurred in the initialization section, of course.

In our game we have single blocks that are selected at random. That random block is used with a random shape. The shapes that exist are the same ones as in the original Tetris. Now the animation sequences that are needed by the shapes are relatively simple ... you merely rotate the shapes. Therefore, I had three choices when deciding how to animate them.

1. I could make bitmaps of every shape pre-built and rotate them at runtime as needed.
2. I could do the same as above except pre-rotate them, then save many bitmaps and cycle through them at run-time as they are needed.
3. I could build every shape from a block and use some sort of table to tell me how the shape was to be built for that frame.

Because of speed, and size, I decided to go with the third method. It is a little bit more complex ... but I think the speed gain, and size drop, is worth it. (NOTE: As a programmer, if you have the ability to make a piece of code more robust, more user-friendly, smaller, or faster then do so).

So, now that we know what we want, how do we accomplish it? Well, the first thing I did was sit down with a piece of paper, and determine the patterns that a shape could have. Then, I took those patterns, encapsulated them into mini-grids, and made them represent either ON, or OFF, states depending on if a block was in that position. Here is an example for a square.
[bquote][font="Courier New"]0 0 0 0
0 1 1 0
0 1 1 0[/font]
[font="Courier New"]0 0 0 0[/font][/bquote]Notice the grid is 4x4, the reason is because the largest a shape can be is four squares wide, or tall. The ones are the places were the blocks are and the zeros are empty locations.

With that gigantic list built, I needed a way to organize them into look-up tables. The decision was to pad the left of each line with four zeros and thus get an 8x4 grid. I could then use an array of four bytes for each frame where a single bit represented a block. This caused a 2-byte waste for every block ... yet it made the code about 100000 times easier to understand.

The table access is really simple. We just offset into the table according to the shape we want. Then, we offset into that address by the frame that we want. Every shape has four frames, no matter what, and are all aligned to four bytes. So, we can easily adjust our "frame pointer" with a few simple arithmetic operations.

That is how animation works in our game. You simply tell him when to adjust to a new frame and he does. Need a new shape? No problem, just point him where it is and he will know what to do.

Here is our table.


[size="5"]Mr. Structure

Oh, yes ... Mr. Structure. He often looks like a container, however in our game he is spread out. It is his responsibility to hold the X and Y coordinates, current shape, current shape block to use, and the current frame. He has just a few variables to keep things semi-organized.

As I mentioned earlier, he will have a larger job when it comes to keep score, and manage any other statistics.

He is a really open guy, global to be precise. He doesn't mind helping people and, of course, will let anybody know what he knows.

The declarations for him are in [color="#8B0000"]Shapes.asm [/color]and for the time being are relatively simple.

Because Mr. Structure is so open bad things can POSSIBLY happen. It is your job, as a programmer, to make sure that those bad things can NEVER happen. If you let him be corrupted in some manner your whole game might go down the toilet.


[size="5"]The New Shape Maker

With the dreary setup stuff behind us we have things ready for the New Shape maker. His responsibility is fairly straight forward so let's take a look at the code before I start explaining things.

Do you see what I am doing with the code? You should start having at least a general idea when looking at the code segments. If not, start studying more ... that means writing code, not staring at mine!

To start with we check the area directly under where we want the block to start to see if there are blocks already in there. If so, then they died. It is a really simple concept. No more room on grid = DEATH!

Next we grab some random numbers to use for the block texture and the shape. I chose just to use the [font="Courier New"][color="#000080"]Get_Time()[/color][/font] function that we have. We may write a true random number generator later in this article series. For now, this function call will serve our purposes.

In order to get a number between zero and six we divide by seven and take the remainder ( this is placed in EDX after a DIV ) . This way, the highest number we could have is six, and the lowest is zero, which is perfect since we have seven shapes to choose from.

We do something a bit different for the blocks. Instead of performing a MOD operation, we AND the number with ( N-1 ). Where N is the number you would normally MOD with. This only works for numbers that are powers of 2 however. We are taking advantage of another bit manipulation operation to speed things up.

The next step is to merely initialize the starting X and Y coordinates along with the starting frame to use.

That is all we need to do in order to create a new shape during the game. Once this function is finished everything is setup to start moving and manipulating the current shape, whatever it may be.


[size="5"]Update takes a few practice swings

Update is our power hitter. He has the job of handling all updates. Let's take a look at exactly what it is he does.

Wow! For somebody so important he sure doesn't do very much. Almost like real life, what do you think?

To begin with we make a call to test the collision status of the current shape. If the call returns TRUE then we can not move the shape anymore and need to place it in the grid. So he makes a call to [font="Courier New"][color="#000080"]Place_In_Grid()[/color][/font]. However, if the call returns FALSE, then we can still move the shape. So, we drop it down a notch by decrementing the Y coordinate of the shape.

The last thing we need to do is return to our manager and tell him whether we succeeded or failed. Before we continue though, let's take a closer look at [font="Courier New"][color="#000080"]Test_Collision()[/color][/font] and [font="Courier New"][color="#000080"]Place_In_Grid()[/color][/font] since they are the ones who really do the work.

The [font="Courier New"][color="#000080"]Place_In_Grid()[/color][/font] function is the simpler of the two so let's cover that one first. It moves to the location in Grid Memory based upon where our current shape is located. Once there, it simply loops through every row in the frame and, if there is a block in that bit position, it sets the block to TRUE by indicating the current block texture + 1. The reason we had to do ( texture + 1 ) is we use zero to indicate that no blocks are there.

[font="Courier New"][color="#000080"]Test_Collision()[/color][/font] is not quite so simple. It loops through all four columns, and, inside that, loops through all four rows of the current frame. It then tests the bit at its' own ( row, col ) location. If there is a bit turned ON there, it checks whether or not the grid has a block in the position directly under it. If it fails this test, on ANY bit, then the block can not be moved so we return TRUE. Otherwise, at the end, if there have been no collisions we return FALSE. At this point we also check to see if it is at the bottom of the grid. This constitutes the same thing as having a block underneath it.

As you an see, although [font="Courier New"][color="#000080"]Update()[/color][/font] is very important to our team, he has so much to do that you ALWAYS want to have him delegate his responsibilities out to others. Then, just let him pretend to do what he is supposed to do.

NOTE: In case you missed my crude attempt at symbolism here is a quick explanation. YOU NEVER want to make functions that do many things. The ideal is to only have them accomplish one, maybe two things. Let a manager type function make calls, test for errors, and things like that.


[size="5"]Let's Get Moving!

Now that we have a piece to play with, we need to do just that, play with it. Get your minds out of the gutter!

Anyway, here is the code:

These two functions [font="Courier New"][color="#000080"]Rotate_Shape()[/color][/font] and [font="Courier New"][color="#000080"]Move_Shape()[/color][/font] are pretty big, so it is good they are twins. Yet, what they do, is fairly cut and dried. Let's cover, just in general, what it is they do.

The rotate function first decided if it is at the last frame. If so, it has code to wrap it around for all of the test, otherwise it just uses the next frame. Then, it loops through all of the bits, finding the valid ones, just like [font="Courier New"][color="#000080"]Test_Collision()[/color][/font]. If there is already a bit set in the place the shape would be at then it is not allowed to move and the call fails. And ... that is that.

NOTE: Code is not in there to check for out of bounds on the grid. So, if you rotate at a corner, you may slide out of the grid and into the background area. This has been left as AN EXERCISE FOR YOU. I wanted to see something interactive come out of this article series, and I decided this would be as good of a place as any to start asking for it. I will present my solution in the next article. Compare yours to mine at that time.

Back to the code at hand: [font="Courier New"][color="#000080"]Move_Shape()[/color][/font]. This function will move the shape to the left, or to the right, depending on the value passed into it. It merely tests the bits once again. Only this time we have to find the leftmost, or rightmost, valid bit in each row. Then, we check the grid block to the left or right and see if it is empty. Accordingly, either we move it, or we don't, and then return to the caller.

There isn't much else to talk about in this section. You have seen how to access everything many times now. The only thing that changes is the things we need to access, or the order in which we test stuff. These are the kinds of things that need to be resolved at design time.


[size="5"]Time to Clear the Bases?

When it comes time to clear the grid we call upon Line_Test. This will function will return TRUE if it clears a line. It will return false if it doesn't have a valid line on the grid.

Here is the code for it:

;########################################################################
; Line_Test Procedure
;########################################################################
Line_Test PROC

;================================================
; This function will test to see if they earned a
; line ... if so it will eliminate that line
; and update our grid of blocks
;================================================

;==========================
; Local Variables
;==========================
LOCAL CurLine: DWORD
LOCAL CurBlock: DWORD

;===============================
; Start at the Base of the Grid
;===============================
MOV CurLine, 0

;=================================
; Loop through all possible Lines
;=================================
.WHILE CurLine < (GRID_HEIGHT - 4)
;===================================
; Goto the base of the current line
;===================================
MOV EAX, CurLine
MOV ECX, 13
MUL ECX
ADD EAX, BlockGrid

;==================================
; Loop through every block
; testing to see if it is valid
;==================================
MOV CurBlock, 0
.WHILE CurBlock < (GRID_WIDTH)
;==========================
; Is this Block IN-Valid?
;==========================
MOV BL, BYTE PTR [EAX]
.IF BL == 0
;===================
; Yes, so break
;===================
.BREAK

.ENDIF

;======================
; Next Block
;======================
INC EAX

;======================
; Inc the counter
;======================
INC CurBlock

.ENDW

;==============================
; Did our inner loop go all
; of the way through??
;==============================
.IF CurBlock == (GRID_WIDTH)
;============================
; Yes. That means that it was
; a valid line we just earned
;============================

;===================================
; Calculate How much memory to move
; TOTAL - Amount_IN = TO_MOVE
;===================================
MOV EBX, (GRID_WIDTH * (GRID_HEIGHT -5))
MOV EAX, CurLine
MOV ECX, 13
MUL ECX
PUSH EAX
SUB EBX, EAX

;============================
; Move the memory one line
; up to our current line
;============================
POP EAX
ADD EAX, BlockGrid
MOV EDX, EAX
ADD EDX, 13

;==============================
; Move the memory down a notch
;==============================
INVOKE RtlMoveMemory, EAX, EDX, EBX

;============================
; Jump down and return TRUE
;============================
JMP done

.ENDIF

;==============================
; Incrment our Line counter
;==============================
INC CurLine

.ENDW

err:
;===================
; We didn't get one
;===================
return FALSE

done:
;===================
; We earned a line
;===================
return TRUE


Line_Test ENDP
;########################################################################
; END Line_Test
;########################################################################The code loops through every line in our grid memory and test for blocks. If it finds that a grid location is empty then it continues with the next line. If every location has a valid block inside of it, then the function moves all of the memory above it to the row that had the line. It does this by calling the Win32 API function [font="Courier New"][color="#000080"]RTLMoveMemory()[/color][/font].

We have it return after every valid line it finds, and eliminates, because when we want to keep score it will be easier to track how many lines they earn. It is always a good thing to keep future expansion in mind while programming.


[size="5"]The Final Batters

Our two final hitters are the publicity hounds [font="Courier New"][color="#000080"]Draw_Shape()[/color][/font] and [font="Courier New"][color="#000080"]Draw_Grid()[/color][/font]. Below is their code.

;########################################################################
; Draw_Shape Procedure
;########################################################################
Draw_Shape PROC

;=======================================================
; This function will draw our current shape at its
; proper location on the screen
;=======================================================

;===========================
; Local Variables
;===========================
LOCAL DrawY: DWORD
LOCAL DrawX: DWORD
LOCAL CurRow: DWORD
LOCAL CurCol: DWORD
LOCAL CurLine: DWORD
LOCAL XPos: DWORD
LOCAL YPos: DWORD

;===================================
; Get the Current Shape Pos
;===================================
MOV EBX, CurShape
MOV EAX, CurShapeFrame
SHL EAX, 2
ADD EBX, EAX
MOV CurLine, EBX

;===================================
; Set the Starting Row and Column
; for the drawing
;===================================
MOV EAX, CurShapeX
MOV EBX, CurShapeY
MOV DrawX, EAX
MOV DrawY, EBX

;===================================
; Loop through all four rows
;===================================
MOV CurRow, 0
.WHILE CurRow < 4
;=====================================
; Loop through all four Columns if
; the Y Coord is in the screen
;=====================================
MOV CurCol, 4
.WHILE CurCol > 0 && DrawY < 20
;===============================
; Shift the CurLine Byte over
; by our CurCol
;===============================
MOV ECX, 4
SUB ECX, CurCol
MOV EBX, CurLine
XOR EAX, EAX
MOV AL, BYTE PTR [EBX]
SHR EAX, CL

;===============================
; Is it a valid block?
;===============================
.IF ( EAX & 1 )
;============================
; Yes it was a valid block
;============================

;=============================
; Calculate the Y coord
;=============================
MOV EAX, (GRID_HEIGHT - 5)
SUB EAX, DrawY
MOV ECX, BLOCK_HEIGHT
MUL ECX
MOV YPos, EAX

;=============================
; Calculate the X coord
;=============================
MOV EAX, DrawX
ADD EAX, CurCol
DEC EAX
MOV ECX, BLOCK_WIDTH
MUL ECX
ADD EAX, 251
MOV XPos, EAX

;=============================
; Calculate the surface to use
;=============================
MOV EAX, CurShapeColor
SHL EAX, 2
MOV EBX, DWORD PTR BlockSurface[EAX]

;=============================
; Blit the block
;=============================
DDS4INVOKE BltFast, lpddsback, XPos, YPos, \
EBX, ADDR SrcRect, \
DDBLTFAST_NOCOLORKEY OR DDBLTFAST_WAIT

.ENDIF

;=====================
; Dec our col counter
;=====================
DEC CurCol

.ENDW

;=======================
; Inc the CurLine
;=======================
INC CurLine

;====================
; decrement Y coord
;====================
DEC DrawY

;====================
; Inc the row counter
;====================
INC CurRow

.ENDW

done:
;===================
; We completed
;===================
return TRUE

err:
;===================
; We didn't make it<br