Wednesday, June 27, 2012

Android Game Programming using Unity

http://docs.unity3d.com/Documentation/Manual/index.html

Unity Manual

Welcome to Unity.

Unity is made to empower users to create the best interactive entertainment or multimedia experience that they can. This manual is designed to help you learn how to use Unity, from basic to advanced techniques. It can be read from start to finish or used as a reference.

The manual is divided into different sections. The first section, User Guide, is an introduction to Unity's interface, asset workflow, and the basics of building a game. If you are new to Unity, it is recommended that you start learning by reading the Unity Basics subsection.

The next section, FAQ, is a collection of frequently asked questions about performing common tasks that require a few steps.

The last section, Advanced, addresses topics such as game optimization, shaders, file sizes, and deployment.

When you're done reading, be sure to take a look at the Reference Manual and the Scripting Reference for further details about the different possibilities of constructing your games with Unity.

If you find that any question you have is not answered in this manual please ask on Unity Answers or Unity Forums. You'll definitely find your answer there.

Happy reading,
The Unity team

The Unity Manual Guide contains sections that apply onto to certain platforms. Please select which platforms you want to see. Platform-specific information can always be seen by clicking on the disclosure triangles on each page.

User Guide
- Unity Basics
- Building Scenes
  - GameObjects
    - The GameObject-Component Relationship
    - Using Components

The Component-Script Relationship

Using the Inspector
- Editing Value Properties

Particle Effects (Shuriken)

Beginning Android Game Programming

http://mobile.dzone.com/articles/beginning-android-game

Scott Mccain

Beginning Android Game Programming

10.01.2010

Introduction

Game development on the Android platform is challenging and rewarding and comes with it's own set of pitfalls and hard learned lessons. In this series of articles I hope to show you some of those pitfalls and maybe teach a lesson or two along the way. While you will be challenged I also hope to help you see the rewards that can come from those challenges.

Background

Mobile Java applications are not a new concept and in fact were one of the original focuses of Sun when it because the java project. There have been mobile java games since the first JVM was put on a mobile device. In the case of the Android things are a little bit different. Android uses what is called the Dalvik Virtual Machine, or DVM, which is an opensource implementation of a JVM. There are several differences between Dalvik and a standard JVM, some subtle, some not so subtle. The DVM is also not aligned to either Java SE or Java ME, but to an apache implementation called Apache Harmony Java. All of this makes for a slight learning curve if you happen to be transitioning from Java ME.

Basic Game Architecture

This example requires three basic classes in order to implement a basic game. The game logic can be extended or changed and the resources can be replaces easily using the same patterns. The file DrawablePanel.java contains the code for DrawablePanel which extends SurfaceView and provides a full screen canvas. The DrawablePanel contains an AnimationThread. This class extends Thread (you could also provide a runnable, whatever pattern is more familiar). The AnimationThread class holds a reference to the DrawablePanel described above and updates the DrawablePanel for game logic and forces a redraw of the panel.

First Steps

I will be using Eclipse as the compilation tool for this tutorial. I am also using the Android Eclipse plugin. Eclipse can be found at www.eclipse.org/downloads and you can find the ADT plugin at developer.android.com/sdk/eclipse-adt.html

First create an Android project:

Since I will be demonstrating an animated sprite implementation we need a sprite strip. Here is the sprite strip we will be using:

You have to add the asset to the project:

Code

Now we come to the actual coding. First we will create the AnimatedSprite class since that has the least amount of dependencies.

AnimatedSprite class

package com.android.tutorial;

 

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Rect;

 

