Java Bulgaria » Java Game Development

Developing Applications with JBoss and Hibernate: Part 1

admin — Wed, 03 Feb 2010 18:04:13 +0000

In this article, by Francesco Marchioni, we will introduce Hibernate, which is the de facto standard object-relational mapping framework for Java applications. The Hibernate galaxy is quite large and needs a book of its own to be fully explored. Our mission will be to take over one sector of this galaxy, especially where Hibernate applications are managed by JBoss AS.

In this two-part article, we will cover the following topics:

A short introduction to Hibernate

Setting up our proof of concept for the Hibernate project

Reverse engineering a database schema into Hibernate POJOs and mapping files

Deploying the application to JBoss AS

Comparing the Hibernate technology with EJB 3 persistence (JPA)

Introducing Hibernate

Hibernate provides a bridge between the database and the application by persisting application objects in the database, rather than requiring the developer to write and maintain lots of code to store and retrieve objects.

The main configuration file, hibernate.cfg.xml, specifies how Hibernate obtains database connections, either from a JNDI DataSource or from a JDBC connection pool. Additionally, the configuration file defines the persistent classes, which are backed by mapping definition files.

This is a sample hibernate.cfg.xml configuration file that is used to handle connections to a MySQL database, mapping the com.sample.MySample class.



user
password

 jdbc:mysql://localhost/database


 com.mysql.jdbc.Driver


 org.hibernate.dialect.MySQLDialect

From our point of view, it is important to know that Hibernate applications can coexist in both the managed environment and the non-managed environment. An application server is a typical example of a managed environment that provides services to hosting applications, such as connection pooling and transaction.

On the other hand, a non-managed application refers to standalone applications, such as Swing Java clients that typically lack any built-in service.

In this article, we will focus on managed environment applications, installed on JBoss Application Server. You will not need to download any library to your JBoss installation. As a matter of fact, JBoss persistence layer is designed around Hibernate API, so it already contains all the core libraries.

Creating a Hibernate application

You can choose different strategies for building a Hibernate application. For example, you could start building Java classes and map files from scratch, and then let Hibernate generate the database schema accordingly. You can also start from a database schema and reverse engineer it into Java classes and Hibernate mapping files. We will choose the latter option, which is also the fastest. Here’s an overview of our application.

In this example, we will design an employee agenda divided into departments. The persistence model will be developed with Hibernate, using the reverse engineering facet of JBoss tools. We will then need an interface for recording our employees and departments, and to query them as well.

The web interface will be developed using a simple Model-View-Controller (MVC) pattern and basic JSP 2.0 and servlet features.

The overall architecture of this system resembles the AppStore application that has been used to introduce JPA. As a matter of fact, this example can be used to compare the two persistence models and to decide which option best suits your project needs. We have added a short section at the end of this example to stress a few important points about this choice.

Setting up the database schema

CREATE schema hibernate;
GRANT ALL PRIVILEGES ON hibernate.* TO 'jboss'@'localhost' WITH GRANT
OPTION;
CREATE TABLE `hibernate`.`department` (
`department_id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
`department_name` VARCHAR(45) NOT NULL,
PRIMARY KEY (`department_id`)
)
ENGINE = InnoDB;
CREATE TABLE `hibernate`.`employee` (
`employee_id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
`employee_name` VARCHAR(45) NOT NULL,
`employee_salary` INTEGER UNSIGNED NOT NULL,
`employee_department_id` INTEGER UNSIGNED NOT NULL,
PRIMARY KEY (`employee_id`),
CONSTRAINT `FK_employee_1` FOREIGN KEY `FK_employee_1` (`employee_
department_id`)
REFERENCES `department` (`department_id`)
ON DELETE CASCADE
ON UPDATE CASCADE
)
ENGINE = InnoDB;

With the first Data Definition Language (DDL) command, we have created a schema named Hibernate that will be used to store our tables. Then, we have assigned the necessary privileges on the Hibernate schema to the user jboss.

Finally, we created a table named department that contains the list of company units, and another table named employee that contains the list of workers. The employee table references the department with a foreign key constraint.

