.NET Game Programming with DirectX 9.0 P2

Chia sẻ: A Ly | Ngày: | Loại File: PDF | Số trang:20

Thêm vào BST

Báo xấu

236
lượt xem 47
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 Chapter 3 Chapter 4 - .Nettrix: GDI+ and Collision Detection Figure .Netterpillars: a screen into 64 zones Chapter 2 - 1-17: DividingArtificial Intelligence and Sprites

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: .NET Game Programming with DirectX 9.0 P2

.NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - 1-17: DividingArtificial Intelligence and Sprites Figure .Netterpillars: a screen into 64 zones Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ If all we want to know is whether a certain zone contains an object (disregarding which one), we can use Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio bytes (instead of arrays) to store the zone information, where each bit will represent a zone on screen; this Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen is called zoningwith bits. We can divide our screen in zones according to the number of bits on each Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow variable used: 64 (8 × 8) zones with a byte, 256 (16 × 16) zones in an int16, 1024 (32 × 32) zones in an Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API int32, and so on. Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay Using 9 - D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter the zoning with bits method, at each game loop we reset the variables and, for each object, we process anyNonmanaged We then calculate the zone of each object (multiply the current position of the movement. Code Bonus Chapter Porting .Nettrix to on each axis and divide by the width or height of the screen), and set the bit object by the number of zones Pocket PC Appendix A - Theto the result Gaming corresponding State of PC at the x-axis variable and at the y-axis variable, accordingly. We have to set a Appendix bit-ifMotivations in Games second B the sum of the position and the size of the object (width for x axis, height for y axis) lies in another zone. Appendix C - How Do I Make Games? Appendix D - Guidelines for Developing Successful Games If when checking the variables we see that the bit in both variables is already set, then there's an object in Index our zone, so we check all the objects to find out which one it is. Using this method, if we have 15 objects List of Figures on the screen, and only one collision, we'll have to do only one check against a given number of objects List of Tables (14 in the worst case of this scenario), instead of 15 tests with 14 objects. This method has some drawbacks: We don't know which object set the bit, so we have to test all the objects looking for the collision. Some "ghost objects" are created when crossing the bit set for the x zone by one object with the bit set for the y zones by another object, as depicted by Figure 1-18.
.NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 Figure 1-18: Using zone Intelligence and big objects (like the bricks), there'll be lots of "ghost - .Netterpillars: Artificial bits, if we have Sprites Chapter 3 objects." - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen This method is most useful when we want to test a group of objects against other objects (for example, Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow bullets against enemies on screen); if we need to test all the objects against each of the others, we'd Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API better use zoning with arrays of bits, as described in the next section. Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Zoning- Nonmanaged Code of Bits Chapter 9with Arrays Bonus Chapter Porting .Nettrix to Pocket PC If we have a limited number of objects on screen, we can use two arrays, instead of variables, to define Appendix A - The State of PC Gaming our zones. Each object will correspond to a specific bit in the array elements, so we'll use byte arrays to Appendix B - Motivations in Games control 8 objects, int16 arrays to control 16 objects, and so on, and create a mapping table linking each Appendix C - How Do I Make Games? bit with a specific object. The size of each array will define the number of pixels in a zone for each Appendix D - Guidelines for Developing Successful Games dimension. For example, creating two arrays each with 10 positions in a 640×480 resolution, we'll have Index measuring 64 pixels wide by 48 pixels high. zones List of Figures List ofuse the same idea as the previous method to define the zone (or zones) in which each object may be, We Tables and then check to see if both x and y array elements aren't empty. If they aren't zero, and the bits set in both arrays are the same, then we know for sure that there's another object near us (not a ghost object), and only check for collision with the one that corresponds to the bit set. An example of this is shown in Figure 1-19. Figure 1-19: Using zone arrays, we can keep track of which objects are in each zone. The legend
shows the bit set in each array element, for each object. .NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Appendix B - Motivations in Games Appendix C - How Do I Make Games? Appendix D - Guidelines for Developing Successful Games Index List of Figures List of Tables
Extending the Game Programming with DirectX 9.0 Dimension .NET Algorithms to Add a Third by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton There are many advanced algorithms for 3-D collisions described on game-related sites all over the Apress 2003 (696 pages) Internet. We'll not stress©the many implications on including a z axis in the collision detection algorithms; instead we'll just The authors of thisextensionshow easy it can bealgorithms. add some simple text show to the preceding to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest Extending the bounding box algorithm is very straightforward, as shown here: version of Microsoft's Visual Studio. If object1.x The spheres don't collide!!! end if The last proximity test is used for 3-D diamond-shaped objects: Distance = math.abs(Object1.CenterX - Object2.CenterX) + _ math.abs(Object1.CenterY - Object2.CenterY) + _ math.abs(Object1.CenterZ - Object2.CenterZ)
If Distance < Object1.width + Object2.width then .NET Game Programming with DirectX 9.0 => The 3-D diamond objects are overlapping by Alexandre Santos Lobão and Ellen ISBN:1590590511 Else Hatton => The 3-D ©diamonds don't collide!!! Apress 2003 (696 pages) end if The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest In the next sections we'll of Microsoft's Visual Studio. version see how to apply these theoretical ideas in a real game project. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Appendix B - Motivations in Games Appendix C - How Do I Make Games? Appendix D - Guidelines for Developing Successful Games Index List of Figures List of Tables
The Game Proposal .NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton The first step in developing any project is to establish the project's scope and features. Apress © 2003 (696 pages) Note The main purpose forthis text show howproposal is to have clear objectives stated; and everyone The authors of creating a game easy it can be to produce involved in the game creation must agree Managed DirectX 9.0 and interesting multimedia games using on every point. programming with Visual Basic .NET on Everett, the latest For our project we can summarize theVisual Studio. of desired features, as shown here: version of Microsoft's scope in a list Our game will be a puzzle game, and it'll be called .Nettrix. Table of Contents .NET Game Programming with DirectX 9.0 to control falling blocks and try to create full horizontal lines, while The main objective of the game is Foreword allowing the block pile to reach the top of the game field. not Preface The blocks will be made out of four squares (in every possible arrangement) that fall down in the Introduction game field, until they reach the bottom of the field or a previously fallen block. Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 -the blocks are Artificialthe player can move the blocks horizontally and rotate them. When .Netterpillars: falling, Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ When-aRiver Pla.Net: falling, we'll Fields, Scrolling,there are continuous horizontal lines of squares in the Chapter 4 block stops Tiled Game check to see if and DirectAudio game field. Every continuous line must be removed. Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 player gets 100 points per removed line, multiplied by the current level. After every couple of The - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic blocks must start Animation Techniques and Speech API minutes, the KindergarteN. II: falling faster, and the level number should be increased. Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay If the stack of blocks grows untilNonrectangular Windows, and Access to the game ends. D-iNfEcT: Multithreading, it's touching the top of the game field, Chapter 9 - Nonmanaged Code Bonus list contains many definitions that PC important for any game proposal: This Chapter Porting .Nettrix to Pocket are Appendix A - The State of PC Gaming The game genre (puzzle) Appendix B - Motivations in Games Appendix C - How Do I Make the game The main objective of Games? Appendix D - Guidelines for Developing Successful Games Index The actions the player can perform (e.g., to shoot and to get objects) List ofDetails about how the player interacts with the game and vice-versa: keyboard, intuitive interface, Figures List offorce-feedback joystick, etc. Tables How the player is rewarded for his or her efforts (points, extra lives, etc.) How the player gets promoted from one level to the next (in this case, just a time frame) The criteria for ending the game Note In more sophisticated games, there may be other considerations, such as the storyline, the game flow, details about the level design or level of detail for the maps or textured surfaces, the difficulty levels for the game, or even details on how the artificial intelligence (AI) of the game should work.
The Game Project Programming with DirectX 9.0 .NET Game by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton In a commercial game project, the game project starts with a complete game proposal (not just some Apress © and continues simple phrases like ours) 2003 (696 pages) with a project or functional specification. Although the proposal is written in natural The authors ofanyone can understand and approve it (including the Big Boss, who will language-so this text show how easy it can be to produce approve or rejectinteresting multimedia games using Managed DirectX 9.0 and the budget for the project)-the project includes programming details that will guide the development team through the coding phase. .NET on Everett, the latest programming with Visual Basic version of Microsoft's Visual Studio. It's not our objective here to explain what must appear in the project documents (it depends largely on the development methodology used by the team), and we won't create any complete projects since this isn't Table of Contents the focus of the book. But since it's not advisable to start any coding without a project, we'll take a quick .NET Game Programming with DirectX 9.0 look at projects just to make some implementation details clearer. Foreword Preface Of course you can start coding without a project, but even when working alone, a project is the Tip Introduction place to start, since it lets you organize your ideas and discover details that were not clear best Chapter 1before you put pen to paper. Even if the project is just some draft annotations, you'll see that the - .Nettrix: GDI+ and Collision Detection Chapter 2average quality of your code will improve Sprites use. The more detailed the project is, the better - .Netterpillars: Artificial Intelligence and with its Chapter 3your code will be, since they'll help you see the and DirectX vs. GDI+ - Managed DirectX First Steps: Direct3D Basics traps and pitfalls along the way before you fall into Chapter 4them. - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Object-oriented (OO) techniques are the best to use in game projects, because usually games deal with Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow some representation (sometimes a very twisted one) of the real world, as OO techniques do. For example, Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API in Street Fighter, we don't have real fighters on the screen, we have some moving drawings, controlled by Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay the player or the computer, that create the illusion of a fight. Using an OO approach to project creation is roughly - D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9the same thing: We decide the important characteristics from the real-world objects that we want Nonmanaged Code to represent in our program, and write them down. We aren't going to go any deeper into this topic at this Bonus Chapter Porting .Nettrix to Pocket PC stage, but you can find some very good books on this topic. Appendix A - The State of PC Gaming Appendix B - Motivations in Games Since this is our first program, we'll go through the process of making it step by step, in order to demonstrate how we evolve from the game proposal to the final code; in later chapters we'll take a more Appendix C - How Do I Make Games? direct approach. In the next sections we'll see a first version of a class diagram, then pseudo-code for the Appendix D - Guidelines for Developing Successful Games Index main program, and after that we'll go back to the class diagram and add some refinements. game List of Figures The Class Diagram: First Draft List of Tables Let's start with a simple class diagram (shown in Figure 1-20) illustrating the basic structures of the objects for our game, and then we can add the details and go on refining until we have a complete version. Almost all of the object-oriented analysis methodologies suggest this cyclic approach, and it's ideal to show how the game idea evolves from draft to a fully featured project. Figure 1-20: The class diagram-first draft From our game proposal we can see the first two classes: Block, which will represent each game piece, andSquare, the basic component of the blocks. Reviewing our game proposal, we can think about some methods (functions) and properties (variables) for theBlock class, as described in Table 1-1. Table 1-1: The Block Class Members
TYPE NAME Game Programming with DirectX 9.0 .NET DESCRIPTION by Alexandre Santos Lobão and Ellen ISBN:1590590511 Method Down Hatton Makes the block go down on the screen Method Apress © 2003 (696 pages) Right Moves the block right The authors of this text show how easy it can be to produce Method interesting multimediathe block left Managed DirectX 9.0 and Left Moves games using programming with Visual Basic .NET on Everett, the latest Method Rotates the block clockwise Rotate of Microsoft's Visual Studio. version Property Square 1 One of the squares that compose the block Table of Contents Property Square 2 One of the squares that compose the block .NET Game Programming with DirectX 9.0 Property Foreword Square 3 One of the squares that compose the block Preface Property Square 4 One of the squares that compose the block Introduction Chapterblock is composed of fours objects from the Square class, described in Table 1-2. Each 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 1-2: The Square Class Members Table 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio TYPE Chapter 5 NAME DESCRIPTION - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Method Show Draws the square on the screen at its coordinates (Location Chapter 7 - Magic KindergarteN. II: Animation Techniques(Size property), colored with a specific property) and with its size and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games andproperty) and filled with BackColor color (ForeColor Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Hide Method Nonmanaged CodeErases the square from the screen Bonus Chapter Porting .Nettrix to Pocket PC border color Property ForeColor The square Appendix A - The State of PC Gaming Appendix B - Motivations in Games square inside color (fill color) Property BackColor The Appendix C - How Do I Make Games?x,y position of the square on the screen Property Location The Appendix D - Guidelines for Developing Successful Games Property Index Size The height and width of the square List of Figures Comparing the two tables, we can see that there are methods to show and hide the square. Because the List of Tables squares will be drawn from the Block object, we must have corresponding methods in the Block class, and the corresponding properties too. We can adjust the first diagram accordingly to produce Figure 1-21. Figure 1-21: The class diagram-second draft We use SquareSize as the size property for the block, since it's not important to know the block size, but the block must know the size of the squares so that it can create them.
We can return to this diagram later and adjust it if necessary. Let's think now about the game engine, described in the next section.Programming with DirectX 9.0 .NET Game by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton The Game Engine Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce Using the Visual Basic events jargon, we can think about coding three main events to implement the interesting multimedia games using Managed DirectX 9.0 and behaviors described at the game proposal: programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. 1. When the form loads, we can create the first block. 2. At the form KeyPress event, we can handle the keyboard input from the user. Table of Contents .NET3. With a timer we can call the Down method at each clock tick, producing the desired falling effect for Game Programming with DirectX 9.0 Foreword the blocks. As we'll see later, using a timer isn't a recommended practice when creating games that Preface need to run at full speed, but that's not the case here. Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection class diagram, checking whether we use every method Writing pseudo-code is helpful for validating the Chapter 2 - .Netterpillars: Artificial Intelligence and Spritesthe results stated in the game proposal with those and property, and determining whether we can achieve Chaptermembers. The DirectX First Steps: Direct3D is shown inDirectX vs. GDI+ class 3 - Managed pseudo-code for our game Basics and the following code sample: Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Form_Load Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 -Creates an object (named currentBlock) DirectShow class Magic KindergarteN.: Adventure Games, ADO.NET, and of block Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay We'll use the currentBlock object in all other events, so it must have the same scope as the form: D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Form_KeyPress Bonus Chapter Porting .Nettrix to Pocket PC If Left Arrow was pressed, call Left method of currentBlock Appendix A - The State of PC Gaming If Right Arrow was pressed, call Right method of currentBlock Appendix B - Motivations in Games If Up Arrow was pressed, call Rotate method of currentBlock Appendix C - How Do I Make Games? If Down Arrow was pressed, call Down method of currentBlock Appendix D - Guidelines for Developing Successful Games Index List theFigures In of previous pseudo-code, we are using the up arrow key to rotate the block and the down arrow key to List of Tables force the block to go down faster, while the right arrow key and left arrow key move the block in the horizontal direction. The game engine core will be the timer event. Reviewing the game proposal, we see what we must do here: Make the block fall, stop it according to the game rules, check to see if there are any full horizontal lines, and check for the game being over. Possible pseudo-code to do this is shown in the following sample: If there is no block below currentBlock, and the currentBlock didn't reach the bottom of the screen then Call the Down method of currentBlock Else Stop the block If it's at the top of the screen then The game is over If we filled any horizontal lines then Increase the game score Erase the line Create a new block at the top of the screen Analyzing this code, we can see some features our current class diagram doesn't take into account. For
instance, how can we check if there is no block below the current block? How can we erase the horizontal .NET Game Programming with DirectX 9.0 line we just managed to fill? We'll discuss these points in the next section. by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton The Class Diagram: Final Version Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce In order to check interesting multimedia games using Managed are any 9.0 andbelow the current block or if the previous block positions to see if there DirectX blocks there are any filled lines, we must have a Basicto store and check each of the squares of the block, programming with Visual way .NET on Everett, the latest independently of version of Microsoft's Visual Studio. the original blocks (remember, when we erase a line, we can erase just a square or two from a given block). We can do this by creating a new class representing the game field, which will store the information of all squares and have some methods that allow line erasing, among other features. With Table of Contents a quick brainstorm, we can add this class to our model, which will evolve into the diagram shown in Figure .NET Game Programming with DirectX 9.0 1-22. Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Figure 1-22: The final class diagram Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Appendix B - Motivations in Games properties of the new class, along with a short description for each one. Table 1-3 lists the methods and Appendix C - How Do I Make Games? Appendix D - The Gamefor Developing Successful Games Table 1-3: Guidelines Field Class Members Index TYPE NAME DESCRIPTION List of Figures List of Tables Properties Width and Represents the width and height of the game field, measured Height in squares. Property SquareSize Indicates the size of each square, so we can translate pixels to squares. Property ArrGameField Constitutes an array to store all the squares from all the blocks that stopped falling. Method CheckLines Checks if there are any complete horizontal lines, erasing them if so, and returns the number of erased lines so the main program can increase the player's score. Method IsEmpty Checks if the square at a particular location (a given x and y) is empty, therefore telling us when a block is in motion. Method Redraw Forces the full redraw of the game field. This will be used when a line has been erased or when another window has overlapped ours. In a real project, we would possibly go beyond this point, refining all methods to include their interfaces (received parameters and return values) and specifying the data types for the properties, which would probably lead to another revision of our class diagram. But we've got the basic idea here, and that's the main point.
Tip Those interested in looking into project creation in 9.0 depth can find more detailed explanations .NET Game Programming with DirectX more in books by Alexandre Santos Lobão and Ellen covering object-oriented analysis. ISBN:1590590511 Hatton Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Appendix B - Motivations in Games Appendix C - How Do I Make Games? Appendix D - Guidelines for Developing Successful Games Index List of Figures List of Tables
The Coding Phase Programming with DirectX 9.0 .NET Game by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton When coding any project, it's always useful to create drivers and stubs to allow us to test each component Apress © 2003 (696 pages) separately.Drivers are programs that control other lower-level programs, and stubs are programs that mimic low-level programs' behavior, allowing the testing of higher levelto produce provide a vision of a real coding The authors of this text show how easy it can be code. To phase, we'll sometimes usemultimedia games to validate the code written, step by step. interesting such techniques using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest We'll go through version of Microsoft's Visual Studio. to the final code: three versions, from our first draft 1. First draft: Code the Square class. Table of Contents 2. Second draft: Code the Block class. .NET Game Programming with DirectX 9.0 Foreword 3. Final version: Code the GameField class and the game engine. Preface We start coding from the lowest level class, Square, in the next section. Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection First Draft: Coding the Square Class Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 -the game project, we find Fields, Scrolling, andof the class and create the class interface: Reviewing River Pla.Net: Tiled Game the basic structure DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 Class KindergarteN.: Adventure Games, ADO.NET, and DirectShow Public - Magic ClsSquare Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Public location As Point Public size As size Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay Public forecolor As Color D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Public backcolor As Color Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - TheSub Show(WinHandle As System.IntPtr) Public State of PC Gaming Public Sub Hide(WinHandle As System.IntPtr) Appendix B - Motivations in Games End Class Appendix C - How Do I Make Games? Appendix D - Guidelines for Developing Successful Games Index There's nothing here that we couldn't do in the previous version of Visual Basic. In later chapters we'll see List of Figures some improvements brought about by .NET |concerning object orientation. The class methods are shown in List of Tables thenext section. The New and Hide Methods In the Show method all we need to do is to adapt the code for creating a path gradient rectangle we saw in theprevious section. For the Hide method, we can hide the rectangle in an easier way: Since we'll be working with a one-color background (no textures or bitmaps yet), we can simply draw the rectangle again, this time using a solid color, the same as the background. To create a generic code that can be updated later by any programmer, it's always a good idea to not use fixed values inside our program. In our example, we'd better read the game field background color from some variable, so that if it's updated later to another color, our Hide method will still work. This color value should be a property of the GameField class, but since this property doesn't appear in our game project, we'll need to update it with this new property. In a real project it's common for some details (like this one) to only become visible at the coding phase, since it's not possible for the project to predict all possible details. The code for the Square class is shown here: Public Class ClsSquare Public location As Point Public size As size Public forecolor As Color Public backcolor As Color
' Draws a rectangle with gradient path using the properties above .NET Game Programming with DirectX 9.0 Public Sub Show(WinHandle As System.IntPtr) by Alexandre Santos Lobão and Ellen ISBN:1590590511 Dim rectSquare As Rectangle Hatton Dim graphPath (696 pages) Apress © 2003 As Drawing2-D.GraphicsPath Dim brushSquare As Drawing2-D.PathGradientBrush The authors of this text show how easy it can be to produce Dim surroundColor() As Color Managed DirectX 9.0 and interesting multimedia games using Dim GameGraphics As Graphics on Everett, the latest programming with Visual Basic .NET version of Microsoft's Visual Studio. ' Gets the Graphics object of the background picture GameGraphics = Graphics.FromHwnd(WinHandle) Table of Contents ' Creates a path consisting of one rectangle .NET Game Programming with DirectX 9.0 graphPath = New Drawing2-D.GraphicsPath() Foreword rectSquare = New Rectangle(location.X, location.Y, _ Preface size.Width, size.Height) Introduction graphPath.AddRectangle(rectSquare) Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 -' Creates the gradient brushSprites .Netterpillars: Artificial Intelligence and which will draw the square Chapter 3 -' Note: DirectX First one center color and DirectXarray of border colors Managed There's Steps: Direct3D Basics and an vs. GDI+ Chapter 4 -brushSquare = New Drawing2-D.PathGradientBrush(graphPath) River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 -brushSquare.CenterColor Writing Text to Screen River Pla.Net II: DirectInput and = forecolor Chapter 6 -surroundColor = Adventure Games,{backcolor}DirectShow Magic KindergarteN.: New Color() ADO.NET, and Chapter 7 -brushSquare.SurroundColors = surroundColor Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay ' Finally draws the square D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 -GameGraphics.FillPath(brushSquare, graphPath) Nonmanaged Code End Sub Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Public Sub Hide(WinHandle As System.IntPtr) Appendix B - Motivations in Games Dim GameGraphics As Graphics Appendix C - How Do I Make Games? Dim rectSquare As Rectangle Appendix D - Guidelines for Developing Successful Games Index ' Gets the Graphics object of the background picture List of Figures GameGraphics = Graphics.FromHwnd(WinHandle) List of Tables ' Draws the square rectSquare = New Rectangle(location.X, location.Y, _ size.Width, size.Height) GameGraphics.FillRectangle(_ New SolidBrush(ClsGameField.BackColor), rectSquare) End Sub End Class
NEW Visual Basic comes fully packed withnew data9.0 .NET Game Programming with DirectX types. For example, for integer values we have the IN by Alexandre Santos Lobão and Ellen typeinteger, as in the previous versions, plus theISBN:1590590511 int32,int64, representing types int16, Hatton .NET integers of different sizes, and intPtr, which is a special integer type that will use the size of the Apress © pointers (such2003window handles) specific to the destination machine. as (696 pages) The authors of this text show how easy it can be to produce In Visual Basic .NET we can set the initial values of variablesand defining them. A common interesting multimedia games using Managed DirectX 9.0 when programming with Visual Basic .NET on Everett, the latest example is version of Microsoft's Visual Studio. Dim x as integer = 10 Table of Contents .NET Game Programming with DirectX 9.0 Foreword The variable x is created and then the value 10 is assigned to it.When setting initial values to Preface arrays, the values may appear separated with commas and delimited by {}. That's what we see Introduction in the code for the Square class in the line Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - surroundColor = New Color() Sprites .Netterpillars: Artificial Intelligence and {backcolor} Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - surroundColor is an array of Writing with a single element. The following code has the same River Pla.Net II: DirectInput and colors Text to Screen Chapter 6 - effect as the previous line: Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Chapter 8 - Redim surroundColor(1) .Netterpillars II: Multiplayer Games and Directplay Chapter 9 - surroundColor(1) = Nonrectangular Windows, and Access to D-iNfEcT: Multithreading, backcolor Nonmanaged Code Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - This State feature becomes more interesting when dealing with larger arrays. Compare the The new of PC Gaming Appendix B - following codeGames Motivations in samples: Appendix C - How Do I Make Games? Appendix D - Dim myArray () as integer Games 2, 3, 4, 5} Guidelines for Developing Successful = {1, Index List of Figures List of Tables The corresponding code in the previous versions is as follows: Dim myArray() as integer Redim myArray(5) myArray(1) = 1 myArray(1) = 2 myArray(1) = 3 myArray(1) = 4 myArray(1) = 5 In .NET all the arrays must be defined without boundaries, which are later assigned in the code. So we must always use Redim before assigning values to an array. NEW In the Hide method shown previously, we can see an unusual use of the backcolor property:We IN are using the property directly from the class definition, instead of from a previously created object .NET in this class. In this case, we are using a new feature of .NET: the shared properties or methods. Defining a method or a property as Public Shared makes it available for any part of the program directly from the class name, without the need for explicitly creating an object. An important point is that the property or method is shared by all the instances of the objects created from the class. For example, we can have a shared counter property that each object increments when it's created and decrements when it's destroyed, and any object can read this counter at any time in order to see how many objects are available at any given time.
Testing the Square Class .NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Now we are ready to test our program. To do this, we'll need to create a driver to call the class (a window Hatton with a button and a pictureBox will suffice), and a stub for the GameField class, since our Square class Apress © 2003 (696 pages) uses the backcolor property of this class. The authors of this text show how easy it can be to produce The stub is very simple, justmultimedia composed ofManaged DirectX 9.0 and the next sample: interesting a new file games using the code lines shown in programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Public Class ClsGameField Public Shared backcolor As Color Table of Contents End Class .NET Game Programming with DirectX 9.0 Foreword The driver will be replaced by the main program in the final version, so we can implement it as code on the Preface form that will be used as the game user interface. In this case, we can create a simple form with a picture Introduction Chapter 1 - .Nettrix: and a and Collision Detection (picBackground) GDI+ button (cmdStart), with the code to create the objects and set the properties of theclsSquare class, then call the Draw method: Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled GameAs System.Object, e As System.EventArgs) _ Sub CmdStart_Click(sender Fields, Scrolling, and DirectAudio Chapter 5 Handles CmdStart.Click - River Pla.Net II: DirectInput and Writing Text to Screen Dim -objSquare as clsSquare Games, ADO.NET, and DirectShow Chapter 6 Magic KindergarteN.: Adventure Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API objSquare = new clsSquare Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 Set the Properties ' - Nonmanaged Code objSquare.location = new Point (40,20) Bonus Chapter Porting .Nettrix to Pocket PC objSquare.Size = new Size (10,10) Appendix A - The State of PC Gaming objSquare.Forecolor = color.blue Appendix B - Motivations in Games objSquare.BackColor = color.green Appendix C - How Do I Make Games? ' Set the backcolor property of clsGameField class Appendix D - Guidelines for Developing Successful Games clsGameField.backcolor = picBackground.BackColor Index List of Figures ' Draws the square List of Tables objSquare.Draw(picBackground.Handle) End Sub Running the code, we can see the fruits of our labor: a nice, path gradient-colored square is drawn on screen as shown in Figure 1-23.
.NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Hatton Apress © 2003 (696 pages) The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - 1-23: Our first results with GDI+ Figure Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Because in our game the squares won't change color or size, we can assign these values when creating the Chapter 8 creating a New method in the class toand this, as illustrated in the next code sample: objects, - .Netterpillars II: Multiplayer Games do Directplay D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Bonus Chapter Porting New(InitialSize As size, _ Public Sub .Nettrix to Pocket PC InitialBackcolor As Color, InitialForecolor As Color) Appendix A - The State of PC Gaming size = InitialSize Appendix B - Motivations in Games backcolor = InitialBackcolor Appendix C - How Do I Make Games? forecolor = InitialForecolor Appendix D - Guidelines for Developing Successful Games End Sub Index List of Figures List of Tables So the code for our Start button will be as follows: Sub CmdStart_Click(sender As System.Object, e As System.EventArgs) _ Handles CmdStart.Click Dim objSquare as clsSquare objSquare = new clsSquare (new Size (10,10), color.blue, color.green) ' Set the Location of the square objSquare.location = new Point (40,20) ' Set the backcolor property of clsGameField class clsGameField.backcolor = picBackground.BackColor ' Draws the square objSquare.Draw(picBackground) End Sub NEW IN In Visual Basic .NET, the New method is called when an object is created, and receives the .NET parameters used in the object's creation. In the previous versions, the corresponding method was called Initialize, and could receive no arguments.
Now that everything is working correctly, let's continue with the coding by looking at the Block class. .NET Game Programming with DirectX 9.0 by Alexandre Santos Lobão and Ellen ISBN:1590590511 Second Draft: Coding the Block Class Hatton Apress © 2003 (696 pages) We can map the The authors of defined in the how easy it cancreated for our game project, to the final class Block class, this text show class diagram be to produce interesting multimedia games using Managed DirectX 9.0 and interface including the data types for the properties and parameters for the methods. The proposed class interface is shown in the next code Visual Basic .NET on Everett, the latest programming with listing: version of Microsoft's Visual Studio. Public Class clsBlock Table of Contents Public Location as Point .NET Game Programming with DirectX 9.0 Public SquareSize as integer = 10 Private ForeColor As Color Foreword PrefacePrivate BackColor As Color ' The 4 squares that compose the block Introduction Public square1 As ClsSquare Chapter 1 - .Nettrix: GDI+ and Collision Detection Public square2 As ClsSquare Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Public square3 As ClsSquare Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Public square4 As ClsSquare Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Public Function Down() As Boolean Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Public Function Right() As Boolean Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Public Function Left() As Boolean Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Public Sub Rotate() Chapter 8 - .Netterpillars II: Multiplayer Games System.IntPtr) Public Sub Show(WinHandle As and Directplay Public Sub Hide(WinHandle As System.IntPtr) Access to Chapter 9 - D-iNfEcT: Multithreading, Nonrectangular Windows, and Nonmanaged Code End Class Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Appendix B - Motivations we Games In the game proposal, in said that the blocks will be composed of four squares (in every possible Appendix C - How Do can start the coding by thinking about the possible combinations, and give each of them a arrangement). We I Make Games? Appendix D shown in Figure 1-24. name, as - Guidelines for Developing Successful Games Index List of Figures List of Tables Figure 1-24: The square arrangements to form each block Because each block will have a specific square combination, we can think of three new elements for our class: a BlockType property, an enumeration for the block types, and a New method that creates the squares in the desired positions and the color of each square. To give a visual clue to the player, the colors must be fixed for each block type, so it's a good idea to create arrays to hold the forecolor and backcolor for each type. The extra definitions for the class are shown in the next code listing: Public Enum enBlockType UNDEFINED = 0 SQUARE = 1 LINE = 2 J = 3 L = 4 T = 5 Z = 6 S = 7 End Enum
Public BlockType As enBlockType Private backColors() As Color = with DirectX 9.0 .NET Game Programming _ by Alexandre Santos Lobão and Color.Blue,ISBN:1590590511 Color.Yellow, _ {Nothing, Color.Red, Ellen Color.Red, Hatton Color.Green, Color.White, Color.Black} Apress © 2003 (696 pages) Private foreColors() As Color = _ The authors of this text show how easy it can be to produce {Nothing, Color.Purple, Color.LightBlue, Color.Yellow, _ interesting multimedia games using Managed DirectX 9.0 and Color.Red, Color.LightGreen, Color.Black, latest programming with Visual Basic .NET on Everett, the Color.White} version of Microsoft's Visual Studio. The New Method Table of Contents TheNew method will receive two parameters: the block type and the location where the block will be created. .NET Game Programming with DirectX 9.0 Foreword need random block types, we can make the block type parameter optional, and choose a new Since we Preface type inside the New procedure when this isn't given. The default value for the optional parameter must block be the UNDEFINED member of the block type enumeration, so we know when the block type isn't given by Introduction Chapter 1 function. GDI+ and Collision Detection the caller - .Nettrix: Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites We won't use the optional parameter immediately, but it's a good idea to create code following this pattern, Chapter 3be able to test a specific block type easily. For example, if the Rotate procedure doesn't work well so we'll - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ Chapter 4 block type, we can call the New function with the corresponding parameter to allow us to do the for the T - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5Code to do this is shown in the following listing: to Screen testing. - River Pla.Net II: DirectInput and Writing Text Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow Chapter 7 Public Sub New(locationII: Animation Techniques and Speech API - Magic KindergarteN. As Point, _ Chapter 8 - .Netterpillars II: Multiplayer Games and DirectplayenBlockType.UNDEFINED) Optional newBlockType As enBlockType = D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code ' Create the new block, chooses a type if not informed Bonus Chapter Porting .Nettrix to Pocket PC If newBlockType = enBlockType.UNDEFINED Then Appendix A - The State of PC Gaming Randomize() Appendix B - Motivations in Games Int(Rnd(7) * 7) + 1 BlockType = Appendix C -ElseDo I Make Games? How Appendix D - Guidelines for Developing Successful Games BlockType = newBlockType Index End If List of Figures List of Tables' Create each of the squares of the block ' and set the square colors, based on the block type square1 = New ClsSquare(New Size(squareSize, squareSize), _ backColors(BlockType), foreColors(BlockType)) square2 = New ClsSquare(New Size(squareSize, squareSize), _ backColors(BlockType), foreColors(BlockType)) square3 = New ClsSquare(New Size(squareSize, squareSize), _ backColors(BlockType), foreColors(BlockType)) square4 = New ClsSquare(New Size(squareSize, squareSize), _ backColors(BlockType), foreColors(BlockType)) ' Set the squares' positions based on the block type Select Case BlockType Case enBlockType.SQUARE ' Creates a Square block Case enBlockType.LINE ' Creates a Line block Case enBlockType.J ' Creates a J block Case enBlockType.L ' Creates an L block Case enBlockType.T ' Creates a T block Case enBlockType.Z
' Creates a Z block Case Game Programming with DirectX 9.0 .NET enBlockType.S by Alexandre' Creates an S block Santos Lobão and Ellen ISBN:1590590511 Hatton End Select Apress © 2003 (696 pages) End Sub The authors of this text show how easy it can be to produce interesting multimedia games using Managed DirectX 9.0 and programming with Visual Basic .NET on Everett, the latest In this sample, the code of Microsoft's Visual Studio. must set the square positions, based on each block version inside each case statement type, according to Figure 1-24. For example, let's analyze the Square block type, depicted in Figure 1-25. Table of Contents .NET Game Programming with DirectX 9.0 Foreword Preface Introduction Chapter 1 - .Nettrix: GDI+ and Collision Detection Chapter 2 - 1-25: The squares forIntelligence and Sprites Figure .Netterpillars: Artificial the Square block type Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. GDI+ The code for creating the Square block type is shown here: Chapter 4 - River Pla.Net: Tiled Game Fields, Scrolling, and DirectAudio Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Case enBlockType.SQUARE Chapter 6 - Magic KindergarteN.: Adventure Games, ADO.NET, and DirectShow square1.location = New Point(location.X, location.Y) Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API square2.location = New Point(location.X + SquareSize, location.Y) Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay square3.location = New Point(location.X, location.Y + SquareSize) D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter square4.location = New Point(location.X + SquareSize, _ 9 - Nonmanaged Code location.Y + SquareSize) Bonus Chapter Porting .Nettrix to Pocket PC Appendix A - The State of PC Gaming Appendix B - Motivations in Games As for the Line block type, the squares that compose it are shown in Figure 1-26. Appendix C - How Do I Make Games? Appendix D - Guidelines for Developing Successful Games Index List of Figures List of Tables Figure 1-26: The squares for the Line block type The code for the Line block type is as follows: Case enBlockType.LINE square1.location = New Point(location.X, location.Y) square2.location = New Point(location.X, location.Y + SquareSize) square3.location = New Point(location.X, location.Y + 2 * SquareSize) square4.location = New Point(location.X, location.Y + 3*SquareSize) The code for the other blocks follows the same idea. For the full code of the New method, check the samples on the accompanying CD-ROM. Once the blocks are created, we can start coding the moving operations over them, as described in the next
section. .NET Game Programming with DirectX 9.0 The Down, Right, and Left Methods Ellen by Alexandre Santos Lobão and ISBN:1590590511 Hatton Apress © 2003 (696 pages) The next methods, following the class diagram order, are Down,Right, and Left. These methods are fairly simple, since all we need to do is to text show how easy it can be to produce direction, regardless of the block The authors of this update the block position in the defined type. The basic code for themultimedia games could Managed DirectX this:and interesting Down procedure using be as simple as 9.0 programming with Visual Basic .NET on Everett, the latest version of Microsoft's Visual Studio. Public Function Down() As Boolean Down = true Table of Contents ' Hide the block (in the previous position) .NET Game Programming with DirectX 9.0 Hide(ClsGameField.WinHandle) Foreword Update the block position ' Prefacesquare1.location=New Point(square1.location.X, _ Introduction square1.location.Y + SquareSize) Chapter 1 - .Nettrix: GDI+ and Collision Detection square2.location=New Point(square2.location.X, _ square2.location.Y + SquareSize) Chapter 2 - .Netterpillars: Artificial Intelligence and Sprites Chapter 3 - Managed DirectX First Steps: Direct3D Basics and DirectX vs. _ square3.location=New Point(square3.location.X, GDI+ Chapter 4 - River Pla.Net: Tiled Game Fields, square3.location.Y + SquareSize) Scrolling, and DirectAudio square4.location=New Point(square4.location.X, _ Chapter 5 - River Pla.Net II: DirectInput and Writing Text to Screen Chapter 6 - Magic KindergarteN.: Adventure square4.location.Y + SquareSize) Games, ADO.NET, and DirectShow ' Draw the block in the new position Chapter 7 - Magic KindergarteN. II: Animation Techniques and Speech API Show(ClsGameField.WinHandle) Chapter 8 - .Netterpillars II: Multiplayer Games and Directplay End Function D-iNfEcT: Multithreading, Nonrectangular Windows, and Access to Chapter 9 - Nonmanaged Code Bonus Chapter Porting .Nettrix to Pocket PC Because we'll need to hide and redraw the block every time these methods are called, we can reduce the Appendix A - The State of PC Gaming shared property on the GameField class, the WinHandle used in the calling overhead by creating a new Appendix B - Motivations in handle of the pictureBox used as the game field on the form. With this approach, preceding code, and the Games Appendix set this property in the New method and use it for every drawing operation, instead of passing the we can C - How Do I Make Games? Appendix as - Guidelines for Developing Successful Gamestime it's called. handle D a parameter to the drawing methods every Index TheRight and Left methods will be similar to this one, except this time the horizontal block position is List of Figures changed-incrementing it to move the block to the right and decrementing it to move the block to the left. We List of Tables are moving the blocks using the default value of the SquareSize property, assigned to 10 in the class definition. This means that the blocks will always move a square down, left, or right, so we don't have to take worry about the squares' alignment. There's one more detail to include in this procedures: the test for collision detection. The block can't move down, left, or right if there are any squares (or screen limits) in the way. Since the block itself can't know if other blocks are in the way, it must ask the GameField class if it can move this way. We already thought about this in the game project: The IsEmpty method of the GameField class will check if a specified square in the game field is empty. In the Down method, we must check if there are any blocks in the way and stop falling if we hit an obstacle. When the block stops falling, we must inform the Game-Field class of this, so it can update its internal controls to allow the proper function of the IsEmpty method. We can do this by creating a new method, namedStopSquare, which will inform the GameField that a specific square is now not empty, and pass the square object and its coordinates as parameters. After that, each square will be treated separately from each other (no more blocks) by the GameField class, because when a line is removed, some squares of the block can be removed while others remain. Since the IsEmpty and StopSquare methods are based on an array of Squares,ArrGameField (as defined in our game project), the logical approach is for these methods to receive the array coordinates to be used. We can translate screen coordinates to array positions by simply dividing the x and y position of each square by the square size. The final code for the down procedure will now be as follows: