black art of java gaame programmig

Black Art of Java Game Programming:Introduction

Black Art of Java Game Programming
by Joel Fan
Sams, Macmillan Computer Publishing
ISBN: 1571690433 Pub Date: 11/01/96

Table of Contents
Introduction
Gaming on the Web is the next blockbuster business. Have any doubts? The video game industry,
which already eclipses Hollywood in terms of revenue, targets the Web as the next huge growth area.
Software developers are busily porting games to the online environment, or developing entirely new
ones. And numerous popular Web sites, many of which charge fees, are devoted to game
entertainment.
With Black Art of Java Game Programming, you’ll learn how to create your own dynamic online
entertainment using the Java programming language. Java heralds a revolutionary shift in gaming,
away from the desktop and into the network. Using Java, you’ll create games that people can
download through the Web and play. Using Java, you’ll enable players from around the world to
compete against one another. As Java enters its maturity, the possibilities of creating innovative
entertainment are endless, and the potential for profit unbounded.
This book provides you with the foundations for creating Java games of all types, such as board
games, video games, and networked/multiplayer games. We recommend that you have some basic
knowledge of C, C++, or Java before diving in. The underlying thread of this book is that good object-
oriented design and good Java games go hand in hand, so we devote the early chapters of the book to
covering and applying object-oriented principles to graphics and games. Once the foundations have
been laid, we build a wide variety of games. As you will see, game programming is almost a game in
itself, and once you learn the basics, you’ll be well equipped to write innovative games on your own.
Organization
Black Art of Java Game Programming is divided into three parts:
Part I, Fundamentals of Java Game Development
Part II, Advanced Game and Graphics Techniques

Part III, Game Gallery
file:///D|/Downloads/Books/Computer/Java/Bla %20Of%20Java%20Game%20Programming/index.html (1 von 3) [13.03.2002 13:17:32]
www.traintelco.com
Black Art of Java Game Programming:Introduction
Part I, Fundamentals
Part I takes you on a whirlwind tour of Java, graphics, and object-oriented game programming. This
section is for you if you’re learning Java, if you’re new to object-oriented design, or if you want to see
how to build a game step by step.
This is what’s covered in the Fundamentals section:
Chapter 1, “Fundamental Java,” delivers a turbocharged introduction to the Java language, the API,
and object-oriented design. By the end, you’ll create graphics applets.
Chapter 2, “Using Objects for Animation,” shows you how classes, inheritance, and dynamic method
binding help you animate objects. You’ll also learn about clipping and double-buffering, two basic
graphics techniques.
Chapter 3, “Animating Sprites,” teaches you to create a simple abstract class for representing graphics
objects called sprites. In addition, you’ll learn about interfaces, bitmap animation, and sound.
Chapter 4, “Adding Interactivity,” shows you how to create applets that respond in real time to player
input.
Chapter 5, “Building a Video Game,” shows you how to apply what you’ve learned in the first four
chapters to create a shoot-’em-up video game. What you learn here can be applied to creating many
other types of games.
Chapter 6, “Extending Your Video Game,” shows you how to take a game that you’ve developed and
add new features to it without starting from scratch.
Chapter 7, “Creating Customizable Games with the AWT,” demonstrates how Java’s Abstract
Windowing Toolkit allows players to change parameters in your games. What you learn here about
the AWT will be applied throughout the rest of the book.
Part II, Advanced Game and Graphics Techniques
In Part II, you’ll learn the skills necessary to bring your games into the next dimension, such as
multithreading, networking and multiplayer techniques, and 3D.
Chapter 8, “Implementing a High Score Server on a Network,” takes you through Java’s networking