A new Eclipse project

Now start Eclipse. You don’t have a specific project for Hibernate applications, so a utility project (which simply packs the classes in an archive) will be enough. You can reach this option from the menu by going to New | Other | Java EE | Utility Project.

Name the project HibernateProject and target it to JBoss AS 5.0 Runtime. You can leave the default JBoss AS configuration and hit Finish.

Now, we are going to unleash the full potential of Hibernate tools. Select from the menu New | Other | Hibernate | Hibernate Configuration File. The Hibernate configuration contains all of the details for wiring your application to the database. You will be asked for the name and the parent folder of the configuration file. Accept the default hibernate.cfg.xml at the root of your project.

Next, insert the details of your Hibernate configuration. Choose a name for your SessionFactory, which will contain your MySQL connection facets. Remember to check the flag Create a console configuration, so that the wizard will complete the console configuration as the next step.

A console configuration describes how the Hibernate plugin should interact with Hibernate and what configuration files (including the classpath) are needed to load the POJOs, JDBC drivers, and so on. This step is required to make use of query prototyping, reverse engineering, and code generation.

The console wizard will look at the current selection in the IDE and will try to autodetect the settings, which you can approve or modify to suit your needs. For example, you don’t need to enter the Configuration file or the Property file if you have just one in your project; Eclipse will select it automatically.

One important selection is the Type option that lets you choose between the Core hibernate configuration (Java classes backed by mapping files), Annotations, or even JPA annotations. We will leave the selected Core option.

Before clicking Finish, select MySQL (InnoDB) as Database dialect in the Options tab. No other changes are required.

Now verify that you have successfully linked to Hibernate by switching to Hibernate Perspective. This view will be composed by a tree of three objects: Configuration, Session Factory, and Database. Choose Database and verify that it expands correctly to show the database tables of your schema.

If you fail to browse the database schema, check that you have correctly set up your Hibernate configuration.

Reversing your schema into Java classes

The next move will be reversing our database schema into Java classes and mapping files. This powerful feature is available from the menu: File | New | Hibernate | Hibernate Reverse Engineering file. You can place this file in a convenient location for your project and choose a name for it. The default name proposed is hibernate.reveng.xml, which looks rather the tile of another fiction movie from G. Lucas.

On the next page, select your Console configuration and choose the tables that will be included in your reverse engineering process. (Hint: You have to hit Refresh first to show the database schema and then click Include….)

What Eclipse has just created for you is a file named hibernate.reveng.xml that should resemble the following code snippet:

If you are smart at noticing variations, you might have discovered a new icon in your toolbar. This is your gateway to the reverse engineering process. (Notice: this icon is visible only in the Hibernate Perspective, you will not be able to find it anywhere else.)

Click on Hibernate’s down arrow icon and select Hibernate Code Generation Configurations. In the next dialog, you will first have to create a new Hibernate Code Generation Configuration that will contain all the details of your reverse engineering process. Click on the New button located in the left corner of the wizard.

Now, select your brand new configuration and carefully choose the following options. First, wire the Console configuration to your project (HibernateProject). Then, choose an output directory for your generated files. We would suggest you to point to your src folder. (Be aware that existing files will be overwritten, that’s why I just said you have to be careful!)

Just below, you will find the checkbox Reverse engineer from JDBC Connection. If enabled, the tools will reverse engineer the available database using the connection information in the selected Hibernate Console configuration. Check this option and enter the package name for the generated classes, which will be com.packtpub.hibernate. Leave the other text fields to the defaults and move to the tab Exporters.

The Exporters tab menu is used to specify which type of code should be generated. Each selection represents an Exporter that is responsible for generating the code, hence the name.

In the upper area of the dialog, you will notice an interesting checkbox named Generate EJB 3 annotations. We will return to this useful option later. At the moment, what we need is just to check the Domain code and Hibernate XML Mappings options, which will generate the Java POJOs and mapping files respectively.

It took a bit of time to complete all of these steps; however, now your Java classes and configuration files are handy and waiting to be packaged.

