Gaming, Graphics, Programming, Review

Review: Game Programming Algorithms and Techniques: A Platform-Agnostic Approach by Sanjay Madhav

GameProAlgo

Game Programming Algorithms and Techniques is one of those books that tries to be as general as possible, and I believe the author was successful in that. Too many books target one specific piece of software or even one particular version of a framework and end up becoming dated rather quick. However, the core ideas in game development have not fundamentally changed in a while. Sure graphics get better, and there are more complexities to working with modern hardware, but the programming algorithms themselves are still very much the same.

Sanjay Madhav starts the book with an overview of some classic games, how a game loop works, handling timing in games, and the idea of game objects. Next he discusses 2D games, sprites, scrolling, and tile maps. There is a quick chapter on linear algebra. Then the author continues with a treatment of 3D graphics, including  coordinate spaces, lighting and shading, visibility and transformation. Handling input is covered as is sound. There is a chapter on physics, which I much appreciated, and then some quick coverage of cameras, artificial intelligence, user interface, scripting, and networking. Finally, the book closes with two example projects.

The author does a great job of explaining complex concepts in easy to understand language, especially in the math and physics chapters, which could be confusing otherwise. One of the pieces that I gained a lot from was the explanation of mouse picking 3D objects, which was described beautifully and made a lot of sense.  The chapter on scripting languages was also helpful and relevant.

Overall I enjoyed the book, and think it would be helpful to beginning programmers, or experienced coders in other fields looking to get into game development. I feel that for intermediate to advanced game programmers, much of this book will be a review. Not to knock the book for that, though, I think it’s a great book if you understand the audience it’s aiming for. I mean, there were even a few bits of information that were new to me, however much of the book was about stuff I’ve seen before.

That said, I do like to read texts of various levels, and even beginner books can help you look at familiar problems in new ways. So I think it’s very much worth reading, especially if you are just starting out in game development.

C++, Gaming, Review

Review: Programming Game AI By Example by Mat Buckland

ProgrammingAI

Programming Game AI By Example by Mat Buckland is one of those books that comes highly recommended and was one I had been meaning to read for a long time. In fact, I originally purchased the paperback in 2006 and never got around to reading it. The interesting part is that the book is still very much relevant today and is not dated in the least. Well now maybe some of the engines and middleware have this stuff built in, but the fundamentals I think I still important to understand.

The book starts with a quick primer on math and physics. The basics are explained, like Cartesian coordinates, trigonometry, vectors, coordinate spaces, and some physics. Like most people reading a book of this level, the beginning was a light refresher. However, I’m a big stickler for reading books from cover to cover with no skipping around, so I did not mind a short recap. Next Buckland gets into state-driven design and demonstrates a simple command-line app using the concepts. I found this approach successful, and it was able to show the concepts without complex 2D or 3D math getting in the way.

He followed up with autonomous moving agents, mostly based on steering behaviors. I was already somewhat familiar with steering behaviors, but I found the author’s description and code to be clear and concise and explained the concept better than I’ve seen before. He then applies the previous topics to a simple soccer game. This was a great next step, and really compiled the knowledge being taught into something concrete. In the next chapter, the author went into graphs; what they are, how to use them, and some popular algorithms link Dijkstra and A*. I always wanted to know what A* was, and this book explains it fairly well.

Buckland then devotes a section to cover scripting languages and why they are useful. In this case, he chose Lua (not a bad choice) and explains some basics about the language, how to interface it with C++, and creates a simple finite state machine. This chapter is helpful even if you’re not coding AI and just need a scripting language for your game or engine (provided you like Lua). In fact, a lot of the concepts in this book are generic enough that they can be applied to multiple fields of interest for game developers.

Next, the author creates a simple overhead game framework used in the subsequent examples. Using this framework he then shows practical path planning, goal driven agent behavior, and finishes up with fuzzy logic. Fuzzy logic is another one of those buzzwords that always intrigued me but I never really understood. Buckland concludes with a quite excellent explanation of the concept.

