精通2D游戏开发：经典指南

需积分: 10 55 浏览量更新于2024-07-22 收藏 5.3MB PDF 举报

"Advanced 2D Game Development - Jonathan S. Harbour" 本书《Advanced 2D Game Development》由 Jonathan S. Harbour 所著，是游戏开发领域的一部经典著作，专门探讨高级2D游戏的制作技术。作为Course Technology PTR 出版社的一部分，这本书在全球多个国家和地区发行，包括澳大利亚、巴西、日本、韩国、墨西哥、新加坡、西班牙、英国和美国。书中涵盖了2D游戏开发的多个重要方面，旨在帮助读者深入理解并掌握这个领域的核心技能。作者 Jonathan S. Harbour 是一位经验丰富的游戏开发者，他分享了他的专业知识和实践经验，使得读者能够学习到如何创建引人入胜且技术上先进的2D游戏。此书的内容可能包括但不限于以下几个关键知识点： 1. **游戏引擎和工具**：介绍各种2D游戏引擎，如Unity、Godot或Cocos2d-x，以及如何利用它们构建游戏框架，管理资源和优化性能。 2. **图形编程**：讲解2D图形渲染，包括精灵（sprites）、位图（bitmaps）、动画和粒子系统，以及如何使用OpenGL或DirectX等库进行低级图形编程。 3. **物理模拟**：探讨2D物理引擎的使用，如Box2D，用于实现物体碰撞检测、重力和其他物理效果。 4. **游戏逻辑与AI**：介绍游戏规则的编程，包括关卡设计、敌人行为模式、路径规划和决策树。 5. **用户界面（UI）设计**：讨论创建吸引人的交互式UI，包括菜单、提示和控制机制。 6. **音频处理**：涵盖音频集成，如音乐和音效的播放与同步，以及使用音频API如OpenAL。 7. **网络编程**：如果涉及多人游戏，会讲解网络同步、数据包传输和错误处理。 8. **性能优化**：如何调试和优化代码，以确保游戏在不同设备上流畅运行。 9. **项目管理和版本控制**：介绍如何组织代码，使用Git等版本控制系统，以及敏捷开发方法。 10. **测试与调试**：提供有效的测试策略，包括单元测试、集成测试和压力测试，以确保游戏质量。通过《Advanced 2D Game Development》，读者不仅可以学习到具体的编程技巧，还能了解到游戏开发过程中的最佳实践和行业标准，从而提升自己的游戏开发能力。此外，这本书可能还包含实际项目案例，让读者有机会将所学应用到实践中。

Advice

Direct3D is the only DirectX component that has been updated to version 10. None of the other

components (DirectSound, DirectInput, and s o on) has changed much (if at all) since around 2004.

All this means is that DirectInput does what it needs to do just fine and needs no new updates,

just as DirectSound supports high-definition audio systems and 3D positional sound without

needing to be updated further. However, Direct3D is updated regularly to keep up with the latest

graphics hardware.

I recommend you use an older version of DirectX, even if you’re using Visual

Cþþ. Although the November 2007 and future releases may work, there is no

guarantee, as Microsoft is not dedicated to preserving backwards compatibility.

For instance, the October 2006 release is a good one that I use most often (and

this is the version provided on the CD). Just remember this advice when it comes

to game development—the latest and greatest tools are not always preferable for

every game project.

Advice

We do not study the basics of DirectX in this advanced book. If you have never written a line of

DirectX code in your life, then you will need a crash course first. I recommend

Beginning Game

Programming, 2nd Edition

(Course Technology, 2006), which will teach you all of the basics at a

very slow pace. The first four chapters cover Windows programming before even getting into

DirectX, and only ambient lighting is covered to keep the examples simple for beginners.

Why Do We Need an Engine?

What is the purpose or advantage of a game engine, as opposed to, say, just

writing all the code for a game as needed? Why invest all the time in creating a

game engine when you could spend that time just writing the game?

These are valid questions that I have pondered over the years while developing

small and large game projects (especially those for college courses). The simple

answer is: You don’t need an engine to write a game. But that is a loaded answer

because it implies that either 1) The game is very simple, or 2) You already have a

lot of code from past projects. The ﬁrst implication is that you can just write a

simple game with DirectX or OpenGL code. The second assumes that you have

some code already available, perhaps in a game library—ﬁlled with functions

you’ve written and reused. A game library saves a lot of time. For instance, it’s a

given that you will load bitmap ﬁles for use in 2D artwork or 3D textures, and

once you’ve written such a function, you do not want to have to touch it again,

because it serves a good purpose. Anytime you have to open up a function and

Why Do We Need an Engine? 5

modify it, that’s a good sign that it was poorly written in the ﬁrst place. (Then

again, it’s possible you have gained new knowledge and want to improve your

functions, which is valid.)

In my opinion, there are three key reasons why a game engine will help a game

development project: teamwork, cross-compiler support, and logistics. Let’s

examine each issue.

1. Teamwork is much easier when the programmers in a team use a game

engine rather than writing their own core game code, because the engine

code facilitates standardization across the project. While each programmer

has his or her own preferences about how timing should be handled, or how

rendering should be done, a game engine with a single high-speed game loop

forces everyone on the team to work with the features of the engine. And

what of features that are lacking? Usually one or two team members will be

the ‘‘engine gurus’’ who maintain the engine based on the team’s needs.

2. Cross-compiler support is almost impossible without the use of a game

engine. Although many programmers are adept at writing standard Cþþ

code that will build on multiple platforms and compilers, game code usually

does not fall into that realm due to its unique requirements (namely, ren-

dering). Cross-compiler support is the ability to compile your game with

two or more compilers, rather than just your favorite (such as Visual Cþþ).

Advice

