Game programming is what got me into computers about 15 years ago. If you’re anything like me, then the magic, the brightly colored animation that radiates from computer games draws you in like a moth to a light. but being fascinated by computer games (and their internal components) and being able to program them are two completely different things. I had to learn the trade the hard way: by watching the games for hours until you could see how they worked. these days you can cheat and take a shortcut: pick a book and just “match your mind” with the experienced programmer who spews out all his experience, tips and tricks.
Keeping in mind that some java books (see laura lemay’s book listed below in the resources section) these days want to guide you down different paths, you could do worse than trusting an ex-game programmer (commercial ) to review currently available java game programming books.
You are reading: Java games programming books
four titles arrived at my door for this review:
-
the black art of java game programming, by joel fan, eric ries and calin tenitchi (waite group press)
Cutting Edge Java Game Programming, by Neil Bartlett, Steve Simkin, and Chris Stranc (Coriolis Group Books)
java entertainment applet development, by john withers (wiley)
Before we review the books in detail, let’s start with a table that gives you an overview of their main features:
table 1: overview of java game programming books.
To describe the table headers, the object oriented column highlights the extent to which the author(s) of the respective book used java in the way it should be used: in an object oriented way. good java books, whatever their focus, enforce good object-oriented practices. the lower books use java as if it were c or pascal, i.e. procedurally. games are very good candidate applications that benefit from being designed and implemented using object orientation, so a good java gamebook had better be strong in ooa/ood/oop (oo analysis, design, programming) .
See Also: 2010 To 2020 -The 10 Best Books Of The Decade – MyGoodTimes
the network multiuser focus column highlights how much the book focuses on java game programming’s greatest potential: network multiuser games.
The Game Framework Focus column highlights the extent to which the book relies on a game framework to explain and develop game programming. game frameworks are state-of-the-art gaming APIs that eliminate many of the standard tasks that all games must perform (sprite management, screen repaint, score keeping, etc.).
now, a look at the books in detail.
black art of java game programming
The Black Art of Java Game Programming is one of those 933-page bible-like books. The book is logically structured in three parts:
- “basics of java game development”
- “advanced game and graphics techniques”
- “game gallery”
part 1, which is written entirely by the book’s main author (joel fan), expertly weaves together the three core topics of java, object orientation, and the fundamentals of game programming into one whole clear, refreshing and consistent.
part 2 focuses on networks and 3d techniques. one chapter develops a server-side high score management system, while another develops a complete chat room system. both systems involve client-side and server-side programs (in other words, applets and servers). The only two chapters that deal with 3D read like a book within a book: in over 110 pages, Calin Tenitchi discusses all the classic 3D basics, and in his second chapter, he discusses using a 3D gaming framework. large but very well designed application called 3dcore. with the official java 3d api on the horizon, this part of the book will soon be partially obsolete, although much of the framework deals with higher level aspects than java 3d, so this is not an issue for the book. in any case, having the inside of such a 3d frame explained is very enlightening.
part 3, the game gallery, contains eight chapters, each of which develops a complete game. the games vary in sophistication, which gave me the impression that this part of the book was put together rather quickly. however, the individual design and implementation of the games are (generally) of the same high quality as the rest of the book. There’s a vector-based asteroid clone, othello, a web-based mahjong, a horizontal scrolling word shooter edutainment game, two different magic square games, and an incarnation of the classic game of worms (or snakes, yes). He prefers). .
although the book is not without flaws, errors, etc. (for example, a page contains a list of codes that is mangled beyond belief), I really liked it. the book has many strengths and few weaknesses. is strong in good program analysis and design. (ah! you thought you could skip those stages just because they are games? mistake?). the book uses various types of diagrams very effectively (object diagrams, class diagrams, flow diagrams, state machine diagrams, screen prototype diagrams, etc.), and most of the code listings are very legible. (This aspect, like writing style, fluctuates from author to author. This is the inevitable flip side of multi-authored books.)
next generation java game programming
I’m usually very skeptical of titles that start with “advanced”, “cutting edge” and the like, simply because they usually aren’t. In the case of state-of-the-art Java game programming, Coriolis’ marketing department did not promote anything: the book is definitely not for beginners or intermediate level Java programmers. in fact, all but the first and last chapters of the book are dedicated to an in-depth and no-nonsense analysis of the design and implementation of two game frameworks. the first framework is tailored to single-user (indie) games, while the second is geared towards multi-user internet-based games.
See Also: 5 Best Baby Memory Books of 2022 | WonderBaby.org
Chapter 2 includes the full implementation of a full clone of asteroids that is playable, non-flickering, and uses smooth animation and sound. and that in just 250 odd lines of code, or just 18 book pages! This chapter, therefore, should convince anyone that using game frameworks, and frameworks in general, is one of the best ways to achieve high levels of programming productivity by emphasizing design reuse, rather than code reuse. (but also reusing mountains of code in the process).
If chapter 2 is a clear and promising sign of the high quality of this book, then chapter 3 reinforces that impression by introducing us to the central theme of the book: the in-depth exploration of a (very) well-designed game framework. . In passing, the author explains what crc (class/responsibilities/collaborators) cards are, the essence of booch class diagrams, and object message interaction diagrams. by the way, this is not like filling a page because the rest of the book uses these powerful software engineering tools to enhance the text!
The single-user game framework, called gameworks, is based on the tried-and-true game programming metaphor of a stage populated by actors. Using this intuitive abstraction, you can implement any type of game, from classic board games to fast-paced, action-packed arcade games. I was a bit disappointed that the authors chose card games as an example game style (prefer something that gets the adrenaline flowing), though they nonetheless manage to weave in all the standard problems and techniques, and expertly (among other : image processing, input management, sprites, optimized screen update, audio, randomization, artificial intelligence).
Although the book is not structured in parts, it should have been. there is a clear change of focus from chapter 15 onwards. Chapter 15, “Network Game Programming,” represents a definite shift into higher gear, with a new author writing. after presenting the main problems surrounding network-based games (connection topologies, latency, game state synchronization), the book develops a clone of the risky, classic strategy board game (called domination in the book). domination is just an excuse to develop a new game framework that addresses the generic class of network-enabled multi-user games. These last five chapters are difficult, and I strongly suspect that readers with no data communications experience will not feel comfortable with the more technical arguments. but there’s no way you’re going to skip these chapters – they contain a very comprehensive treatment of critical game state desync and latency issues, as well as a number of increasingly sophisticated solutions.
The book ends with a chapter on code optimization and an interesting chapter on the design of fred, a clone of “doom” written in java. fred uses ray casting (yes, in java) to achieve that classic “doom” feel, and this core technique is explained in detail.
To sum it up, state-of-the-art java game programming is excellent. the writing is lucid and to the point. the software that the authors develop is of very high quality. the listings are clear and readable, and I don’t know about you, but after reading other people’s programs for 15 years, I don’t consider source code readability to be a luxury).
java entertainment applet development
Developing Java Entertainment Applets is a very disappointing book. if a publisher gave you 400 pages to include everything you know about java game programming (ok, ok, “java en-ter-tain-ment app-lets”), then you don’t start with a chapter that reiterates, ad nauseum, the history of java. or continue with “java basics” (chapter 4), a totally superfluous rehash of the basics of the language (variables, unicode, expressions, comments, control flow, objects, classes, packages, you name it!). the author still doesn’t suspect that he might be focusing on the wrong topic altogether, so in chapter 5, “more advanced techniques,” he continues with arrays, arrays, strings, exceptions, multithreading, applets. getting hotter is chapter 6, “graphics, sound and events”. but you’ll be hard pressed to find references to game programming here. instead, precious page space is devoted to giving you no less than 13 half-page screenshots of the trivial results of draw3drect(), drawoval(), drawarc() and the like.
Midway through the book (chapter 7, page 219) we get the first appearance of some java game code, in this case an attempt at the solitaire card game (definitely card games). cards must be in season). game design, game implementation, and list readability are so inferior compared to the same aspects of the other books in this review that it’s clear that developing java entertainment applets has problems.
A few notable statements made by the author, and a general oversight or misuse of terms that have a very clear meaning, only help to sink this book before it has a chance to set sail. awt’s layout management mechanism is criticized as follows: “the way the layout is handled is pretty sloppy. It’s not that it doesn’t make sense and it’s not for a good reason, but it’s still sloppy.” java’s network api is also not to the author’s liking: “the way java connects to other locations on the network is broken, and while it’s not totally unusable, it sure isn’t very functional in its current state.” weird, i would have sworn i and others managed to build some pretty exciting stuff with that same api (web crawler, dampp – see the resources below for references to my previous javaworld articles on these topics). that last quote comes from chapter 8, “multiplayer games”, where we are, however, shown “a stupid little example” (to quote the book) in the form of a chat app. (Other examples of language that I find hard to swallow in this book are “to cement it in your head” (p. 283), “and spit things on a plug” (p. 284), to name just two). /p>
Is there nothing good to say about this book? Actually, there is: Chapter 2, “Game Design Principles,” is an interesting look at what makes a good game good. here the author stands out by identifying several aspects that all good games have, such as a well-designed game interface, truthfulness (level of realism), customization, artificial intelligence, etc. The next chapter, “Game Design in Action,” looks at some real games and highlights their use of good game design elements. Then there’s a big chapter (Chapter 9) devoted to the study and use of the Gamelet Toolkit (a public domain game framework, written by Mark Tacchi, which received an international JavaCup award). these three chapters are the only parts of the book worth the paper they’re printed on, I’m afraid.
learn to program internet games with java
Comparative reviews are difficult because there are rarely two (or more) books in exactly the same category. Teach Yourself Programming Internet Games With Java, according to its back cover, targets users in the “new” to “casual” categories. beginners, in other words.