Overall I found this book to be stellar on all accounts. I feel that any game developer could gain insight from this text, even if they aren’t primarily working with AI programming. The scripting coverage could be used in many games, and the algorithms covered are generic enough to apply to different disciplines. While this is the first book I’ve read on AI, I really can’t imagine a better introduction. Highly recommended.

Gaming, Review, Unity

Review: Getting Started with Unity 5 by Dr. Edward Lavieri

GettingStartedUnity5

Getting Started with Unity 5 is mostly what it bills itself as: a way to get started in Unity for beginners. The book is clearly targeting beginners, and takes the reader from having never used Unity to making a simple farming-type game. I enjoyed reading it (in the whole 3 days it took to finish), however I’m not sure exactly how much I learned (if anything at all).

At 195 pages, the book is not extremely thorough, but does cover a lot of the basic fundamentals of game development with Unity. Unfortunately, that coverage is brief and only really scratches the surface. Some of the topics featured include: downloading Unity (an easy one), the editor views like scene/game/project/etc., game design, importing assets, animation, C# scripting, UI, and sound. Looking at that list, it seems like a lot of stuff, but some chapters are barely even 20 pages long. Not that it’s bad as an introduction, it could be a good place to start, but I feel for experienced developers the book falls short.

Besides the brevity of the coverage, I found some of the instructions confusing. For example, on the topic of programming, the author explains how to code different animals in a farm to do similar things like eat or have babies. This would seem like a classic text-book example for using object-oriented programming principles. Instead, the author concocts some cryptic array of numbers, where a 0 means a pig and a 1 a chicken or something or another. Not to say that this won’t work, sure, it will compile. It’s just not a great way to teach programming concepts to a beginner.

I don’t especially like giving bad reviews, and I don’t want to say the book is bad. It’s titled as a “getting started” book and that’s just what it is. I’m just not sure it’s the best instruction for a beginner, and the programming sections in particular were lacking for me. There are not many Unity 5 specific books available today but, truthfully, much of what’s covered in this book would have worked the same in Unity 4. Even so, the older Unity books I’ve read were much more comprehensive and useful than this one. So if you’ve just started to learn now, this book may be worth picking up as a quick intro if you understand it’s not very deep at all. Experienced Unity developers should keep moving.

3D Modeling, Art, Gaming, Graphics, Review

Review: How to Become a Video Game Artist: The Insider’s Guide to Landing a Job in the Gaming World by Sam R. Kennedy

VideoGameArt

So I am actually not looking to try to break into the game industry as an artist. Why did I read this book? Well, I am very much interested at upping my game when it comes to real-time graphics and content creation as a hobby. Computer graphics are just fascinating to me, and the best engine and shaders in the world will not save a shabby piece of art. This book seemed like a good way to get into the artist mindset. To top things off, the sticker-price was a palpable $12 dollars and the cover art looked great (important when taking art direction).

Basically what the book amounts to is a series of chapters, each one describing a particular game art profession. Some of the jobs detailed include: concept, environment, character, ui, and marketing artists. Every chapter includes a job description, explanation of the process or workflow, example images, an artist profile, and finally a mock “help wanted” ad that could be for the position. The format is informative, and I think would be very helpful for a student looking to get into the industry as an artist. Certainly, you don’t have to be a student to find worth in this book and I personally feel it is a great choice if you are at all interested in video game art.

The author, Sam R. Kennedy, is a game artist himself and shares a some of his (quite impressive) work within these pages. Nicely, the photos on the Kindle e-book were in color. This is quite important, and in my research I did stumble upon some game art instruction books from people with questionable artistic ability. Of course, you don’t need to be da Vinci to make a 3d model (especially not when working from good photos or concept art) but I can’t help but wonder what I’m doing taking advice from an amateur. That was not the case with this text. Kennedy is a veteran and has worked at Ubisoft on Tom Clancy games and the like. I felt pretty comfortable accepting his opinions.

All in all, I was happy with the purchase and I’m glad to have the book in my collection. If it helps me (even a little bit) in improving my art that’s a net positive. In any case, it was inspiring and that’s enough for me.

Art, Gaming, Review