Writing code that builds on compilers from more than one vendor teaches you to write good,

standard

code, without any ties to a specific platform. It’s

hard

to write platform-independent

code! Be prepared for a serious workout!

3. Logistics in a large game project can be a nightmare without some

coordinated way to organize the entities, processes, and behaviors in your

game. Logistics is the problem of organizing and supporting a large system,

and is often used to describe military operations (for example, the logistics

of war—equipping, supplying, and supporting troops). The logistics of a

game involve the characters, vehicles, crafts, enemies, projectiles, and

scenery—in other words, the ‘‘stuff’’ in a game. Without a system in place to

assist with organizing all of these things, the game’s source code can become

an unmanageable mess.

6 Chapter 1

Building a 2D Game Engine

Let’s summarize all of these points in a simple sentence: A game engine makes it

easy—sometimes ridiculously easy—to make a game. Contrast that with the

problems associated with creating a game from scratch using your favorite APIs,

such as Direct3D or OpenGL for graphics, DirectInput for mouse and keyboard

support, Winsock for networking, FMOD for audio, and so forth. The logistics of

keeping up with the latest updates to all of these libraries alone can be a nightmare

for a game developer. But by wrapping all of these libraries and all of your own

custom game code into a game engine, you eliminate the headache of maintaining

all of those libraries (including their initialization and shutdown) in each game. The

best analogy I can come up with is this: ‘‘Rolling your own’’ game code for each

game project is like fabricating your own bricks, forging your own nails, and cutting

down your own trees in order to build a single house. Why would you do that?

Indeed!

But perhaps the most signiﬁcant beneﬁt to wrapping an API (such as DirectX)

into your own game engine classes is to provide a buffer around that API’s

unpredictable future revisions. Whenever a change occurs in a library that you

regularly use in your games, you can accommodate those changes in your engine

classes without having to revise any actual game code in the process. Based on my

comments already about the problems with compatibility in software today, this

is an especially important point to take to heart.

Creating the Engine Project

We are going to create the core game engine project in this chapter and then

expand it over the next half-dozen chapters to include all of the features we need

to build advanced 2D games. The starting point is the core engine developed in

this chapter, which will include WinMain, Direct3D initialization, D3DXSprite

initialization, the basic starting game event functions (

game_init(), and so on),

timing and automatic frame-rate maintenance, and of course, a game loop. The

great thing about doing all of this right now, at the very beginning, is that we will

not have to duplicate any of this code in future chapters—it will already be

embedded in the game engine.

Let’s get started creating the engine project so that we’ll have a foundation with

which to discuss the future design of our engine. The

Engine class is embedded in

a namespace called Advanced2D. This namespace will contain all of the engine

classes so there will not be any conﬂicts with other libraries you may need to use

Creating the Engine Project 7

in a game. I will go over the project creation for two compilers in detail now and

show you which libraries you will need to include in the project, so that you may

refer to this chapter again for future projects. We will continue to build on the

Engine project (which you are about to create) in future chapters.

Dev-Cþþ Project

(Note: If you are using Visual Cþþ, you may skip this section.) Dev-Cþþ 5.0 is

a modern Cþþ compiler based on the GCC MinGW kit for Windows, and it

is available for install from the book’s CD. The actual revision at the time of this

writing is 4.9.9.2. You may check www.bloodshed.net for updates. By default,

Dev-Cþþ includes Win32 compatibility, meaning you can compile Windows

code with it using GCC versions of the Windows API. The API is really just a

collection of library ﬁles (such as gdi32 and winmm). The library ﬁle extension

for GCC libraries is .a, while the library ﬁle extension for MSVC libraries is .lib,

and they are not compatible. Since Dev-Cþþ includes the Win32 API, that really

simpliﬁes conﬁguration.

However, DirectX is not included, so we must install it. The DirectX SDK distributed

by Microsoft does not work with Dev-Cþþ (because of the library ﬁle format), but

there is a third-party version of the DirectX SDK available for Dev-Cþþ (and GCC

compilers in general), which is available on the book’s CD.

First, install Dev-Cþþ if you have not done so already. The installer is available

on the CD-ROM, or you may download it from www.bloodshed.n et/dev/

devcpp.html. After you have installed Dev-Cþþ, then you can install the DirectX

DevPak, either from the CD or from this URL: www.g-productions.net/

list.php?c=ﬁles_devpak. (Be sure to download the 9.0c version.) The DirectX

installer is shown in Figure 1.1. After installation is complete, the DirectX library

will show up in the Package Manager, as shown in Figure 1.2.

With the DirectX library now available, we can create a new project. Open Dev-

Cþþ and click File, New, Project. This will bring up the New Project dialog

shown in Figure 1.3. Name this new project ‘‘Engine’’ (or whatever you choose).

Make sure you choose Windows Application and Cþþ Project (from the options

on the lower right). Although a DirectX template is available (as you can see on

the New Project dialog tabs list), we will not be using the template because it

includes too much code, and we want to start off with a simple, empty project.

More than likely, the provided DirectX template won’t meet your needs anyway

8 Chapter 1

Building a 2D Game Engine

剩余329页未读，继续阅读

liziyuanhahaha

粉丝: 1
资源: 40

精通2D游戏开发：经典指南

Advanced 2D Game Development 无水印pdf

Advanced 2D Game Development.pdf

Learn iPhone and iPad Cocos2D Game Development

Mastering.Cocos2d.Game.Development.1784396710

Unity.5.x.2D.Game.Development.Blueprints

Learning.Cocos2d-JS.Game.Development

Mobile Game Development with Unity

.Learning.iPhone.Game.Development.with.Cocos2D.3.0

iPhone Game Development (epub 格式)

Hands-On Game Development with WebAssembly Learn WebAssembly C++.epub

最新资源