public class AnimatedSprite {

private Bitmap animation;

private int xPos;

private int yPos;

private Rect sRectangle;

private int fps;

private int numFrames;

private int currentFrame;

private long frameTimer;

private int spriteHeight;

private int spriteWidth;

 

public AnimatedSprite() {

sRectangle = new Rect(0, 0, 0, 0);

frameTimer = 0;

currentFrame = 0;

xPos = 80;

yPos = 200;

}

 

public void Initialize(Bitmap bitmap, int height, int width, int fps,int frameCount) {

this.animation = bitmap;

this.spriteHeight = height;

this.spriteWidth = width;

this.sRectangle.top = 0;

this.sRectangle.bottom = spriteHeight;

this.sRectangle.left = 0;

this.sRectangle.right = spriteWidth;

this.fps = 1000 / fps;

this.numFrames = frameCount;

}

 

public int getXPos() {

return xPos;

}

 

public int getYPos() {

return yPos;

}

 

public void setXPos(int value) {

xPos = value;

}

 

public void setYPos(int value) {

yPos = value;

}

 

public void Update(long gameTime) {

if( gameTime > frameTimer + fps) {

frameTimer = gameTime;

currentFrame += 1;

 

if( currentFrame >= numFrames ) {

currentFrame = 0;

}

 

sRectangle.left = currentFrame * spriteWidth;

sRectangle.right = sRectangle.left + spriteWidth;

}

}

 

public void draw(Canvas canvas) {

Rect dest = new Rect(getXPos(), getYPos(), getXPos() + spriteWidth,

getYPos() + spriteHeight);

canvas.drawBitmap(animation, sRectangle, dest, null);

}

}

Here we can see that AnimateSprite is a fairly simple class. It basically keeps track of what frame it's currently displaying and increments it during update if the appropriate time has elapsed. If it reaches the end of the list it will wrap around and begin rendering at the start of the list again.

I've abstracted the interaction between the animation logic and display logic with an interface called ISurface. Let's look at that interface now.

ISurface interface

package com.android.tutorial;

 

import android.graphics.Canvas;

 

public interface ISurface {

void onInitalize();

void onDraw(Canvas canvas);

void onUpdate(long gameTime);

}

Here we can see that the ISurface interface provides some basic functions. One for initialization which is called at startup or when the sprite is first initialized. The second is the draw function which is pretty self explanatory. The final function is the update function which is what is used by the animation thread to update it's animation(s).

Let's look at the AnimationThread now

AnimationThread class

package com.android.tutorial;

 

import android.graphics.Canvas;

import android.view.SurfaceHolder;

 

public class AnimationThread extends Thread {

private SurfaceHolder surfaceHolder;

private ISurface panel;

private boolean run = false;

 

public AnimationThread(SurfaceHolder surfaceHolder, ISurface panel) {

this.surfaceHolder = surfaceHolder;

this.panel = panel;

 

panel.onInitalize();

}

 

public void setRunning(boolean value) {

run = value;

}

 

private long timer;

 

@Override

public void run() {

 

Canvas c;

while (run) {

c = null;

timer = System.currentTimeMillis();

panel.onUpdate(timer);

 

try {

c = surfaceHolder.lockCanvas(null);

synchronized (surfaceHolder) {

panel.onDraw(c);

}

} finally {

// do this in a finally so that if an exception is thrown

// during the above, we don't leave the Surface in an

// inconsistent state

if (c != null) {

surfaceHolder.unlockCanvasAndPost(c);

}

}

}          

}

}

This class isn't doing much either, but what it is doing is very important. This class extends Thread. You could also create a runnable and implement threading that way. This way is more obvious which is why I chose it. The run function of this class is where all the work is being done. In this case the function retrieves the current system time and calls it's dependent panel's update function. It then obtains an exclusive lock on the containing surface's canvas and passes that canvas to the surface view's draw function. This call is synchronized to ensure stability.

Now we need to provide a concrete implementation of the ISurface interface for our tutorial. This will be the responsibility of the DrawablePanel class. Let's look at that class now:

DrawablePanel class

package com.android.tutorial;

 

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

 

public abstract class DrawablePanel

extends SurfaceView

implements SurfaceHolder.Callback, ISurface {

 

private AnimationThread thread;

 

public DrawablePanel(Context context) {

super(context);

getHolder().addCallback(this);

 

this.thread = new AnimationThread(getHolder(), this);

}

 

@Override

public void onDraw(Canvas canvas) {

}

 

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width,

int height) {

}

 

@Override

public void surfaceCreated(SurfaceHolder holder) {

thread.setRunning(true);

thread.start();

}

 

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

boolean retry = true;

thread.setRunning(false);