Adding Hibernate configuration to your project

The advantage of embedding the Hibernate application in JBoss AS is that you can expose Hibernate SessionFactory through a JNDI tree and modify its configuration at runtime.

This is indeed a great configuration advantage; before the new release of JBoss AS, you had to delegate to an MBean the creation of the Hibernate SessionFactory and its exposure through JNDI.

For example, if you wanted to configure a SessionFactory at the naming context hibernate/SessionFactory, you would have to package your Hibernate application with a file named xxx-service.xml in the META-INF folder. Here’s a sample of it:



java:/ MySqlDS

org.hibernate.dialect.MySQLDialect


java:/hibernate/SessionFactory


org.hibernate.cache.HashtableCacheProvider

This configuration is still valid for pre 5.0 releases of JBoss AS. With the introduction of the new Virtual Deployment Framework (VDF), you now have to provide your SessionFactory configuration using the Hibernate XML schema. For example, if you want to link your SessionFactory to your MySQL database, you have to add the following service-hibernate.xml. (Be aware, the suffix is -hibernate.xml and not –service.xml.)



java:/MySqlDS

org.hibernate.dialect.MySQLDialect

jboss:service=Naming
jboss:service=TransactionManager

The preceding configuration file needs to be stored in the META-INF folder of your Hibernate archive (HAR) file. The structure of the updated project from the Package Explorer is as shown in the following snapshot:

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

First demo of Flixel on Android

admin — Wed, 03 Feb 2010 17:55:37 +0000

Demo

The last article showed you how to get a minimal Flixel game running on Android. Here we will add a player controlled character that will run and jump on the screen.

First we need a way to move from the MenuState to a new state called GameState. To do this we override the update function in the MenuState class and watch for a keypress which we will use as a trigger to swap to the GameState.

Most of the Flixel classes have an update function, and it is in this function that an object can update itself, usually by modifying the underlying physics properties like acceleration and velocity and (as is the case here) watching for input.

For those not familiar with Flixel, FlxG is a kind of utility class that contains a number of static functions and properties giving the developer easy access to things like state changes, keyboard input and more.

MenuState.java

package org.myname.flixeldemo;

import org.flixel.*;

import android.view.KeyEvent;

public class MenuState extends FlxState
{
 public MenuState()
 {
  super();
  add(new FlxText(10, 10, 250, "Press the center DPad key to continue."));
 }

 public void update()
 {
  super.update();
  if (FlxG.keys.justPressed(KeyEvent.KEYCODE_DPAD_CENTER))
   FlxG.switchState(GameState.class);
 }
}

Obviously we now need a state called GameState to switch to.

GameState.java

package org.myname.flixeldemo;

import java.util.ArrayList;

import org.flixel.*;

Just like the MenuState, the GameState class extends the FlxState class.

public class GameState extends FlxState
{
 protected ArrayList levelBlocks = new ArrayList();
 protected Player player = null;

 public GameState()
 {

The level is made up of FlxBlock objects, which are blocks that are placed in the level space. These blocks are used in collision detection to give the player a surface to walk on. Here we create a long horizontal block to serve as the ground, load the tech_tiles.png image to display the block, and then add the block to both to the state (all objects that need to be rendered and updated need to be added to the state) and a local collection called levelBlocks.

  FlxBlock ground = new FlxBlock(0, 640-16, 640, 16);
  ground.loadGraphic(R.drawable.tech_tiles);
  levelBlocks.add(this.add(ground));

We then create a new player object, which will be detailed later. We then ask Flixel to keep the player in front of the “camera” using the FlxG follow function. The followAdjust function makes the camera lag behind the movement of the player slightly, while the followBounds function defines the limit of the cameras movement across the level.

  player = new Player();
  this.add(player);
  FlxG.follow(player, 2.5f);
  FlxG.followAdjust(0.5f, 0.0f);
  FlxG.followBounds(0, 0, 640, 640);

Finally we play some background music.

  FlxG.playMusic(R.raw.mode);
 }

In the update function we need to check for a collision between the player and the blocks that make up the level. The collideArrayList function will test the players position against the level blocks (this is why we added the blocks to a local collection), and will push the player out of the blocks if there is a collision.

 public void update()
 {
  super.update();
  FlxG.collideArrayList(levelBlocks, player);
 }
}

The Player class represents the player on the screen.

Player.java

package org.myname.flixeldemo;

import java.util.ArrayList;
import java.util.Arrays;
import android.view.*;

import org.flixel.*;

We extend the FlxSprite class, which will allow us to draw a static or animated sprite on the screen.

public class Player extends FlxSprite
{
 protected static final int PLAYER_START_X = 300;
 protected static final int PLAYER_START_Y = 300;
 protected static final int PLAYER_RUN_SPEED = 80;
 protected static final float GRAVITY_ACCELERATION = 420;
 protected static final float JUMP_ACCELERATION = 200;

 public Player()
 {

We start by calling the underlying FlxSrpite constructor, passing in the initial position of the sprite, the image that will be used to display the sprite, and true to indicate that the sprite should be automatically reversed when it is facing left (by default the source images for all Flixel sprites should be drawn facing right).

  super(PLAYER_START_X, PLAYER_START_Y, R.drawable.spaceman, true);

The physics for the player are defined. The drag, maxVelocity and acceleration defines how the player will move and fall in the level.

  drag.x = PLAYER_RUN_SPEED * 8;
  acceleration.y = GRAVITY_ACCELERATION;
  maxVelocity.x = PLAYER_RUN_SPEED;
  maxVelocity.y = JUMP_ACCELERATION;

The final step is to define the animations and the frames that they will use from the source image that is used to display the sprite. You can see this image here.

As you can see this image is like a film strip. Each of these individual frames of animation are mapped to an animation like “run” or “fall”. The code to initialise a Java collection from an inline array is a little messy, but all we are doing is saying something like “map frames 0, 1, 2 to the animation called run”.

  addAnimation("idle", new ArrayList(Arrays.asList(new Integer[] {0})));
  addAnimation("run",  new ArrayList(Arrays.asList(new Integer[] {1, 2, 3, 0})), 12);
  addAnimation("jump",  new ArrayList(Arrays.asList(new Integer[] {4})));
  addAnimation("idle_up",  new ArrayList(Arrays.asList(new Integer[] {5})));
  addAnimation("run_up",  new ArrayList(Arrays.asList(new Integer[] {6, 7, 8, 5})), 12);
  addAnimation("jump_up",  new ArrayList(Arrays.asList(new Integer[] {9})));
  addAnimation("jump_down",  new ArrayList(Arrays.asList(new Integer[] {10})));
 }

In the update function we use the keyboard input to modify the acceleration and velocity of the player, which will in turn be used to modify the position of the player on the screen.

 public void update()
 {
  acceleration.x = 0;
  if(FlxG.keys.pressed(KeyEvent.KEYCODE_DPAD_LEFT))
  {
   setFacing(LEFT);
   acceleration.x = -drag.x;
  }
  else if(FlxG.keys.pressed(KeyEvent.KEYCODE_DPAD_RIGHT))
  {
   setFacing(RIGHT);
   acceleration.x = drag.x;
  }
  if(FlxG.keys.justPressed(KeyEvent.KEYCODE_DPAD_UP) && velocity.y==0)
  {
   velocity.y = -JUMP_ACCELERATION;
  }

We then use the velocity of the player to determine which animation should be playing.

  if(velocity.y != 0)
  {
   play("jump");
  }
  else if(velocity.x == 0)
  {
   play("idle");
  }
  else
  {
   play("run");
  }

  super.update();
 }
}

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Creating a Flash platform game with Flixel and Flex – Enemies

admin — Wed, 03 Feb 2010 17:52:50 +0000

Demo

To give the player something to do we will add some enemies. These enemies will be quite dumb, simply moving left and right across the top of the blocks we have added. Even though this is not particularly advanced behaviour, it was fairly common with a lot of old 8/16 bit platform games.

