generate barcode in c# windows application Understanding spatial grid collision in Font

Creation Code 128C in Font Understanding spatial grid collision

We know that our game world is a grid of cells. All the objects in the game, moving or stationary, occupy a cell. The cat can collide only with objects that are in adjacent cells, so we just need to check the contents of those cells. If any of them contain objects that the cat needs to collide with, we will run a collision check on those objects. To get you started thinking about this problem, I have a puzzle for you. Figure 8-12 is an illustration of a simple game world grid. The cat is in a cell at the center of the grid. Looking at that grid, can you tell which cells you need to check for collisions Take a moment to think about it, and try not to peek at the answer.

Figure 8-12. Puzzle 1: Which grid cells do you need to check for collisions Now I feel bad ... it was a trick question! The only cell that needs to be checked is the center cell that the cat occupies, 2-2. The cat is completely inside a single cell, so there s no likelihood that it will come into contact with any object from an adjacent cell. But as you can see from the PlatformCollision SWF, the cat is hardly ever neatly contained within a single cell. It runs and jumps freely all over the stage, and is usually between cells. It s very likely that the cat will overlap more than one cell. Figure 8-13 shows the second puzzle. The cat is overlapping four cells. Can you figure out which cells need to be checked for a collision

Figure 8-13. Puzzle 2: If the cat is overlapping more than one cell, which cells do you need to check for a collision The answer is that you must check every cell that the cat s four corners occupy. As shown in Figure 8-14, these are cells 1-1, 2-1, 1-2, and 2-2. By the cat s four corners, I mean the tips of the cat s left and right ears, and the ends of its left and right paws.

Figure 8-14. Find out which cells the four corners of the cat are in, and check those cells for collisions. There are ten platforms on that grid. You don t need to do a collision check with all ten of them. Instead, you check the cat s four corners, and if any of those corners are in a cell that is occupied

by a platform, you do a collision check on that cell. In a typical platform game where you might have hundreds of platforms, this is a huge savings. At most, you ll need to check for four platforms each frame. Even if your game has a thousand platforms, you ll never need to do more than those four checks. But of course, this all hinges on knowing which cells the cat s four corners occupy. How can we figure this out

Let s first look at how we can figure out which cell the center of the cat occupies. To do this, find its center x and y stage position and divide it by the maximum tile size (64). Round it down to truncate the remainder. (This assumes the cat s xPos and yPos position is its top-left corner). column = uint((cat.xPos + cat.width * 0.5) / 64); row = uint((cat.yPos + cat.height * 0.5) / 64);

This is the same formula we looked at earlier in the chapter. Figure 8-15 illustrates how to find the cat s position.

Now we know the column and row of the cat s center point. To find its corner points, all we need to do is apply the same formula to the cat s corner points: top left, top right, bottom left, and bottom right, as shown in Figure 8-16.

Figure 8-16. Apply the same formula to the cat s four corner points to find out which cells you need to check for collisions. Calculating these points is basic to tile-based games, and the custom TileModel class introduced earlier in this chapter does this for us automatically. Remember that after the listing of that class, I told you to ignore the get methods at that time, because they wouldn t make sense to you yet. Now they certainly should make sense. Here are the getters from the TileModel class: public function get top():uint { var top:uint = uint(yPos / _maxTileSize); return top; } public function get bottom():uint { var bottom:uint = uint((yPos + height) / _maxTileSize); return bottom; } public function get left():uint { var left:uint = uint(xPos / _maxTileSize); return left; } public function get right():uint { var right:uint = uint((xPos + width) / _maxTileSize); return right; }

public function get { var centerX:uint return centerX; } public function get { var centerY:uint return centerY; }

centerX():uint = uint((xPos + width * 0.5) / _maxTileSize);

centerY():uint = uint((yPos + height * 0.5) / _maxTileSize);

You can use these six values to find the columns and rows for all the corner points plus the object s center point. Here s what s you need to do this: A TileModel object A platform map array that contains the tile ID numbers of the platforms The ID numbers for the platform tiles, such as 00 On each frame, you check which cells on the map the TileModel object s four corners are overlapping. Here s a simplified, pseudo code version of how this all works: var _platformMap:Array = [ [10,10,10,10,10,10,10,10,10,10], [00,00,10,10,10,10,10,10,10,10], [10,10,10,10,10,00,00,00,00,10], [10,10,00,10,10,10,10,10,10,10], [10,10,10,10,10,10,10,10,10,10], [00,00,00,00,10,10,10,00,10,10], [00,00,00,00,00,10,10,10,10,10], [00,00,00,00,00,00,00,00,00,00] ]; var platform = 00; var tileModel = new TileModel(MAX_TILE_SIZE, etc ); enterFrameHandler { //Move the tile model around the stage //Start the spatial grid, broad-phase collision check: //1. Check the top-left corner if(platformMap[tileModel.top][tileModel.left] == platform) { //Perform a narrow-phase collision check }