and GUI facilities, and teaches you to build a high score server for your games.
Chapter 9, “Advanced Networking and Multiplayer Gaming Concepts,” illustrates techniques for
enabling multiuser game play over the Web. In addition, you’ll deepen your understanding of Java’s
networking capabilities by implementing a chat room.
file:///D|/Downloads/Books/Computer/Java/Bla %20Of%20Java%20Game%20Programming/index.html (2 von 3) [13.03.2002 13:17:32]
www.traintelco.com
Black Art of Java Game Programming:Introduction
Chapter 10, “Advanced Techniques,” covers features of Java and the Java API that are useful in
writing games and organizing programs.
Chapter 11, “Into the Third Dimension,” demonstrates the process of defining, transforming,
projecting, and painting three-dimensional models, and builds classes that can be used to make a
simple 3D engine.
Chapter 12, “Building 3D Applets with App3Dcore,” shows how the App3Dcore (a set of classes)
works and how it can be used to develop some simple 3D applets and an advanced 3D game.
Part III, Game Gallery
In Part III, you’ll apply the skills you’ve learned in earlier chapters as leading Java game designers
take you step by step through the creation of a wide spectrum of cool games.
Chapter 13,“Building the JAVAroids Game,” shows you how to create a Java version of the video
game classic Asteroids.
Chapter 14, “Daleks!,” takes you through the creation of an enhanced Java version of a classic
computer game.
Chapter 15, “NetOthello,” builds on your networking skills learned in earlier chapters to create a
networked implementation of the classic game Othello.
Chapter 16, “WordQuest,” takes you through the creation of a Java game specifically designed to
teach vocabulary, but which could easily be extended to teach a plethora of other concepts,
demonstrating Java’s potential as a learning tool.
Chapter 17, “The Magic Squares Puzzle,” is an example of a deceptively simple, yet challenging
puzzle game that will delight Rubik’s Cube enthusiasts (and many others).
Chapter 18, “The Internet MahJong Server,” demonstrates a software package that allows people to
play the classic Chinese strategy game MahJong with each other online.

Chapter 19, “Slider Puzzle,” shows you how to write a Java applet for a simple slider puzzle enhanced
with animation and sound.
Chapter 20, “The Game of Worm,” develops a game in which you control the direction of a virtual
worm on a rectangular playing surface, collecting treats while avoiding collision with solid objects.
Table of Contents
file:///D|/Downloads/Books/Computer/Java/Bla %20Of%20Java%20Game%20Programming/index.html (3 von 3) [13.03.2002 13:17:32]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents

Black Art of Java Game Programming
by Joel Fan
Sams, Macmillan Computer Publishing
ISBN: 1571690433 Pub Date: 11/01/96

Introduction
What's on the CD-ROM?
About the Authors
Part I—Fundamentals of Java Game Development
Chapter 1—Fundamental Java
What Is Java?
The World Wide Web
What Is a Java Applet?
Advantages to Writing Games in Java
Other Benefits
Current Limitations to Writing Games in Java
Object-Oriented Fundamentals
Thinking with States and Behaviors
Defining a Class
Variables
Methods

