使用Android构建与移植经典游戏

需积分: 9 179 浏览量更新于2024-07-31 收藏 3.99MB PDF 举报

"Pro Android Games电子书是一本针对中级到高级用户的书籍，专注于教授如何在Android平台上创建和移植经典游戏，如Space Blaster、Asteroids™、Doom和Wolfenstein™3D。作者Vladimir Silva提供了一种独特视角，结合了纯Java和混合游戏开发（使用JNI将C语言的游戏移植到Android）的方法。" 本书的核心知识点： 1. **Android游戏开发基础**：书中介绍了Android游戏开发的基础知识，包括Android平台的游戏架构、游戏引擎选择以及游戏开发环境的搭建，这对于初学者来说是非常重要的入门内容。 2. **Java编程**：作为Android开发的主要语言，Java在游戏开发中的应用是本书的一大重点。读者将学习如何使用Java来编写游戏逻辑、处理用户输入、实现游戏循环以及优化性能。 3. **游戏设计与实现**：通过构建Space Blaster和Asteroids™这样的游戏实例，读者可以学习到游戏设计的基本原则，包括游戏规则、界面设计、动画效果和碰撞检测等。 4. **经典游戏移植**：Doom和Wolfenstein™3D等经典游戏的移植过程展示了如何利用Java Native Interface (JNI)将C/C++代码与Android Java代码结合，这涉及到跨语言编程和原生库的使用。 5. **JNI原理与应用**：JNI是Android系统中用于调用本地代码的接口，本书会深入讲解如何使用JNI来调用C/C++库，以及在游戏开发中如何管理和优化JNI代码，提高游戏性能。 6. **性能优化**：Android游戏开发的一个关键方面是性能优化，书中可能会涵盖内存管理、渲染优化、多线程编程以及设备适应性等内容，帮助开发者提升游戏体验。 7. **源码在线**：购买本书的读者可以访问源代码，这提供了实际操作和学习的机会，通过阅读和修改代码，可以更好地理解游戏开发的细节。 8. **中级至高级内容**：本书定位为中级到高级开发者，因此除了基础概念外，还涵盖了更复杂的主题，如游戏物理引擎、网络对战功能和社交元素的集成。 9. **专业实践**：作者作为一个专业背景的开发者，分享了他的经验和技巧，这有助于读者避开常见的陷阱，提高开发效率。通过学习《Pro Android Games》，开发者不仅可以掌握Android游戏开发的基本技能，还能了解到如何将经典游戏带到Android平台，从而提升自己的游戏开发能力。这本书是想要在Android平台上创造精彩游戏的开发者的重要参考资料。

■ INTRODUCTION

xiv

GNU C Compiler for ARM Processors

A GNU C compiler is required for the hybrid games in the book. These games combine Java code with a

native core library, hence the need for a C compiler that targets the mobile ARM processor. The compiler

used in this book and detailed in Chapter 1 is the Code Sourcery GNU G++ Toolkit. You are not bound,

however, to use this compiler; as a matter of fact, you can use any C compiler capable of generating ARM

code, including the Android Native Development Kit (NDK).

Chapter Source

This is an optional tool but it will help you greatly to understand the concepts as you move along. I have

made my best effort to describe each chapter as simply as possible. Nevertheless, some of the games

(especially Wolf 3D and Doom) have very large core engines written in C (100K lines for Doom), which

are poorly commented and very hard to understand. All in all you will see how easily these great

languages (Java and C) can be combined with minimal effort. Get the companion source for the book

from the publisher at http://www.apress.com. It was built using Eclipse Galileo.

What Makes This Book Unique?

I think it is important for the reader to understand my goal with this manuscript and what I believe sets

this book apart. Even though Java is the primary development language for Android, Google has realized

the need for hybrid Java/C development if Android is to succeed as a gaming platform, so much so that

they released the Native Development Kit (NDK). Google is realizing the need to support C development

to catch up with the overwhelming number of native games written for other mobile platforms like the

iPhone. PC games have been around for decades (mostly written in C), and by using a simple ARM C

compiler, you could potentially bring thousands of PC games to the Android Platform. This is what

makes this book unique. Why translate 100k lines of painfully complicated code from C to Java if you can

just combine both languages in an elegant manner with significant savings on time and money? My

book will help you to do just that. This is my goal and what makes this book stand out. In the other hand,

this book also includes chapters of pure Java games in a well-balanced layout to satisfy both the Java

purist and the C lover in you.

Android SDK Compatibility

As a developer you may ask yourself about the SDK compatibility of the code in this book. This is an

important question as new versions of the Android SDK come out frequently. By the time of this writing,

Google released the Android SDK version 2.0. The code in this chapter has been tested with the following

versions of the Android SDK:

• SDK version 2.0

• SDK version 1.6

• SDK version 1.5

• SDK version 1.0

■ INTRODUCTION

The bottom line is that the code in this book will run in any version of the SDK from 2.0 to 1.0, and that

was my intention all along.

SDK Changes for Version 1.6

Virtually nothing has changed from versions 1.5 to 1.6 of the platform when it comes to game

development. For a detailed list of API changes in version 1.6, see

http://developer.android.com/sdk/RELEASENOTES.html.

This book has a well-balanced layout of pure Java and hybrid games, divided as follows:

Chapter 1

This chapter provides the first step to set up a Linux system for hybrid game compilation, including

fetching the Android source, extracting device system libraries, setting up a custom compilation

toolchain, custom compilation scripts, plus details on setting up the Eclipse IDE for use throughout the

rest of the book.

Chapter 2

In this chapter you will learn how to combine Java and C code in an elegant manner by building a simple

Java application on top of a native library. You will learn exciting concepts about the Java Native

Interface (JNI) and the API used to combine Java and C in a single unit, including how to load native

libraries, how to use the native keyword, how to generate the JNI headers, plus all about method

signatures, Java arrays vs. C arrays, invoking Java methods, compiling and packing the product, and

more.

Chapter 3

This chapter is the first in a series to explore pure Java gaming with a real-world game dubbed Space

Blaster. The goal of this game is to maneuver (using your finger tips or the keyboard) a space ship

through a field of meteors. This chapter will teach you how to build custom XML-based linear layout,

how to use an abstract class and timer tasks to simulate a simple game loop, how to invalidate views

within a non-UI thread, how to load sprites and sounds from the project resources, plus drawing

techniques such as sprite animations, drawing simple objects, and setting style and color using the Paint

object.

Chapter 4

Pure Java games continue in Chapter 4 with the arcade classic Asteroids. This chapter will teach you all

about drawing polygon sprites on the Android canvas. This is a somewhat difficult technique due to the

lack of polygon support in the Android API. The chapter relies on the high portability of the Java

language to bring polygon code from the J2SE API into the Android API to ultimately create Asteroids. As

■ INTRODUCTION

xvi

you may have noticed, this is a mostly Polygon-based game. Other interesting topics include game life

cycle steps, initialization, draw, and update physics, responding to key and touch events, plus testing on

the device emulator.

Chapter 5

This chapter deals with 3D graphics with OpenGL. It presents a neat trick I stumbled on by coincidence

that allows for mixing OpenGL API calls in both Java and C. This concept is illustrated by using the 3D

cubes sample provided by Google to demonstrate OpenGL in pure Java and hybrid modes. This trick

could open a new frontier of 3D development for Android with the potential to bring a large number of

3D PC games to the platform with enormous savings in development costs and time.

Chapter 6

This is the first chapter in a series of two, which are my personal favorites of this book. Here it brings the

godfather of all PC 3D shooters to the Android platform—Wolfenstein 3D. Who would have thought that

a PC game like this one could be brought to an Android mobile device with minimal effort? This chapter

demonstrates how Java and C can coexist harmoniously and includes topics such as the basic game

architecture (showing how the Java and C components fit together), resource handlers for sound, music,

key and touch events, how to use JNI to cascade graphics information, video buffers, and sound/music

requests back to Java, plus compilation and testing.

Chapter 7

Chapter 7 takes things to the next level with the ground-breaking game for the PC—Doom. Doom is

arguably the greatest 3D game ever created and opened new frontiers in 3D graphics. The ultimate goal

of this chapter is not to describe the game itself, but to show you how easy it is to bring a complex PC

game like Doom to the Android platform. The proof? Doom is 100+K lines of C code and brought to

Android with less than 200 lines of extra JNI API calls, plus the Java code required to build the mobile UI.

This chapter shows that you don’t have to translate 100K lines of C into Java but simply marry these two

powerful languages in an elegant application. Consider the potential savings in development time and

costs! This chapter is a must-read.

C H A P T E R 1

■ ■ ■

Welcome to Android Gaming

Welcome to the world of Android Games! The goal of this book is to help you build the best games for the

platform. As you work your way through the chapters, you will learn how to create two kinds of games:

pure Java, and perhaps most interestingly, hybrid games that combine the elegant design of Java with

the raw power of C for maximum performance. The ability to combine both Java and C in this way is

what makes the games in this book unique, as Google does not support this kind of development. But

you may ask, “Why even bother with hybrid games?” After all, Java provides all the APIs you need to

build any kind of game. This is certainly true. However, there are thousands of games out there written

in C that can be brought to Android by compiling the C core and wrapping a Java graphical user

interface (GUI) using the Java Native Interface (JNI). In this book, you’ll learn how to bring to the

platform two of the great 3D shooter games for the PC: Wolfenstein 3D and Doom.

The bottom line? My goal is to bring to you the latest documented and undocumented secrets to

building games for Android. Furthermore, if your plan is to port a PC game, this book will provide you

with invaluable expertise to do so. But before we get started, there are some things you need to know to

get the most from this book.

What Skills Do You Need?

In this book, I am targeting seasoned game developers, not only in Java, but also in C. This makes sense,

as performance is critical in game development. Java provides elegant object-oriented capabilities, but

only C gives you the power boost that game development needs. This is the best of both worlds in the

palm of your hand. This book assumes you are familiar with Android, as well as Linux and shell scripting.

A Solid Foundation of Android

This book assumes that you already know the basics of Android development. For example, you need to

know what activities, views, and layouts are. Consider the following fragment. If you understand what it

does just by looking at it, then you are in good shape.

public class MainActivity extends Activity

{

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

CHAPTER 1 ■ WELCOME TO ANDROID GAMING

}

This fragment defines the main activity or class that controls the life cycle of the application. The

onCreate method will be called once when the application starts, and its job is to set the content layout

or GUI for the application.

You should also have a basic understanding of how GUIs are created using XML. Look at the next

fragment. Can you tell what it does?

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout

xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="fill_parent">

<ImageView android:id="@+id/doom_iv"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:background="@drawable/doom"

android:focusableInTouchMode="true" android:focusable="true"/>

<ImageButton android:id="@+id/btn_upleft"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_alignParentBottom="true"

android:layout_alignParentLeft="true"

android:src="@drawable/img1" />

</RelativeLayout>

This code defines a relative layout. In a relative layout, widgets are placed relative to each other

(sometimes overlapping). In this case, there is an image view that fills the entire screen. This image will

display as the background the file called doom.png stored in the res/drawable folder of the project, and

receive key and touch events. In the lower left of the screen, overlapping the image view, an image

button with the ID btn_upleft will be displayed.

Need an Android Tutorial?

There are a lot of concepts related to Android development, and it is impossible to remember every detail

about activities, views, and layouts. A handy place to access this information quickly is the Android tutorial:

http://developer.android.com/

The ultimate guide for Android developers—the latest releases, downloads, SDK Quick Start, version

notes, native development tools, and previous releases—can be found here:

http://developer.android.com/sdk/1.6_r1/index.html

Throughout this book (especially in the chapters dealing with native code), I make extensive use of

the Android Software Development Kit (SDK) command tools (for system administrator tasks). Thus,

剩余316页未读，继续阅读

机械师2

粉丝: 7
资源: 28

使用Android构建与移植经典游戏

Pro_Android_Games%28code%29.zip

Android 3D游戏开发书籍(Pro_Android_Games)

Android英文非影印版

使用Android开发经典游戏实战指南

深度解析：Android SD卡主要文件夹用途

使用Java和C创建Android 3D游戏指南

Android专业游戏开发指南：从经典到现代

打造Android 3D游戏杰作：空间与经典游戏开发指南

打造Android游戏专业指南：从Space Blaster到Doom的开发与移植

基于Java的家庭理财系统设计与开发-金融管理-家庭财产管理-实用性强

最新资源