First up we define a constant that controls how many enemies will be added to the level in the GameState class.

protected static const ENEMY_COUNT:uint = 10;

Then we add a FlxArray to hold the new enemies.

protected var enemies:FlxArray = new FlxArray();

We then make a call to the new function addEnemies in the constructor (after we have added the blocks to the level).

public function GameState()
{
 // ...

 for (var j:uint = 0; j < NUMBER_RANDOM_BLOCKS; ++j)
  addRandomBlocks();

 addEnemies();

 // ...
}

The addEnemies function will place the enemies on top of the blocks randomly throughout the level. However, we can’t place an enemy on top of any block, because there is a good chance that two blocks have been placed in top of each other, meaning there is no room for our enemy.

protected function addEnemies():void
{
 var enemyCount:uint = 0;

 for each (var block1:FlxBlock in this.levelBlocks)
 {
  var enemyStartX:Number = block1.x;
  var enemyStartY:Number = block1.y;
  var collides:Boolean = false;

  for each (var block2:FlxBlock in this.levelBlocks)
  {
   var xCollision:int = enemyStartX + (BLOCK_DIMENSIONS>>1);
   var xCollision2:int = xCollision + BLOCK_DIMENSIONS;
   var yCollision:int = enemyStartY - (BLOCK_DIMENSIONS>>1);
   var yCollision2:int = yCollision - BLOCK_DIMENSIONS;

   if (block1 !== block2 &&
    (block2.overlapsPoint(xCollision, yCollision) ||
    block2.overlapsPoint(xCollision, yCollision2) ||
    block2.overlapsPoint(xCollision2, yCollision) ||
    block2.overlapsPoint(xCollision2, yCollision2)))
   {
    collides = true;
    break;
   }
  }

To check this we loop through the level blocks twice. This way we can test each block for a collision in the space above it with every other block in the level. We need to find a block where a 2×2 block area (so 16×16 pixels) above the top left corner is free (this is because our enemies take up the space of 4 blocks).

To test this we need to test 4 points in space. The first will be half a block up, and half a block across. This effectively tests the area highlighted in red below.

If you are not familiar with it, the >> operator is called a bit shift. The actual details of this operator are not important; all you need to know is that by calling >>1 on an int you are effectively halving its value. It is more efficient that calling BLOCK_DIMENSIONS/2, and you get to impress all your friends with an obscure operation.

We then test the area of the next block up.

Then we repeat the process one block to the right.

In the example above, the block at the bottom of the image would not be suitable for an enemy placement because there is a collision with the second test. This sets the collision flag to true, which means we do not add an enemy here.

  if (!collides && enemyStartX > 0 && enemyStartY > 0)
  {
   enemies.add(this.add(new Enemy(enemyStartX, enemyStartY, block1.width)));
   ++enemyCount;
  }

  if (enemyCount >= ENEMY_COUNT)
   break;
 }
}

If the space above the block was clear we then create a new Enemy, which is added both to the GameState and to the enemies collection. We increment the enemyCount counter, and then either place the next enemy, or if they have all been placed break out of the loop.

public override function update():void
{
 super.update();
 FlxG.collideArray(levelBlocks, player);
 FlxG.collideArrays(playerBullets, levelBlocks);
 FlxG.collideArrays(enemies, levelBlocks);
 FlxG.overlapArrays(playerBullets,enemies,bulletHitEnemy);
}

The enemies will collide with the level blocks, and with the players bullets. In the update function we test for these collisions. For the bullet / enemy collision, we set the bulletHitEnemy function to be called in the event of a collision.

private function bulletHitEnemy(Bullet:FlxSprite,Bot:FlxSprite):void
{
 Bullet.hurt(0);
 Bot.hurt(1);
}

In the bulletHitEnemy function we call the hurt function on both the bullet and the enemy. This will remove the bullet from the level, and cause the enemy to suffer some damage. If the enemy suffers enough damage it will then be killed.

Next we need to create the Enemy class.