while (retry) {

try {

thread.join();

retry = false;

} catch (InterruptedException e) {

// we will try it again and again...

}

}          

}

}

This class extends SurfaceView and implements the SurfaceHolder.Callback interface. This is one technique to create a custom view. This class also implements our ISurface interface. It also has an AnimationThread. During construction the class does some standard plumbing to hookup the SurfaceHolder.Callback interface and starts the AnimationThread we looked at earlier. One of the parameters of the AnimationThread is an ISurface. This is where we can hook up our update and draw events to the animation thread. In this case we don't have to perform any logic for either event so they are left as empty functions. The final point of interest is surface creation or destruction. This will occur if your app goes out of focus for any reason. This could be because the user hit the home button, the app is being put to sleep, or the operation system is cleaning up memory for a larger foreground app. There are other reasons but those are the most common. In this case we have to make sure the thread no longer pumps animations and tries to draw to the canvas since the canvas will no longer exist. This is done by stopping the thread in the surfaceDestroyed callback. The thread is started in the surfaceCreated callback. This is the main reason for implementing the SurfaceHolder.Callback interface.

Finally edit the main activity class AndroidTutorial.java and replace the code with the following:

AndroidTutorial activity

package com.android.tutorial;

 

 

import android.app.Activity;

import android.content.Context;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.os.Bundle;

 

public class AndroidTutorial extends Activity {

AnimatedSprite animation = new AnimatedSprite();

 

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(new AndroidTutorialPanel(this));

}

 

class AndroidTutorialPanel extends DrawablePanel {

 

public AndroidTutorialPanel(Context context) {

super(context);

}

 

@Override

public void onDraw(Canvas canvas) {

super.onDraw(canvas);

AndroidTutorial.this.animation.draw(canvas);

}

 

@Override

public void onInitalize() {

AndroidTutorial.this.animation.Initialize(

BitmapFactory.decodeResource(

getResources(),

R.drawable.explosion),

32, 32, 14, 7);

}

 

@Override

public void onUpdate(long gameTime) {

AndroidTutorial.this.animation.Update(gameTime);

}

}

 

}

In this class we create an inner class called AndroidTutorialPanel which extends the DrawablePanel class we looked at above. Since DrawablePanel is an ISurace AndroidTutorialPanel overrides the ISurface members and provides custom implementation. In this case the class creates, updates, and draws an instance of an AnimatedSprite which we looked at previously. One point of interest is the creation of the sprite. The constructor expects a resource id, a resource height and width, and finally some timing values. These values control how many times per second the animation is drawn and how many frames to draw. You can use this to create many animations from a single sprite sheet and customize how fast those animations run.

Conclusion

You can easily extend this framework with your own panels or animation threads even. You can even customize your animation sprites how you see fit such as adding velocity, acceleration, or even a complete physics framework. There is no limit accept your own imagination.

Here is a screen shot of the demo in action:

Attachment	Size
Block Diagram.img_assist_custom-300x388.png	27.82 KB
New_Android_Project-09.27.2010-09.20.05PM.png	42.79 KB
explosion.png	3.73 KB
SS-09.27.2010-09.27.45PM.jpg	17.42 KB
New_Java_Class-09.27.2010-09.34.44PM.img_assist_custom-300x359.png	46.99 KB
New_Java_Interface-09.27.2010-09.37.16PM.img_assist_custom-300x299.png	73.09 KB
New_Java_Class-09.27.2010-09.41.27PM.img_assist_custom-300x359.png	47.02 KB
New_Java_Class-09.27.2010-09.39.59PM.img_assist_custom-300x359.png	46.96 KB
5554GPSTester-09.29.2010-08.52.43AM.img_assist_custom-300x213.png	36.6 KB
AndroidGameTutorial.zip

NotaRazi

Auto-generate Flow Chart from Java/C++ Codes:

Raptor Flowchart Tutorial For Beginners

Wednesday, June 27, 2012

Android Game Programming using Unity

Unity Manual

Table of Contents

Beginning Android Game Programming

Beginning Android Game Programming

Introduction

Background

Basic Game Architecture

First Steps

Code

AnimatedSprite class

ISurface interface

AnimationThread class

DrawablePanel class

Conclusion