Review: Drawing Basics and Video Game Art: Classic to Cutting-Edge Art Techniques for Winning Video Game Design by Chris Solarski

GameArt

I’ve been trying to get back into making art (I did go to art school, after all) and this seemed like a well reviewed book. Plus, the Kindle edition was very reasonably priced at $12. Drawing Basics and Video Game Art: Classic to Cutting-Edge Art Techniques for Winning Video Game Design by Chris Solarski is not a long book (at 240 pages) but it’s well worth reading.

It almost seems like it’s two different books sandwiched together. The start is with basic drawing techniques and a study of classical artists. Anatomy, proportions, perspective, composition and layout, etc. Then the second part is more of a study of modern games with things like how color sets a mood, use of different shapes to evoke feelings, horizon lines, etc. It’s all very interesting, and I think would be helpful to not just artists but anyone working in gaming.

Just be aware, the book doesn’t really teach you how to be a good artist. There are various topics covered that can certainly help an artist, but there is little direct instruction (outside of the brief introduction at the beginning). I don’t think that was the author’s intention, and there are really tons of more general art books out there if you are so inclined. Drawing Basics and Video Game Art is more about theory and I feel the author is successful in that aspect. Solarski also managed to get screenshots of many popular games to analyze in the text, and thankfully all the images were in full color on my Kindle Fire tablet.

Overall, I liked the book and I think you will too.

3D Modeling, Gaming, Graphics, Review

Review: 3ds Max Modeling for Games: Insider’s Guide to Game Character, Vehicle, and Environment Modeling: Volume I by Andrew Gahan

3dsMax

If you’re working with 3ds Max, or even similar packages, I think this book holds some insight. I’ve tried a few different modeling packages, but somehow Max just seemed to click better for me. Maybe it’s because it was the first one I started learning with, or maybe it’s popular for a reason. Not sure, but I think it’s a very capable product (especially for game development). 3ds Max Modeling for Games shows you how to do some basic (and not so basic) modeling tasks in the app. I found the instruction to be detailed and clear, though at times it can be very specific to the package.

So what does Andrew Gahan show you here? Well, he goes through some basics of working with the 3ds Max interface, terminology for game art, and texturing. Then he shows how to create, unwrap, and texture a simple model. Creating a more complex model (sort of a floor sweeper thing), vegetation and alpha maps, a low-poly vehicle, normal mapping techniques, an entire 3D environment, and finally a high and low poly character. Quite a good assortment of chapters and each one was fully fleshed out.

I did appreciate that the author goes through each step, even simple stuff other books may gloss over. In some cases, as I started reading I was questioning the method he was using, but eventually he made it work. While the text is very focused on the one specific application, I do think that artists (or aspiring artists) could glean knowledge from the techniques and apply them to other packages. However, this would not be the first book I went to if I was using Maya or whatever.

Overall I feel like I learned a couple neat tricks, and after reading the book I feel a little more confident in my modeling skills. Will really need to put this to the test soon, as I’ve been dying to create some nice art to work with building graphic demos and whatnot. Looking at programmer art all day is just not as motivating. I have plans of creating a realistic-style apartment, and I think it’s something reasonable to get finished. Down the road, I’d love to do a full character, but I’ve always struggled with this in the past. At least now that I’ve switched to Unreal, I can free up some of my effort to focus on art since I know the engine will support whatever I throw in there (and make it look good!). Looking forward to checking the Volume II in the series shortly.

3D Engine, Game Engine, Gaming, Graphics, Unreal

Making Pong in Unreal Engine 4 (My Very First UE4 Game!)


 

Today I’d like to unveil what I’ve been working on for about 2 weeks: Pong in Unreal Engine 4. Most of that time was spent reading documentation and watching tutorial videos just to figure out the basics. There is actually a *lot* of good material out there for Unreal Engine 4, the docs have been helpful and there are plenty of videos. Disappointingly, there are barely any books out there for the engine, but I’m sure that will change quickly.

