A star algorithm for 2D java game

Page 1 of 1

0 Replies - 3765 Views - Last Post: 11 October 2009 - 10:25 AMRate Topic: //<![CDATA[ rating = new ipb.rating( 'topic_rate_', { url: 'https://www.dreamincode.net/forums/index.php?app=forums&module=ajax&section=topics&do=rateTopic&t=131338&amp;s=3a1712c814dbee8ca519b1610e4295ff&md5check=' + ipb.vars['secure_hash'], cur_rating: 0, rated: 0, allow_rate: 0, multi_rate: 1, show_rate_text: true } ); //]]>

#1 General_9

Reputation: 0
• Posts: 1
• Joined: 11-October 09

A star algorithm for 2D java game

Posted 11 October 2009 - 10:25 AM

We are developing a game as a project, can someone assist us with implementing the A star algorithm for our enemies. We have attached our source code.

[code]
import java.util.Vector;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.*;
import java.nio.ByteBuffer;

import GameEngine.Game;
import GameEngine.GameTexture;
import GameEngine.GameFont;
import GameEngine.GameObject;

//==================================================================================================
//==================================================================================================

public class SurvivalGame extends Game
{
// Offset of the screen
private Point2D.Float offset = new Point2D.Float(0,0);
private int trigger = 0;
private boolean alive = true;
private boolean enemyAlive = true;

// A Collection of GameObjects in the world that will be used with the collision detection system
private Vector<GameObject> objects = new Vector<GameObject>();

// Grid GameObjects
private GameObject [] [] gridTile;

// The cooldown of the gun (set this to 0 for a cool effect :> )
private int cooldown = 10;
private int cooldownTimer = 0;

// Important GameObjects
private PlayerObject player; // the player
private HealthObject health; //health pack

//private PlayerObject enemy;
private Vector<PlayerObject> enemy = new Vector<PlayerObject>();
//Textures that will be used
private GameTexture bulletTexture;

//GameFonts that will be used
private GameFont arial, serif;

// The positin of the mouse
private Point2D.Float mousePos = new Point2D.Float (0,0);

// a counter for how far the mousewheel has been moved (just an example)
private int mouseWheelTick = 0;

// Information for the random line at the bottom of the screen
Point2D.Float [] linePositions = {new Point2D.Float(0,0), new Point2D.Float(100,100)};
float [][] lineColours = {{1.0f,1.0f,1.0f,1.0f},{1.0f,0.0f,0.0f,1.0f}};

//==================================================================================================

public SurvivalGame (int GFPS) {
super(GFPS);
}

//==================================================================================================

Midi midiObj = new Midi();
midiObj.run();

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

int gridSize = 12;

//creating the health packs to boost player's health
for (int i = 0; i < 6; i++ ) {

float x = (float) ((Math.random()*(gridSize-4)+2)*grassTexture.getWidth());
float y = (float) ((Math.random()*(gridSize-4)+2)*grassTexture.getHeight());

health = new HealthObject(x, y);
}

// creating the floor objects
gridTile = new GameObject[gridSize][gridSize];
for (int i = 0; i < gridSize; i++ ) {
for (int j = 0; j < gridSize; j++ ) {
gridTile[i][j] = new GameObject(grassTexture.getWidth()*i,grassTexture.getHeight()*j);
}
}

// Creating wall objects
for (int i = 0; i < grassTexture.getWidth()*gridSize; i += rockTexture.getWidth()) {
WallObject go = new WallObject(i, 0);

go = new WallObject(i, grassTexture.getHeight()*(gridSize-1));
}
for (int i = grassTexture.getHeight(); i < grassTexture.getHeight()*(gridSize-1); i += rockTexture.getHeight()) {
WallObject go = new WallObject(0, i);

go = new WallObject(rockTexture.getWidth()*(gridSize-1), i);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// Creating the player's ship
player = new PlayerObject(
(float)(grassTexture.getWidth()*12)/2f,
(float)(grassTexture.getHeight()*2)/2f);

for (int i = 0; i < 72; i++) {
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//Creating enemy ships
for(int t=0; t<3; t++)
{

(float)(grassTexture.getHeight()*(20-(t*6)))/2f));

for (int i = 0; i < 72; i++) {
}

}
}

//==================================================================================================