package
{
 import org.flixel.*;

 public class Enemy extends FlxSprite
 {
  [Embed(source="../media/enemy.png")]
  protected var EnemyImage:Class;

  [Embed(source="../media/enemygibs.png")]
  protected var EnemyGibsImage:Class;

  protected static const ENEMY_SPEED:Number = 20;
  protected static const ENEMY_HEALTH:int = 2;

To start with we embed some images, one for the enemy itself, and one for the gibs that will fly when the enemy is killed. We also specify some constants the define the enemy’s health and speed.

  protected var startingX:int;
  protected var maxHorizontalMovement:int;
  protected var gibs:FlxEmitter;

The startingX variable stores the starting position of the enemy. Since all enemies start at the left of a block, and we know how wide a block is, we can use starting with the enemies current position to determine when it should move back to the right to avoid falling off the edge.

The maxHorizontalMovement variable is the width of the underlying block. This, in combination with the startingX variable, stops the enemies moving off the edge of the block.

The gibs variable will hold a FlxEmitter, which is like a particle system, which will be display an explosion of gibs when the enemy is destroyed.

  public function Enemy(X:int, Y:int, maxHorizontalMovement:int)
  {
   super(EnemyImage, X, Y, true);

   this.y -= this.height;
   this.startingX = X;
   this.maxHorizontalMovement = maxHorizontalMovement - this.width;
   this.velocity.x = ENEMY_SPEED;
   this.health = ENEMY_HEALTH;
   this.gibs = FlxG.state.add(new FlxEmitter(0,0,0,0,null,-1.5,-150,150,-200,
      0,-720,720,400,0,EnemyGibsImage,20,true)) as FlxEmitter;

   addAnimation("anim", [0, 1], 12);
   this.play("anim");
  }

All of this code is straight forward. We simply setup the underlying FlxSprite variables along with those we specified ourselves, and then setup the enemy’s animation. We also create a new FlxEmitter, which will display the shower of gibs when the enemy dies.

  public override function update():void
  {
   super.update();

   if (this.x - this.startingX >= maxHorizontalMovement)
   {
    this.x = this.startingX + maxHorizontalMovement;
    this.velocity.x = -ENEMY_SPEED;
   }
   else if (this.x - this.startingX <= 0)
   {
    this.x = this.startingX;
    this.velocity.x = ENEMY_SPEED;
   }
  }

In the update function we change the velocity of the enemy if it has moved over the edge of the underlying block.

  public override function hitWall(Contact:FlxCore=null):Boolean
  {
   this.velocity.x = -this.velocity.x;
   return true;
  }

The hitWall function will be called if the enemy has hit a wall. Since we know the path is clear over the left of the underlying block, this means that the enemy hit a block as it moved right. In this case we simply set the velocity to move the enemy back to the left.

  public override function kill():void
  {
   super.kill();

   this.gibs.x = this.x + (this.width>>1);
   this.gibs.y = this.y + (this.height>>1);
   this.gibs.restart();
  }

 }
}

The kill function is called once the enemy’s health has dropped to 0. Managing the health value is all taken care of by the underlying FlxSprite class. Calling the FlxSprite kill function will remove the enemy from the level. We then position the FlxEmitter referenced by the gibs variable to the enemy’s last position, and call restart to play the effect.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Creating a game on Google Android game with Flixel – Getting Started

admin — Wed, 03 Feb 2010 17:47:07 +0000

The iPhone has taken the world by storm, but with the backing of Google the Android platform is picking up steam and has a bright future ahead of it. But while there are dozens of tools to create games on the iPhone, Android has only a few examples showing how to make a game, and I could not find any decent engines or middleware on which to build a game on Android.

Flixel is a game engine for Flash that I have used quite a bit lately, and after my experiences porting it to Silverlight I felt confident that Flixel would make a great platform for Android on which to make games. This tutorial series will show you how to make your own simple platform game on Android using the ported Flixel engine.

Step 1

Download a copy of Eclipse from here, and then download both the Android SDK and the Eclipse plugins from the Android site here. You can find step by step instructions on how to do this on the Android developer site.

Step 2

Start Eclipse once the Android plugins for Eclipse have been installed. Open Window->Preferences.