Pretty much anyone will tell you, when you are learning to develop games (or switching to a new engine/platform), the best thing to do is to start small and try to complete something. It’s really silly to try to make an MMORPG as your first game (I have fallen for this one!) and even relatively simple things can become complex fast when you are not familiar with the platform. So I chose to do Pong as my first excursion into Unreal 4. It was not without some trials, but I made it through alive. Oh, and, no. This will not be considered my “finished project of the new year”. There are some other, cooler, things I have in mind.

Previously I was making multi-part blog posts with basically quick status updates. This was fine, but I think it will be more helpful for the community for me to do focused tutorials on a specific topic and post those more frequently. I learned quite a lot about Unreal with this project, and I think I can share some of that on this site. Some of the things I picked up working on this demo include: importing assets, working with Blueprint, basic flow and logic, movement, collision, HUD, events, keyboard control, functions and variables, and just getting familiar with the Unreal Editor interface. Not sure I will make tutorials on everything, but I plan to break this into a few posts. Below you can see the level Blueprint for the game, just to give you an idea of the complexity.

UE4_Pong_BP

Overall I have been impressed with Unreal Engine 4, and I can’t imagine purchasing a more capable piece of commercial software for less than the pennies they are giving this away for. People can complain about the 5% royalty but, really, if you get to the point where 5% is a significant dollar amount, you will be rolling in the the dough and shouldn’t care if Epic wants a piece of the pie. Cost aside, I do like the engine a lot. Granted, I ran into some bugs, and more crashes and stability issues than I’d care to admit. At one point, the project saved in a corrupted state and I was blocked from even opening it at all. Luckily, I was able to update the engine and convert the project, but I was sweating pretty hard for a little while. That said, I’m sure this can be improved in time and it didn’t stop me from developing (I’d just recommend using source control and committing often).

The visual programming system, Blueprint, is very powerful and I used that alone for this demo (no C++). I did start checking out the C++ support and it seems to add some extra power and flexibility, but I haven’t got that far yet. However, I can see building some simple games and experiences using the visual coding by itself. This is also great for designers, who may be able to rig up some basic stuff themselves. Keep in mind, it’s still programming (just not with text). You have to understand the basics of logic and control flow and, in some ways, it may even seem alien to veteran programmers. I know there were definitely a few cases where I had a non-trivial amount of nodes and connections and thinking “I could have done this in 1 line of code”. Once I got beyond that, I think I may prefer it to coding manually, as it’s much harder to make mistakes (or to create stuff that doesn’t work).

I hope to continue working with UE4 in the future and I’ll continue updating my blog as I make major developments. Thanks for watching.

C++, Gaming, Review

Review: Game Programming Patterns by Robert Nystrom

Game Patterns

I will start by saying this book is game programming GOLD! Whether you are a pro or a novice looking to learn, this book deserves to place on your shelf (or I guess in memory if you buy the e-book). While some of the chapters may seem like obvious things for people that have programmed games before, I think even advanced coders will discover a few things they didn’t know.

So let me talk about what this book is. Basically it covers common challenges in game programming and some useful ways of resolving the problem. Though the theme of the book is game development, a lot of this stuff is applicable to any sort of visual or object-oriented programming. Nystrom starts by revisiting the classic design patterns popularized by the seminal book by the “gang of four” in 1994. Surprisingly, 20 years later a lot of those ideas still hold up. Next he moves onto more game specific topics like double buffering (not just for graphics), a game loop, and updating objects. Then he goes into bytecode (really a simple compiler), components, event queues, singletons, object pools, dirty flag and spatial partitioning. It’s actually not the longest book out there at 354 pages, but this is a breathe of fresh air after persevering through The C++ Programming Language (which was great, just very long). The author does not waste pages, though. There are nuggets of knowledge littered throughout the text.

One thing I like is how the book is not tied to a particular API or library. The pseudo-code is in C++, but really you could implement the ideas in almost any language. He even goes as far as not using the STL (for example, rolling his own linked list for a few examples). In a real application, you would probably not want to reinvent the wheel for basic containers, but it’s nice that the examples stand alone without any nasty dependencies. I could see a lot of the code here being copied into a real game and being usable with only minor additions. Well, of course you have to modify for your platform or engine or whatever, but the concepts are solid.