// this method is used to fire a bullet
public void fireBullet() {

cooldownTimer = cooldown;

float dir = 90+player.getDegreesTo(mousePos);
BulletObject bullet =
new BulletObject(

//bullet.setVelocity(player.getVelocity());
bullet.applyForceInDirection(dir, 6f);

}

//this method is used to fire an enemy bullet
public void enemyFireBullet() {

cooldownTimer = cooldown;
for(int t=0; t<enemy.size(); t++)
{
float dir = 100+enemy.elementAt(t).getDegreesTo(player);//enemy bullets will miss player by 10 degrees
BulletObject bullet =
new BulletObject(

//bullet.setVelocity(player.getVelocity());
bullet.applyForceInDirection(dir, 6f);

}
}

public static boolean isPointInBox(final Point2D.Float point, final Rectangle2D.Float box) {
return box.contains(point.x, point.y);
}

// This is a pretty bad implementation and faster ones exist, it is suggested you find a better one. At least try make use of the Rectangle2D's createIntersection method.
public static boolean boxIntersectBox (final Rectangle2D.Float d, final Rectangle2D.Float d2) {
return isPointInBox(new Point2D.Float (d.x, d.y), d2) ||
isPointInBox(new Point2D.Float (d.x, d.y+d.height), d2) ||
isPointInBox(new Point2D.Float (d.x+d.width, d.y), d2) ||
isPointInBox(new Point2D.Float (d.x+d.width, d.y+d.height), d2) ||
isPointInBox(new Point2D.Float (d2.x, d2.y), d) ||
isPointInBox(new Point2D.Float (d2.x, d2.y+d2.height), d) ||
isPointInBox(new Point2D.Float (d2.x+d2.width, d2.y), d) ||
isPointInBox(new Point2D.Float (d2.x+d2.width, d2.y+d2.height), d);
}

private void handleControls(GameInputInterface gii) {

//----------------------------------

// This isn't so great, there are better and neater ways to do this, you are encouraged to implement a better one
boolean move = false;
float directionToMove = 0;

if(gii.keyDown(KeyEvent.VK_UP)) {
move = true;
if(gii.keyDown(KeyEvent.VK_LEFT) && !gii.keyDown(KeyEvent.VK_RIGHT))
directionToMove = 225;
else if(gii.keyDown(KeyEvent.VK_RIGHT) && !gii.keyDown(KeyEvent.VK_LEFT))
directionToMove = 135;
else
directionToMove = 180;
}
else if(gii.keyDown(KeyEvent.VK_DOWN)) {
move = true;
if(gii.keyDown(KeyEvent.VK_LEFT) && !gii.keyDown(KeyEvent.VK_RIGHT))
directionToMove = -45;
else if(gii.keyDown(KeyEvent.VK_RIGHT) && !gii.keyDown(KeyEvent.VK_LEFT))
directionToMove = 45;
else
directionToMove = 0;
}
else if(gii.keyDown(KeyEvent.VK_LEFT) && !gii.keyDown(KeyEvent.VK_RIGHT)) {
move = true;
directionToMove = 270;
}
else if(gii.keyDown(KeyEvent.VK_RIGHT) && !gii.keyDown(KeyEvent.VK_LEFT)) {
move = true;
directionToMove = 90;
}
if (move)
player.moveInDirection(directionToMove);

if (cooldownTimer <= 0) {
if(gii.keyDown(KeyEvent.VK_SPACE) || gii.mouseButtonDown(MouseEvent.BUTTON1)) {
fireBullet();

}
}
cooldownTimer --;

}

//==================================================================================================

public void logicStep(GameInputInterface gii) {
/*if(gii.keyDown(KeyEvent.VK_W)) {
offset.y -= 3.0;
}
if(gii.keyDown(KeyEvent.VK_S)) {
offset.y += 3.0;
}
if(gii.keyDown(KeyEvent.VK_A)) {
offset.x += 3.0;
}
if(gii.keyDown(KeyEvent.VK_D)) {
offset.x -= 3.0;
}
if(gii.keyDown(KeyEvent.VK_ESCAPE)) {
endGame();
}*/

// some examples of the mouse interface
mouseWheelTick+= gii.mouseWheelRotation();
mousePos.x = (float)gii.mouseXScreenPosition() - offset.x;
mousePos.y = (float)gii.mouseYScreenPosition() - offset.y;

//----------------------------------

if (alive) {
handleControls(gii);
player.setDirection(90+player.getDegreesTo(mousePos));
{
objects.clear();
enemyAlive = false;
}
else
{
for(int t=0; t<enemy.size(); t++)
{
//enemies move in player's direction
enemy.elementAt(t).setDirection(90+enemy.elementAt(t).getDegreesTo(player));

if (trigger%20 == 0)
{
enemy.elementAt(t).moveInDirection(90+enemy.elementAt(t).getDegreesTo(player));
}
if (trigger%500 == 0)//controls how often enemies fire bullets
{
enemyFireBullet();
}
trigger++;//variable used to control how often bullets are fired
}
}
}
// NOTE: you must call doTimeStep for ALL game objects once per frame!
// updateing step for each object
for (int i = 0; i < objects.size(); i++) {
objects.elementAt(i).doTimeStep();
}

// setting the camera offset
offset.x = -player.getPosition().x + (this.getViewportDimension().width/2);
offset.y = -player.getPosition().y + (this.getViewportDimension().height/2);

//checking each unit against each other unit for collisions
for (int i = 0; i < objects.size(); i++) {
for (int j = i+1; j < objects.size(); j++) {
GameObject o1 = objects.elementAt(i);
GameObject o2 = objects.elementAt(j);
if (boxIntersectBox(o1.getAABoundingBox(), o2.getAABoundingBox())) {

if (fine_tune_collision(o1, o2))//checks if the pixels are both non-transparent
{
if (o1 instanceof WallObject && o2 instanceof WallObject) {
//do nothing
}
else if ((o1 instanceof BulletObject && o2 instanceof WallObject) || o1 instanceof WallObject && o2 instanceof BulletObject) {
// just destroy the bullet, not the wall
if (o1 instanceof BulletObject)
o1.setMarkedForDestruction(true);
else
o2.setMarkedForDestruction(true);

}
else if ((o1 instanceof PlayerObject && o2 instanceof WallObject) || o1 instanceof WallObject && o2 instanceof PlayerObject) {
if(o1 == player || o2 == player)
{
player.revertPosition();
}
else if(o1 instanceof PlayerObject)
{
for(int t=0; t<enemy.size(); t++)
{
if(o1 == enemy.elementAt(t))
{
enemy.elementAt(t).revertPosition();
}
}
}
else
{
for(int t=0; t<enemy.size(); t++)
{
if (o2 == enemy.elementAt(t))
{
enemy.elementAt(t).revertPosition();
}
}
}
}
else if (o1 instanceof PlayerObject && o2 instanceof PlayerObject){
if (o1 == player)
{//kill player
o1.setMarkedForDestruction(true);
player.setHealth(0);
}
else
{//kill player
o2.setMarkedForDestruction(true);
player.setHealth(0);
}
}
else if ((o1 instanceof PlayerObject && o2 instanceof HealthObject) || o1 instanceof HealthObject && o2 instanceof PlayerObject)
{
if(o1 == player)
{
if (player.getHealth() == 100)
{//dont change health but health pack used up
o2.setMarkedForDestruction(true);
}
else
{//increase player's health and health pack used up
player.increaseHealth();
o2.setMarkedForDestruction(true);
}
}
else if(o2 == player)
{
if (player.getHealth() == 100)
{
o1.setMarkedForDestruction(true);
}
else
{
player.increaseHealth();
o1.setMarkedForDestruction(true);
}
}
}
else if ((o1 instanceof BulletObject && o2 instanceof HealthObject || o1 instanceof HealthObject && o2 instanceof BulletObject))
{
//Do nothing
}
else {//bullets shoot player or enemies
if(o1 == player)
{
if(player.getHealth() == 25)
{
player.setMarkedForDestruction(true);
o2.setMarkedForDestruction(true);
player.setHealth(0);
}
else
{
player.reduceHealth();
o2.setMarkedForDestruction(true);
}
}
else if(o2 == player)
{
if(player.getHealth() == 25)
{
player.setMarkedForDestruction(true);
o1.setMarkedForDestruction(true);
player.setHealth(0);
}
else
{
player.reduceHealth();
o1.setMarkedForDestruction(true);
}

}
else
{
o1.setMarkedForDestruction(true);
o2.setMarkedForDestruction(true);
}
}
}
}

}

// destroying units that need to be destroyed
for (int t = 0; t < objects.size(); t++) {
if (objects.elementAt(t).isMarkedForDestruction()) {
if (objects.elementAt(t) == player) {
alive = false;
}
else if (objects.elementAt(t) instanceof PlayerObject)
{
for(int j=0; j<enemy.size(); j++)
{
if(objects.elementAt(t) == enemy.elementAt(j))
enemy.remove(j);
}
}
// removing object from list of GameObjects
objects.remove(t);
t--;
}
}

}
}
//==================================================================================================

public void renderStep(GameDrawer drawer) {
//For every object that you want to be rendered, you must call the draw function with it as a parameter

// NOTE: Always draw transparent objects last!

// Offsetting the world so that all objects are drawn
drawer.setWorldOffset(offset.x, offset.y);
drawer.setColour(1.0f, 1.0f, 1.0f, 1.0f);

// drawing the ground tiles
for (int i = 0; i < gridTile.length; i++ ) {
for (int j = 0; j < gridTile[i].length; j++ ) {
drawer.draw(gridTile[i][j], 1.0f, 1.0f, 1.0f, 1.0f, 0);
}
}

// drawing all the objects in the game
for (GameObject o: objects) {
drawer.draw(o, 1.0f, 1.0f, 1.0f, 1.0f, 0);
}

// this is just a random line drawn in the corner of the screen
//drawer.draw(GameDrawer.LINES, linePositions, lineColours, 0.5f);
/*
if (player != null) {
Point2D.Float [] playerLines = {mousePos, player.getPosition()};
drawer.draw(GameDrawer.LINES, playerLines, lineColours, 0.5f);
}*/

drawer.setColour(1.0f,1.0f,1.0f,1.0f);

// Changing the offset to 0 so that drawn objects won't move with the camera
drawer.setWorldOffset(0, 0);
&nbs

Is This A Good Question/Topic? 0

Page 1 of 1

 .related ul { list-style-type: circle; font-size: 12px; font-weight: bold; } .related li { margin-bottom: 5px; background-position: left 7px !important; margin-left: -35px; } .related h2 { font-size: 18px; font-weight: bold; } .related a { color: blue; }