In the Android section browse to the location where you extracted the Andorid SDK and click the Apply button. The SDK should then be listed.

Step 3

Create a new Android Application.

If you get the error below make sure you have completed step 2 successfully.

Fill out the first New Android Project screen like below. You can change the names of the application and packages as long as these changes are made to the rest of the classes where appropriate.

There is no need to create a Test Project, so do not tick Create a Test Project.

Step 4

Extract the contents of the Android Flixel SDK into your project folder. This will extract a number of standard mp3s and images, along with the Flixel source files (under the org.flixel and flash packages).

Step 5

Create a new class called MenuState in the org.myname.flixeldemo package. It will extend the FlxState class.

In Flixel the various states in a game (like the main menu, the game itself, a high scrore screen etc) are represented by classes that extend the FlxState class. As the player progressed through the game these FlxState classes are created and destroyed to present the different aspects of the game.

Add the following code to the MenuState class. Here we are going to display a text field just so we have something on the screen.

package org.myname.flixeldemo;

import org.flixel.*;

public class MenuState extends FlxState
{
 public MenuState()
 {
  super();
  add(new FlxText(10, 10, 100, "Hello World!"));
 }
}

Step 6

Create a new class called GameView in the org.myname.flixeldemo package. It will extend the FlxGameView class.

Unlike a Flash game made with Flixel, where graphical objects can be added directly to the screen, Andoid has a fairly complicated system for allowing continuously running applications (like games) to draw to the screen. You have to create a thread to contain the render loop and then pass in events like key presses to the thread while maintaining thread safety. You can view the Lunar Landing demo for an example of how this works. Fortunately the FlxGameView class hides all of the underlying logic required to implement the render loop.

Add the following code to the GameView class. Here we pass a new FlxGame, which is the root of every Flixel game, to the FlxGameView constructor. The FlxGame constructor takes a few parameters like the context (which allows Flixel to create graphics and sound resources), the initial state class information of the game (which will be the MenuState we created above) and the R class information (the R object is created automatically to contain references to the graphics and sound resources).

package org.myname.flixeldemo;

import org.flixel.FlxGame;
import org.flixel.FlxGameView;

import android.content.Context;
import android.util.AttributeSet;

public class GameView extends FlxGameView
{
 public GameView(Context context, AttributeSet attrs)
 {
  super(
   new FlxGame(320, 455, MenuState.class, context, R.class),
   context,
   attrs
  );
 }
}

Step 7

In order to display the GameView object we just created we need to modify the main.xml file under the res/layout folder. Change it so it looks like the image below. This will cause the FlixelDemo Activity, created when the project was created, to display the GameView object.

Step 8

Add the line of code

requestWindowFeature(Window.FEATURE_NO_TITLE);

to the FlixelDemo class like the screen shot below. This will remove the title bar from the application.

Step 9

To test the game we need to setup a Android elmulator. Click Window->Android SDK and AVD Manager.

Click the New button. Add in the details for the AVD (Android Virtual Device) like the screenshot below. Click Create AVD.

You should now have a Virtual Device listed.

Step 10

Now we can run the demo. Click the Run button on the toolbar.

Select Android Application and click OK.

The AVD will start up. This can take some time initially, so be patient.

Congratulations – you have created you first Android game.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Чертане на текст

admin — Sat, 09 Jan 2010 09:14:49 +0000

Тъй като Java аплети са изцяло в графичен характер, трябва да използвате Graphics обект, дори когато искате да съставяте
текст.Трябва да използвате setFont.

void setFont(Font font)

Шрифтовете, могат да бъдат от видовете на italic , bold и други.

Конструктора приема параметъра на име , стил , точка и шрифт.

Font f = new Font("Helvetica", Font.BOLD + Font.ITALIC, 22);

Сега ще създадем текст.

void drawString(String str, int x, int y)

drawString взима обект низ като първи параметър.Последните два параметъра , поставят позиция на чертане на текста; x определя левия край на текста , а y определя изходното ниво на текста.
Сега ще начертаем обикновен applet.

