Jeff Molofee - NeHe's OpenGL Tutorials

glVertex2d(80+(loop1*60), 70+(loop2*40)); // Right Side Of Horizontal Line

glEnd(); // Done Drawing Horizontal Cell Borders

}

The code below does the same thing, but it checks to make sure the line isn't being drawn too far down the screen instead of too far right. This code is responsible for drawing vertical lines.

glColor3f(0.0f,0.5f,1.0f); // Set Line Color To Blue

if (vline[loop1][loop2]) // Has The Horizontal Line Been Traced

{

glColor3f(1.0f,1.0f,1.0f); // If So, Set Line Color To White

}

if (loop2<10) // Dont Draw To Far Down

{

if (!vline[loop1][loop2]) // If A Verticle Line Isn't Filled

{

filled=FALSE; // filled Becomes False

}

glBegin(GL_LINES); // Start Drawing Verticle Cell Borders

glVertex2d(20+(loop1*60),70+(loop2*40)); // Left Side Of Horizontal Line

glVertex2d(20+(loop1*60),110+(loop2*40)); // Right Side Of Horizontal Line

glEnd(); // Done Drawing Verticle Cell Borders

}

Now we check to see if 4 sides of a box are traced. Each box on the screen is 1/10th of a full screen picture. Because each box is piece of a larger texture, the first thing we need to do is enable texture mapping. We don't want the texture to be tinted red, green or blue so we set the color to bright white. After the color is set to white we select our grid texture (texture[1]).

The next thing we do is check to see if we are checking a box that exists on the screen. Remember that our loop draws the 11 lines right and left and 11 lines up and down. But we dont have 11 boxes. We have 10 boxes. So we have to make sure we don't check the 11th position. We do this by making sure both loop1 and loop2 is less than 10. That's 10 boxes from 0 – 9.

After we have made sure that we are in bounds we can start checking the borders. hline[loop1][loop2] is the top of a box. hline[loop1][loop2+1] is the bottom of a box. vline[loop1][loop2] is the left side of a box and vline[loop1+1][loop2] is the right side of a box. Hopefully I can clear things up with a diagram:

All horizontal lines are assumed to run from loop1 to loop1+1. As you can see, the first horizontal line runs along loop2. The second horizontal line runs along loop2+1. Vertical lines are assumed to run from loop2 to loop2+1. The first vertical line runs along loop1 and the second vertical line runs along loop1+1

When loop1 is increased, the right side of our old box becomes the left side of the new box. When loop2 is increased, the bottom of the old box becomes the top of the new box.

If all 4 borders are TRUE (meaning we've passed over them all) we can texture map the box. We do this the same way we broke the font texture into seperate letters. We divide both loop1 and loop2 by 10 because we want to map the texture across 10 boxes from left to right and 10 boxes up and down. Texture coordinates run from 0.0f to 1.0f and 1/10th of 1.0f is 0.1f.

So to get the top right side of our box we divide the loop values by 10 and add 0.1f to the x texture coordinate. To get the top left side of the box we divide our loop values by 10. To get the bottom left side of the box we divide our loop values by 10 and add 0.1f to the y texture coordinate. Finally to get the bottom right texture coordinate we divide the loop values by 10 and add 0.1f to both the x and y texture coordinates.

Quick examples: loop1=0 and loop2=0

• Right X Texture Coordinate = loop1/10+0.1f = 0/10+0.1f = 0+0.1f = 0.1f

• Left X Texture Coordinate = loop1/10 = 0/10 = 0.0f

• Top Y Texture Coordinate = loop2/10 = 0/10 = 0.0f;

• Bottom Y Texture Coordinate = loop2/10+0.1f = 0/10+0.1f = 0+0.1f = 0.1f;

loop1=1 and loop2=1

• Right X Texture Coordinate = loop1/10+0.1f = 1/10+0.1f = 0.1f+0.1f = 0.2f

• Left X Texture Coordinate = loop1/10 = 1/10 = 0.1f

• Top Y Texture Coordinate = loop2/10 = 1/10 = 0.1f;

• Bottom Y Texture Coordinate = loop2/10+0.1f = 1/10+0.1f = 0.1f+0.1f = 0.2f;

Hopefully that all makes sense. If loop1 and loop2 were equal to 9 we would end up with the values 0.9f and 1.0f. So as you can see our texture coordinates mapped across the 10 boxes run from 0.0f at the lowest and 1.0f at the highest. Mapping the entire texture to the screen. After we've mapped a section of the texture to the screen, we disable texture mapping. Once we've drawn all the lines and filled in all the boxes, we set the line width to 1.0f.

glEnable(GL_TEXTURE_2D); // Enable Texture Mapping

glColor3f(1.0f,1.0f,1.0f); // Bright White Color

glBindTexture(GL_TEXTURE_2D, texture[1]); // Select The Tile Image

if ((loop1<10) && (loop2<10)) // If In Bounds, Fill In Traced Boxes

{

// Are All Sides Of The Box Traced?

if (hline[loop1][loop2] && hline[loop1][loop2+1] && vline[loop1][loop2] && vline[loop1+1][loop2]) {

glBegin(GL_QUADS); // Draw A Textured Quad

glTexCoord2f(float(loop1/10.0f)+0.1f, 1.0f-(float(loop2/10.0f)));

glVertex2d(20+(loop1*60)+59,(70+loop2*40+1)); // Top Right

glTexCoord2f(float(loop1/10.0f),1.0f-(float(loop2/10.0f)));

glVertex2d(20+(loop1*60)+1,(70+loop2*40+1)); // Top Left

glTexCoord2f(float(loop1/10.0f),1.0f-(float(loop2/10.0f)+0.1f));

glVertex2d(20+(loop1*60)+1,(70+loop2*40)+39); // Bottom Left

glTexCoord2f(float(loop1/10.0f)+0.1f,1.0f-(float(loop2/10.0f)+0.1f));

glVertex2d(20+(loop1*60)+59,(70+loop2*40)+39); // Bottom Right

glEnd(); // Done Texturing The Box

}

}

glDisable(GL_TEXTURE_2D); // Disable Texture Mapping

}

}

glLineWidth(1.0f); // Set The Line Width To 1.0f

The code below checks to see if anti is TRUE. If it is, we enable line smoothing (anti-aliasing).

if (anti) // Is Anti TRUE?

{

glEnable(GL_LINE_SMOOTH); // If So, Enable Antialiasing

}

To make the game a little easier I've added a special item. The item is an hourglass. When you touch the hourglass, the enemies are frozen for a specific amount of time. The following section of code is resposible for drawing the hourglass.

For the hourglass we use x and y to position the timer, but unlike our player and enemies we don't use fx and fy for fine positioning. Instead we'll use fx to keep track of whether or not the timer is being displayed. fx will equal 0 if the timer is not visible. 1 if it is visible, and 2 if the player has touched the timer. fy will be used as a counter to keep track of how long the timer should be visible or invisible.

So we start off by checking to see if the timer is visible. If not, we skip over the code without drawing the timer. If the timer is visible, we reset the modelview matrix, and position the timer. Because our first grid point from left to right starts at 20, we will add hourglass.x times 60 to 20. We multiply hourglass.x by 60 because the points on our grid from left to right are spaced 60 pixels apart. We then position the hourglass on the y axis. We add hourglass.y times 40 to 70.0f because we want to start drawing 70 pixels down from the top of the screen. Each point on our grid from top to bottom is spaced 40 pixels apart.

After we have positioned the hourglass, we can rotate it on the z-axis. hourglass.spin is used to keep track of the rotation, the same way player.spin keeps track of the player rotation. Before we start to draw the hourglass we select a random color.