| Tricks 
                                of the Windows Game Programming GurusAuthor: Andre' LaMothe
 Publisher: Sams Publishing
 Published: First Published October 1999
 ISBN: 0-672-31361-8
 Purchasing: [Amazon.Com] 
                                [Fatbrain.Com] 
                                - RRP US$49.99
 Reviewed: 31st August 2001
 Front 
                                Cover Shot: (nb: 
                                this image is a little faded because my copy of 
                                the book has been sitting in the sun for too long!!) First 
                                Impressions Okay, 
                                first impressions are of a very complete book 
                                - weighing in at 1005 pages and including a CD 
                                of everything in the book - there's plenty of 
                                material to dig your teeth into here. The book 
                                truly does cover pretty much everything you need 
                                to know to get started with game programming - 
                                with the only exception that there almost no mention 
                                of 3D graphics, but we are promised that this 
                                is to be covered in volume 2 of the series. The 
                                book is divided into 4 main sections: Part 
                                1 - Windows Programming, this covers the basic 
                                facilities provided by windows for multimedia 
                                programming.Part 2 - DirectX and 2D Fundamentals, this gets 
                                stuck into the low-level high-performance multimedia 
                                programming.
 Part 3 - Hardcore Game Programming, this covers 
                                AI, physics, data handling and then a final game 
                                example
 Part 4 - Appendices and reviews, covers some FAQ's 
                                and an intro to maths and C++ required for game 
                                programming.
 If 
                                you further explore the contents pages you will 
                                quickly see the huge depth of this book - the 
                                contents take up 12 pages of this book; there 
                                really is that much in here. Going 
                                Deeper, Analysing the content There 
                                is one thing straight away that may cause problems 
                                here - all code examples are in C, which is fair 
                                enough really as it is probably the most popular 
                                game programming language; but this is a visual 
                                basic site - and the chances are that you are 
                                a visual basic programmer. Personally this doesn't 
                                actually bother me, as if you are a competent 
                                programmer in VB then you can almost always work 
                                out whats going on with the code in this book 
                                - and you can quite often transfer it to VB with 
                                little change. It is definately advisable to have 
                                at least read a C programming book, or be familiar 
                                with the language - otherwise you may well miss 
                                out on a lot of this book. The language difference 
                                has one other problem for VB programmers - pointers! 
                                C/C++ programmers live and die by using pointers, 
                                and hence this book is filled with them - but 
                                as you are probably aware, visual basic has no 
                                such things (well, technically you can emulate 
                                them, but they aren't proper). This means that 
                                some code samples are very difficult to rewrite 
                                because you have to try and rewrite it without 
                                the pointers. The 
                                other important factor, and I believe this is 
                                one of the most important factors for a technical-based 
                                book - writing style. Andre' LaMothe has an excellent 
                                writing style, it really is a joy to read. Unlike 
                                some technical books, which have the reader-friendliness 
                                of a large dictionary, you get the feeling that 
                                Andre' LaMothe is actually explaining it to YOU, 
                                he may as well be standing there explaining it 
                                to you really. This is all important as I will 
                                explain later, because some of the content is 
                                quite complicated and advanced. Now 
                                what about the stuff I'm going to learn - I here 
                                you ask! Well, there are a lot of things in here 
                                to learn - as is shown at the end of the book, 
                                it is more than possible to write a complete game 
                                using only what was learnt in this book (Andre' 
                                LaMothe uses an asteroids clone as a worked example). 
                                The AI and physics sections, whilst being only 
                                in 2D are still all relevent - and will remain 
                                relevent (physics rarely changes that much!!), 
                                and whilst Artificial Intelligence is always progressing 
                                at dramatic rates the old stuff is still perfectly 
                                expandable, usable and acceptable (There is a 
                                nice section on Fuzzy Logic, which is still quite 
                                a recent technology, and an introduction to Genetic 
                                algorithms). The 
                                first section of the book is an interesting read 
                                (particularly the history section), but it's particularly 
                                aimed at C programming/Win32 programming. Whilst 
                                you can very very easily use Win32 techniques 
                                in VB (just use the API-Viewer to find the relevent 
                                functions), a lot of it isn't incredibly useful 
                                unless you plan to use C/C++ as well as VB. Technology 
                                in action As 
                                far as the technology used in the book is concerned, 
                                well, it's starting to show it's age considerably. 
                                It is by no means useless, as it is still perfectly 
                                possible to learn from, but with most people now 
                                working with 3D graphics, or wanting to... There 
                                are large sections of the book that are all about 
                                triangle rasterization and using 256 colours/8 
                                bit palettes - all of which is quite interesting 
                                to read, isn't too important if you're writing 
                                a game using 16/24/32 bit DirectDraw / Direct3D 
                                - as it'll handle 90% of all that. Again, we are 
                                promised that the second volume will delve into 
                                16 bit/32 bit and 3D acceleration - but that's 
                                the second volume, which (at time of writing) 
                                isn't out yet. Also, 
                                the book has a large section on using DirectX 
                                - which is good, but it uses the much older versions, 
                                which aren't supported in visual basic officially, 
                                and anyway are pretty dated now (we're talking 
                                about DirectX 6.1 and below here). Whilst many 
                                of the functions used still have equivelents in 
                                DirectX 7.0 it's a completely different world 
                                to the current DirectX 8.0... on top of that, 
                                it's all in C again, which whilst similiar is 
                                a bit more complicated than in visual basic (VB 
                                hides alot of the complicated stuff for us). With 
                                all this considered, if you are planning on making 
                                a game (especially if it's 3D) using some more 
                                modern concepts/features then this book probably 
                                wont cover them; even simple things like the A* 
                                path finding algorithm, whilst mentioned, isn't 
                                covered at all. Whilst it's to be expected, most 
                                of the clever stuff is mostly with respect to 
                                2D games - no 3D algorithms are present really. Finishing 
                                things off I've 
                                now covered the important aspects of this book, 
                                but there are a couple of things that I need to 
                                cover before letting you decide whether you want 
                                this book. The 
                                CD included with the book isn't just a dumping 
                                ground for all the source code (it is all there 
                                though), it also has the DirectX 6.1 SDK and VC++6.0 
                                trial version - not of huge interest to most VB 
                                programmers, but you never know. What is interesting 
                                however, is the online digital books - both about 
                                3D graphics, whilst neither of them were written 
                                by Andre' LaMothe himself, they are still worth 
                                a read. Again they aren't the most technical 3D 
                                books ever written, but they're still of good 
                                quality, and cover alot of what you may need to 
                                know when diving into the world of 3D graphics. Then 
                                there are the appendices - as well as being a 
                                good all round book, Andre' LaMothe has made it 
                                an excellent resource as well - there is a section 
                                on Maths, whilst it aint gonna teach you maths 
                                its great if your a little rusty on the intermediate/basic 
                                level stuff. There's also a primer to C++, which 
                                again is only brief, but will give you an overview 
                                of what you need - should you need more you can 
                                then go onto a proper C++ book.  Now 
                                then, I dont want to give this book (or any others 
                                that I read) a numerical score, a number of stars 
                                or anything stupid like that. As I see it, what 
                                I judge as 80% (for example) is worth 99% to others, 
                                and 10% to a few. Thus I will provide you with 
                                a summary table of what I think is good, and what 
                                is bad - and you can make the choice yourself. 
                                
                                   
                                    | Good 
                                      Things | Bad 
                                      Things |   
                                    |  
                                      Lots and lots and lots to read |  
                                      Uses C/C++ for all code examples |   
                                    |  
                                      Excellent writing quality/style |  
                                      Starting to show it's age with respect to 
                                      technology |   
                                    |  
                                      Covers pretty much everything you need |  
                                      No real coverage of 3D graphics |   
                                    |  
                                      Will teach you a lot about how *real* games 
                                      are made. |  
                                      Quite a few sections not at all relevent 
                                      to visual basic game development |   
                                    |  
                                      Not very expensive for the amount of content 
                                      (US$0.05 per page) |  
                                      Some code is difficult to port over to VB 
                                      due to language differences |   
                                    |  
                                      Includes CD |  
                                      Uses a version of DirectX that isn't available 
                                      for visual basic, and is very very different 
                                      to the new versions of DirectX (v8+) |     |