// Drawtext Class
// Drawtext.java
 
// Вмъкване
import java.applet.*;
import java.awt.*;
 
public class Drawtext extends Applet {
  public void paint(Graphics g) {
    Font        font = new Font("Helvetica", Font.BOLD +
      Font.ITALIC, 22);
    FontMetrics fm = g.getFontMetrics(font); 
    String      str = new
      String("Javabg");
 
    g.setFont(font);
    g.drawString(str, (size().width - fm.stringWidth(str)) / 2,
      ((size().height - fm.getHeight()) / 2) + fm.getAscent());
  }
}

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

jDrawing Графика с примитиви

admin — Sat, 09 Jan 2010 09:01:01 +0000

Графика с примитиви се състои от линии, правоъгълници, кръгове, полигони, овал, и дъги. Можете да създадете доста впечатляваща графика с помощта на тези примитиви във връзка един с друг; класът Graphics предвижда методи за съставяне на тези примитиви.

Затворени региони са графични елементи с ясни отличения. За пример, кръгове и правоъгълници са затворени региони, като има предвид, линиите и точките.

Линии

void drawLine(int x1, int y1, int x2, int y2)

Първите два параметъра са, x1 и y1, които са главните точки на линията, x2 и y2 са за крайните точки на линията .
Следващ:

public void paint(Graphics g) {
  g.drawLine(5, 10, 15, 55);
}

Рисуване с drawLine метод.
Правоъгълници

Правоъгълници също са много лесни за рисуване.drawRect метод позволява да се изготвят правоъгълници, като се посочва в горния ляв ъгъл ширината и височината на правоъгълника.

void drawRect(int x, int y, int width, int height)

Параметрите x и y определят височината и ширината на правоъгълника от горния ляв ъгъл. За да начертаете правоъгълник просто извикайте функцията drawRect от paint метода:

public void paint(Graphics g) {
  g.drawRect(5, 10, 15, 55);
}

Other Primitives

Другите фигури също се чертаят, по подобен начин , като с правоъгълника и квадрата . Единствената разлика е, че при кръговете и овалите се ползва радиус за чертане.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Движение на топче 2D

admin — Wed, 06 Jan 2010 09:34:01 +0000

Демо

С този урок, ще започнем с програмирането на игри в 2D сферата.
Ще програмираме applet, в който топката, ще се движи от ляво на дясно.Не е кой знае колко трудно, но за начало с това ще започнем.
В нашия applet трябва да създадем метода за стартиране и метода за свързване с него run() за да анимираме обект.

import java.applet.*; import java.awt.*; public class BallApplet extends Applet implements Runnable { public void init() { } public void start() { } public void stop() { } public void destroy() { } public void run () { } public void paint (Graphics g) { } }

За да местим обект, трябва да създадем, още един обект:Ще използваме Thread .

класовете Thread са:
Thread.start(): стартира thread
Thread.stop(): спира thread
Thread.sleep(време в милисекунди):

Ето го и кода!

public void start () { // дефинира нов thread Thread th = new Thread (this); // стартира го thread th.start (); }

Сега thread е стартиран в run() метода на нашия applet.

public void run () { // бавно ThreadPriority Thread.currentThread().setPriority(Thread.MIN_PRIORITY); // стартира дълъг while (true) това значи "винаги". while (true) { // променя applet repaint(); try { // Спира thread за 20 милисекунди Thread.sleep (20); } catch (InterruptedException ex) { // Неправи нищо } // Задава ThreadPriority с максимална стойност Thread.currentThread().setPriority(Thread.MAX_PRIORITY); } } Нека да нарисуваме кръг. <pre lang="java"> public void paint (Graphics g) { // Задаваме цвят g.setColor (Color.red); // Създаваме кръг g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius); } //Задаваме стойност на променливите int x_pos = 10; //Стартираща позиция int y_pos = 100; //Крайна позиция int radius = 20; //Радиус на кръга

public void run () { ... while (true) { // Променя x позицията на кръга x_pos ++; ... } }

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.