Another point is that this makes design patterns concrete (please, no abstract class jokes…). I read the original Design Patterns book years ago but some of the patterns never made sense to me. They were too abstract and, though interesting, sometimes didn’t click for me. This book, on the other hand, clicked the whole way through. Everything made sense, and was immediately clear why it was useful. Sure, I’ve probably learned a lot in the past few years, making Game Programming Patterns more approachable. But I think almost any game coder (or aspiring coder) could get value from this book. I’d give it 5 stars, 10 out of 10, 2 thumbs up, and definite “buy it now.”

Gaming, Physics, Review

Review: Game Physics Pearls by Gino van den Bergen & Dirk Gregorius

GamePhysicsPearls

Game Physics Pearls has been a book on my wishlist for a while, and I’ve finally got the chance to finish reading it and putting up this review. The text is edited by Gino van den Bergen and Dirk Gregorius, and each chapter is written by a unique author. I found that a lot of ground was covered while still keeping the book somewhat cohesive. It doesn’t feel like a complete random mash-up, and the progression is nice.

Some of the chapter content includes: basic mathematics, game physics pitfalls, broad phase, narrow phase, GJK, SPH, parallel particle simulation, ropes, soft bodies, and verlet integration. Even after reading several game physics books, there was still a decent amount of information I had not seen before. I especially appreciated the chapter on verlet integration (and the subsequent chapter on cloth physics that builds upon it). So many of the books I’ve seen seem to focus on Euler integration techniques and it’s rare to see much talk of verlet integration (or position based dynamics for that matter). This is the direction I am going with my physics engine, so it was nice to see some coverage.

Overall I was impressed with the quality of the book. Sometimes with these “gem” style books, it can be a hit or miss if the chapter is relevant to your needs. I did not think that was the case here. Nearly all the chapters had some pertinent information, and (while maybe not directly relevant to my current project) were at least interesting to read. I did not feel bogged down with math, most of the explanations made sense and there wasn’t too much needless minutia.

I would definitely recommend this title to anyone interested in video game physics. While there are other books that may be better places to start (as the book sort of assumes you know the basics already) this would not be a bad book to add to the collection. There are actually only a couple game physics books that I *haven’t* read, so it’s getting to the point I will need to stop researching and start writing code. Wish me luck!

Gaming, Graphics, Review

Review: Creating the Art of the Game by Matthew Omernick

CreatingArtGame

Creating the Art of the Game by Matthew Omernick was a quick and easy read. However, I wish I had noticed the age of the book (and also the age of the reviews on Amazon). This book is seriously dated, and it has not aged well. Although some of the topics are still applicable, and lot of the stuff he talks about is ancient in the game dev industry. All things considered, it’s not necessarily a bad book, it’s just not very useful at this point.

The book covers a number of fairly basic topics regarding art creation for video games. Some of what is discussed includes: gathering reference, modeling theory, texturing, lighting, user interface, and tips and tricks. It became clear a few short chapters in that this book was really geared at beginners. I mean total beginners, as in still in high school, no experience whatsoever. Had it not been so dated, I could still recommend it to high school students. The only problem is that a lot of the content is not very useful anymore. He talks a lot about things like vertex lighting (saying per-pixel lighting is to intensive for real-time use), faked shadowing using square/circle textures, planar reflection by duplicating and flipping geometry, etc. These are all pre-shader era techniques and are somewhat amusing to look back on.

Omernick refers to the Playstation 2 a lot (the popular console at the time) and makes some interesting predictions about what the “next generation” (now the last generation) would be able to do. Clearly the guy has worked in the industry and knows what he is talking about. It’s just that the state-of-the-art has advanced considerably in the past 10 years, and this book does not stand the test of time. However, I did learn a trick or two regarding texture creation (which fundamentally has not changed much) so I don’t feel too bad about spending a few days reading this book.

Unfortunately I don’t think I could recommend this to anyone at this point, given the beginning level and dated content. No worries, on to the next book.