Constructors
Creating an Object
Accessing Object Variables and Methods
Inheritance
Java Summary
The Java Core
Primitive Data Types
Arrays
Classes and Objects
Instance, Static, and Final Variables and Methods
Memory Management
Packages
Operators
Control Flow
Threads
Exceptions
Major Differences Between Java, C, and C++
The Java API
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (1 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
java.applet
java.awt
java.awt.image
java.awt.peer
java.io
java.lang
java.net
java.util
The Java Interpreter

Three Sample Applications
Program 1: Your First Java Program
Program 2: Parameter Passing
Program 3: A Linked List
Understanding Applets
Executing an Applet
Creating Graphics
Drawing
Filling
Color
A Graphics Applet
The Applet Life Cycle
Suggestion Box
Summary
Chapter 2—Using Objects for Animation
What Is Animation?
Creating Our First Animation Applet
Using the Universal Animation Loop
Tracing the Applet’s Execution Path
Improving Animation Quality
Understanding Animation Flicker
Using Double-Buffering to Eliminate Flicker
Using Clipping to Improve Performance
Adding Complexity to Your Animation
Using Objects
Defining the Class
The this Keyword
Using this in Constructors
Using the DancingRect Class
Using Inheritance

When to Use Inheritance
When Not to Use Inheritance
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (2 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Inheritance Details
The Object Class
Method Overriding
The super Keyword
Using super in Constructors
Final Classes and Methods
Using Inheritance in Our Example Applet
Using Dynamic Method Binding
Putting It Together
Suggestion Box
Summary
Chapter 3—Animating Sprites
What Are Sprites?
Sprite States
Sprite Behaviors
Using Abstract Classes
Defining the Sprite Class
Using Access Specifiers
Public Access
Private Access
Protected Access
Package/Default Access
Accessor Methods
Applying the Sprite Class to an Example Applet
Using Interfaces

What Is an Interface?
Java Interfaces
Multiple Interfaces
Abstract Classes vs. Interfaces
Creating a Moveable Interface
Creating an Applet with Bouncing Sprites
Using Bitmaps
Bitmaps in Java
Loading and Drawing a Bitmap Image
Specifying the Location of a Bitmap Image
Creating Bitmap Sprites
Using Sound
Loading an AudioClip
Playing the Sound
Four Rectangles and a Sushi Chef
Suggestion Box
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (3 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Summary
Chapter 4—Adding Interactivity
How Input Devices Work
What Is an Event?
Mouse Events
Keyboard Events
The Event Class
Handling Function Keys
Handling Modifier Keys
Event Handling in the AWT
Overview of Component classes

How the AWT Handles Events
Displaying Text
Defining Strings
Choosing Fonts
Drawing Strings
Inserting a Text String into an Applet
Clicking and Dragging Sprites
Creating Bitmap Loops
Using MediaTracker
Defining the BitmapLoop Class
An Interactive Applet Using BitmapLoop Sprites
Suggestion Box
Summary
Chapter 5—Building a Video Game
Overview of the Alien Landing Game
The Video Game Loop
Dividing Responsibility Among Functional Units
The GunManager Unit
The UFOManager Unit
The GameManager Unit
Interplay Among the Functional Units
Defining the GunManager
GunSprite
The BitmapSprite Class
The Moveable Interface
The Intersect Interface
Determining Intersections with Bounding Boxes
Implementing GunSprite
MissileSprite
The RectSprite Class

file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (4 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Incorporating the Intersect Interface
Implementing MissileSprite
GunManager
Computing Variables
Defining the UFOManager
The UFO Class
The BitmapLoop Sprite Class
The Four UFO Behavioral States
Transitioning Between States
Implementing the UFO Sprite Class
The UFOManager Class
Defining the GameManager
Two Responsibilities of the GameManager Class
Passing Mouse Input to the GunManager
Implementing the Video Game Loop
Implementing the GameManager Class
Suggestion Box
Summary
Chapter 6—Extending Your Video Game
Changing the UFO Animations
Extending the UFO Class
Modifying GameManager and UFOManager
Adding Levels of Difficulty
Tracking Game Status
Modifying GunManager
Creating an Opening and Closing
Source Code for Modified Classes

Suggestion Box
Summary
Chapter 7—Creating Customizable Games with the AWT
Creating Graphical Interfaces with the AWT
Overview of the AWT
Creating Graphical Interfaces
Handling Action Events
Defining the Action Handler in the Container
Defining the Action Handler in the Component
Using Components, LayoutManagers, and Containers
Components
Buttons
Checkboxes
Checkbox Groups
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (5 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Labels
Text Fields
LayoutManagers
FlowLayout
BorderLayout
GridLayout
Other Layout Managers
Containers
Panels
Frames
Dialogs
Customizing Alien Landing
Defining the GameFrame Container

Creating a Menu Bar
Handling Menu Actions
Defining the Customization Dialog
Customized Source Code for GameManager
Using Applet Parameters
What Are Applet Parameters?
Reading Applet Parameters
Quick AWT Reference
The Component and Container Classes
Components
Containers
Cursors
Menu, MenuBar, and MenuItem
The Event Class
Suggestion Box
Summary
Part II—Advanced Game and Graphics Techniques
Chapter 8—Implementing a High Score Server on a Network
Why Use Java for Network Programming?
What Is Client-Server Networking?
Basic Client-Server Terminology
Some Additional Concepts
Exception Handling
Streams
Implementing Our Client Server Game Model
Implementing Client Features
Creating the HighScoreManager Class
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (6 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents

How HighScoreManager Reduces Calculations
Implementing Server Features
Effect of Client Design on Server Performance
Tasks Performed by the Server
Creating the High Score Objects
The HighScoreList Class
Scoring Variables
The HSob Object Class
Data Parsing
The StringTokenizer Class
Converting Data to Objects
The parseData() Method
The addScore() Method
The tryScore() Method
The getScore() Method
Creating the HighScoreManager Class
The getScores() Method
The paintScores() Method
Methods for Creating Colors
Methods for Creating Fonts
Adding New Scores to HighScoreList
Creating a Testing Applet
Double-Buffering the Testing Applet
The testApp GUI
Threading HighScoreManager
Using Threads
Converting HighScoreManager to a Thread
Writing the Networking Code
Creating a New Socket
Establishing the Connection

Updating and Requesting Information: The HighScore Protocol
Understanding Blocking
Terminating the Link
Creating a Server Application
The HighScoreServer Class
The ServerThread Class
Server Initialization Routine
Coding the run() Method
Trying Out the New Server
Writing Scores Out to a File
Running the New Server
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (7 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Suggestion Box
Summary
Chapter 9—Advanced Networking and Multiplayer Gaming
Concepts
Why Create a Chat Room?
Fundamentals of Multiplayer Gaming
Types of Multiplayer Games: The User’s Perspective
Cooperative Gaming
Competitive Gaming
Types of Multiplayer Games: The Programmer’s Perspective
Local Games
Remote Games
Choosing the Proper Networking Architecture
Peer-to-Peer Networking
Networking Rings
Peer-to-Peer Networking in Java

Adapting Client-Server Architecture to Multiplayer Games
Understanding the Chat Room Server
Functions of a Chat Room Server
ChatServer Classes
Implementing the Chat Room Server
Creating the ChatServer Class
Creating the ChatServerThread Class
Creating the sClientGroup Class
The Vector Class
The sClientGroup.java Startup File
The sendMessage( ) Methods
The calcList( ) Method
The StringBuffer Class
Automatic Garbage Collection (Reclaiming Unused Memory)
The cleanHouse( ) Method
Creating the sClientThread Class
Writing the Real sClientThread Code
The parent Variable
The run( ) Method
The finalize( ) Method
The message( ) Method
The Alias Handling Methods
The Final Server Compile
Creating the Chat Room Client
General Design Considerations
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (8 von 20) [13.03.2002 13:17:36]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
User Interface Components
User Interface Design Considerations

Component Commands and Methods
Common Component Methods
Methods Unique to List
Planning Your Event-Handling Strategy
Basic Events and Their Properties
Event Constants
Implementing the Client Chat Room Applet Code
The ChatClient.java Startup File
Text Output
GUI Setup
Event Handling
The run( ) Method
Command Parsing
Server Input
The stop( ) Method
Suggestion Box
Summary
Chapter 10—Advanced Techniques
Using Packages
Importing Packages and Classes
Creating Packages
Nested Packages and Directory Structure
Using Threads
A Quick Review of Threads
Creating Threads
Creating a Subclass of Thread
Creating a Class That Implements Runnable
Understanding Thread Scheduling
Creating a Simple Multithreaded Animation
Structuring Games with Multiple Threads

Incorporating Multiple Threads into the Alien Landing Game
Using the synchronized Keyword
Considering the Pros and Cons of Using Multiple Threads
Improving Performance with Image Processing
Why Be Concerned with Image Processing?
Creating Image Strips
Filtering the Images
Extracting Images from an Image Strip
Using the java.util Classes
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (9 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
The Date Class
The Vector Class
The Stack Class
The Hashtable Class
The Random Class
Writing for Multiple Platforms
Yield Threads
Aligning Text
Determining System Properties
Determining Screen Parameters
Obtaining System Properties
Ask the Player
Allowing Customization
Testing Your Games on Multiple Platforms
Suggestion Box
Summary
Chapter 11—Into the Third Dimension
Performance Issues with 3D in Java

Improving Performance Through Simple Rendering
Improving Performance Through Optimizing the Overall Model
Future Optimization of Java Itself
Polygon-Based Modeling
The Polyhedron
Vertices
Understanding the Structure of a Polyhedron
Implementing an Array of 3D Points
Polygons
Understanding Polygon Orientation and Visible Surface
Determination
Implementing an Indexing Polygon (fIndexingPolygon)
Why Is the Indexing Polygon an Abstract Class?
The Static “Scratch-Pad” Polygon
The Abstract paint() and copyIndexedPoints() Methods
The Static orientation() Method
Implementing a Filled Polygon
The paint() Method
The fColor Class
Implementing the Polyhedron Class
The Abstract paint() Method
Reading and Writing Polyhedrons from/to Streams
A Two-Dimensional Point Array
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (10 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
The Convex Polyhedron and Polygon Sorting
What Does Convex Mean?
The Advantages of Using Convex Polyhedrons
Implementing a Convex Polyhedron (fConvexPolyhedron)

The Classes Used So Far
Constructing a Simple 3D Pipeline
The Four Coordinate Systems
The Model Coordinate System (MCS)
The World Coordinate System (WCS)
The View Coordinate System (VCS)
Projecting 3D Points on a Plane
The Screen Coordinate System (SCS)
The Camera
Implementing a Generic Camera (fGenericCamera)
The Static Buffers
Calculating Screen Distance with Respect to the View Angle
The Private updateMatrix() Method
The project() Method
Implementing the 3D Point Class (fPoint3d)
Implementing the 3D Angle Class (fAngle3d)
Implementing the 3D Matrix Class (fMatrix3d)
The Complete Chain of Transforms
The Polyhedron Instance Class
Implementing the Polyhedron Instance
The Array transformedVertices
Understanding the paint() Method
Putting It All Together
Implementing the Rotating Cubes Applet
Initiating the Applet
The run() Method
Suggestion Box
Summary
Chapter 12—Building 3D Applets with App3Dcore
What Is the App3Dcore?

The Core’s Internal Structure
Understanding the Virtual World in the Core
Understanding the 3D Engine in the Core
Building an Application on Top of the Core
A Small Example: The Bouncing Boxes
The BouncingBox Constructor
The Overridden Update
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (11 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
The initiateClass() Method
The BouncingBoxWorld Constructor
The initiateClasses() Method
The init() Method
The run() Method
The paint() Method
Building on the Example: Collisions and Object Interactions
The Constructor
The update() Method
Collision Handling
The interestedOfCollisionWith() Method
The handleCollisionWith() Method
Using a Template to Simplify Designing New Objects
Creating the Game Layer
How the Game Layer Works
The Game Layer Classes
The cmAbstractStaticObject Class
The cmAbstractMovingObject Class
The cmAbstractStaticStructure Class
The cmAbstractMovingStructure Class

The cmAbstractStaticScenery Class
The cmAbstractMovingScenery Class
The cmAbstractVehicle Class
The cmAbstractPlayer Class
The cmAbstractWeapon Class
The cmAbstractRound Class
Implementing a Simple 3D Game
The Tank, Extending cmAbstractPlayer
The Constructor
The die() Method
The Tank Remains, Extending cmAbstractMovingScenery
The Constructor
The update() Method
The Glider, Extending cmAbstractPlayer
The Constructor
The update() Method
The die() Method
The Glider Remains, Extending cmAbstractMovingScenery
The Buildings, Extensions of cmAbstractStaticStructure
The Missile Launcher, Extension of cmAbstractWeapon
The Constructor
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (12 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
The fire() Method
The Missile, Extension of cmAbstractRound
The Constructor
The update() Method
The die() Method
The Mini-Cannon, Extension of cmAbstractWeapon

The Mini-Cannon Round, Extension of cmAbstractRound
The Constructor
The update() Method
The die() Method
The Abstract Shell, Extension of cmAbstractMovingScenery
The Constructor
The update() Method
The Mini-Cannon Empty Shell, Extension of cmAbstractShell
The Constructor
The Bomb Bay, Extension of cmAbstractWeapon
The Bomb, Extension of cmAbstractMovingScenery
The Constructor
The update() Method
The die() Method
The Explosion, Extension of cmAbstractRound
The Constructor
The Explosion, Extension of cmAbstractMovingScenery
The Constructor
The update() Method
Putting Together a Virtual World
The cmWorld, Extension of fWorld
The Display Panel
The Applet
Suggestion Box
Summary
Part III—Game Gallery
Chapter 13—Building the JAVAroids Game
The Game Plot
Video Game Paradigms
Deriving Sprites

Choosing a Parent for the PolygonSprite Class
Defining PolygonSprite
Doing a Little Vector Math
Local vs. Screen Coordinates
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (13 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Cartesian vs. Polar Coordinates
Moving and Rotating Polygons
The MoveablePolygon Class
The RotateablePolygon Class
Allocating Responsibility
The Top-Level Organization
Handling Collisions
Building the Game Sprites
The Enemy Sprite
The Fire Sprite
The Asteroid Sprite
The Ship Sprite
The Explosion Sprite
Defining the Managers
The Asteroid Manager
The Ship Manager
The Enemy Manager
The Effect Manager
The Game Manager
Suggestion Box
Summary
Chapter 14—Daleks!
Playing the Game

Setting Up the Game
Animating the Title Screen
Preparing to Animate
Creating a New Thread
The Animation Loop
The Game Begins
Starting a Turn
Directing Traffic
Making the Right Moves
Analyzing Input
The Daleks Pursue
Between-Move Animations
Redrawing the Board
Painting by Number
Better Housekeeping
Customizing the Game
Changing the Title Screen
Changing the Board Size
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (14 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Balancing Play
Allowing Customization
Suggestion Box
Comments
Chapter 15—NetOthello
Why Othello?
Implementing a Board Game
Implementing the Class Hierarchy
The GamePiece Class

The gameBoard Class
The NetOthello Class
Controlling Game Play
Taking Turns
Teaching a Computer the Rules
The Server Side
The Client Side
Writing the Client Code
Writing the Game Code
The GamePiece Class
The GameBoard Class
The NetOthello Class
Creating Game-Specific Functionality
Writing the GUI Code
NetOthello’s GUI Layout
Handling Events
Implementing a Dialog Box
Writing the Networking Code
Threading NetOthello
Getting the User Info
Connecting to the Server
Handling Server Input
Sending Moves
Writing the GameServer
Step 1: Creating GameServer.class
Step 2: Writing GameServerThread.class
Step 3: Coding GameGroup.class
Step 4: Building GameClientThread.class
Adding Some Features
Multimedia Enhancements

Adding Graphics
Suggestion Box
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (15 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Summary
Chapter 16—WordQuest
What Is WordQuest?
Plan of Attack
Building an Action Environment
Simulating 3D
Understanding Sprite Theory
Writing the Code
Implementing Sprite.java Variables
Defining Sprite IDs
Initializing the Variables
Defining the Sprite Images
Animating the Sprites
Scrolling the Background
Understanding the Terrain Class
Coding the Terrain Class
Declaring Variables
Initializing
Creating the nextPoly() Method
Drawing Terrain onto the Screen
Using copyArea() to Enhance Performance
Finishing the Thread Methods
Adding Functionality
Coding the StarField Class
Checking Out the Environment

On with the Quest
Creating the Question Class
Getting the Question Data
Writing the Prompt Frame
Using ThreadGroups to Synchronize Enemy Sprites
Extending the Sprite Class
The statusBar Class
The userSprite Class
Writing WordQuest
Getting Started
Variable Declarations
The init() Method
Using Double-Buffered Graphics
Double-Buffering the Sprite Class
Double-Buffering StarField
See WordQuest Run
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (16 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Handling the Rules
Selecting a Question
Initializing Once More
Creating a Firing Mechanism
Giving the User Control
A Few Enhancements
The syncSprite Class
That’s All Folks!
Beautiful Friend, the End
Suggestion Box
Summary

Chapter 17—The Magic Squares Puzzle
Playing Magic Squares
The Classes
The game_board Class
The game_board Class Constructors
The randomize() Method
Three Methods Used to Apply a Move to the Board
The draw_board() Method
The fill_square() Method
The copy_board() Method
The is_completed() Method
The squares Class
The init() Method
The paint() Method
The mouseDown() Method
The action() Method
Buttons
The solver Class
The solver Class Constructor
The solver Class run() Method
The try_all_squares() Method
The print_solution() Method
The is_repeat() Method
The undo_move() Method
Suggestion Box
Summary
Chapter 18—The Internet MahJong Server
A Brief Introduction to MahJong
Game Pieces and Components
Rules of Play

file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (17 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Overall Game Design
Classes, Protocols, and Packets
Threads
Source Code Tree Structure
Protocols and Packets
The Packet Class
Sending Packets
Receiving Packets
Other Possible Approaches
The Basic Server
The Server Class
The Player and PlayerOutput Classes
The Listener Thread
The Replier Thread
The Table Class: A Simple Version
Handling Login Requests
Synchronization and Deadlock Prevention
The Basic Client
The Greeting Class and the HTML Document
The Client Class
The Client GUI
Incorporating MahJong
Setting Up the MahJong Table on the Client
The Tile and Hand Classes
A Generic Shuffling Algorithm
MahJong Tile Images
Displaying and Manipulating a Hand

A Client-Server Model for MahJong
Starting a New Game
Adding the Server Code for Game Play
Checking for a MahJong Pattern
Adding Finishing Touches
A Flexible Scoring System
A Player Database
Dealing with Bad Connections
Adding Timeout Functionality
Debugging the Game
Comments
Suggestion Box
Summary
Chapter 19—Slider Puzzle
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (18 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:Table of Contents
Creating the Basic Program
Understanding the Game’s Logic
Creating the Graphics
Loading the Graphics
Displaying the Graphics
Moving the Blocks
Adding the Sound
Adding Some Complexity
The Image Observer
The Randomize Button
Adding Enhancements
Adding a Solve Button
Using Pictures Instead of Numbers

Improving the Sounds
Creating Smoother Animation
Suggestion Box
Summary
Chapter 20—The Game of Worm
What Is Worm?
Game Play
Designing Worm
The Playing Surface-Three Possible Approaches
The Graphical Attribute Approach
The Rectangular Array Approach
The Ring Buffer Approach
Interfacing to the Worm
Breathing Life into the Game
Java-centric Programming for Worm
Multithreading Issues
Java Programming Gotchas
Returning Values
Object Instance Assignments
Optimizing Performance Under Java
Worm Game Class Components
Constructing a Worm
Adding a Queue
Reinitializing After Each Game
Adding Worker Functions
The DoYouHaveSegmentAt() Function
The GetNextPoint() and SetNextPoint() Functions
The DropLastPoint() Function
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (19 von 20) [13.03.2002 13:17:37]
www.traintelco.com

Black Art of Java Game Programming:Table of Contents
Returning Worm Segments Through Iterators
Setting Direction from Player Input
Controlling Input from the Keyboard
Controlling Input with the Mouse
Starting the SessionManager
Using the Next() Function
How Next() Works
Next() Variables
Checking Collisions and Treats
Putting It All Together in the WormBin
Adding Autonomous Worms
Modifying SessionManager
The DoAutoWorms() Function
Calculating Increments
Evaluating the Calculations
Implications for Game Play
Integrating the Game into the Web Page
Placement and Applet Size
Instructions
Browser Compatibility
Future Directions for Worm
Demo Mode
Saving the Score
Network Play
Suggestion Box
Summary
Appendix A
Appendix B
Appendix C

Appendix D
Appendix E
Index
file:///D|/Downloads/Books/Computer/Java/Bl 20Of%20Java%20Game%20Programming/ewtoc.html (20 von 20) [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:What's on the CD-ROM?

Black Art of Java Game Programming
by Joel Fan
Sams, Macmillan Computer Publishing
ISBN: 1571690433 Pub Date: 11/01/96

Table of Contents
What’s on the CD-ROM?
The CD-ROM included with Black Art of Java Game Programming contains the project files and
source code for examples in Parts I and II of the book, as well as all applets and source code for all the
games included in Part III, Game Gallery.
How the CD Is Structured
Source code, examples, and projects for the tutorial chapters of Black Art of Java Game Programming
(Parts I and II) are found in a directory called BOOK at the root of the CD-ROM. Within this BOOK
directory are subdirectories for Chapters 1 through 12, which contain all code and examples for their
accompanying chapters. Games from the Game Gallery section of the book (Part III) are included in
subdirectories for Chapters 13 through 20 in a directory at the root of the CD called GAMES. The
Java Developer’s Kit (JDK) version 1.0.2 for Macintosh, Solaris, Windows 95, and Windows NT is
included in the root directory JDK. All the materials on the CD-ROM in ZIP or TAR format are
included in the root directory ARCHIVES. Please refer to the Read Me on the CD for complete
information about the contents of the directories.
Installation
Please refer to the Read Me file at the root level of the CD-ROM for detailed instructions on
installation of the included files, JDK, games, bonus items, and any late-breaking updates.

We hope you’ll enjoy Black Art of Java Game Programming and will tell us about the games that
you’ve created!
Table of Contents
file:///D|/Downloads/Books/Computer/Java/Black%20Art%20Of%20Java%20Game%20Programming/about.html [13.03.2002 13:17:37]
www.traintelco.com
Black Art of Java Game Programming:About the Authors

Black Art of Java Game Programming
by Joel Fan
Sams, Macmillan Computer Publishing
ISBN: 1571690433 Pub Date: 11/01/96

Table of Contents
About the Authors
Joel Fan is an expert programmer and multimedia developer in Java, C/C++, and Macromedia
Director. He has worked as a programmer, analyst, and developer for many years on the
PC/UNIX/Macintosh platforms, on projects ranging from the cosmic (the Hopkins Ultraviolet
Telescope) to the comic (an animation teaching toolkit) to the downright serious (currently,
cryptographic and security development using the SSLava SSL/Java toolkit). He has published papers
in the field of computer vision, and holds degrees in computer science from Harvard University and
The Johns Hopkins University.
Eric Ries, an undergraduate at Yale University and freelance technical writer, has been developing
Java applets since the very early days of Java’s alpha release. He enjoys all manifestations of
computer programming, as well as writing, which he does in his spare time. In addition to this project,
he has recently completed work for Sybex and the Java Developer’s Journal. He is a founding
member of TeamJava (
) and a member of the Southern California Web
Programmers’ Forum (scwpf).
Calin Tenitchi is currently pursuing his M.S. degree in computer sciences at Lunds Institute of
Technology in Sweden. He also runs a successful consulting firm with his business partner Mathias

Lagerwall that specializes in Java applications and intranet solutions. Calin always likes to be on the
cutting edge of new and exciting technologies like Java, and is happy to be living in an age in which
technology evolves at an amazing pace.
Game Gallery Contributors:
Roman Mach is currently designing and managing engineering projects for Web applications at
Saltmine Creative, Inc., a Seattle-based Web design and engineering company. Roman has written C
and assembly applications in performance-critical areas such as remote radio-telephony software,
server-side search engines, and mobile robotics. He has a Masters in electrical engineering from the
University of Washington. Roman’s interests include mountain biking, bass playing, and road
tripping. His work can be explored at his Web site:
/>Ethan Koehler is presently studying for a Masters in business administration at Marquette
University, as well as doing consulting for companies interested in the Web. Much of his technical
file:///D|/Downloads/Books/Computer/Java/Blac 20Java%20Game%20Programming/about_author.html (1 von 3) [13.03.2002 13:17:38]
www.traintelco.com