[Cocøa]

Howdy all. I found a general template a few days ago for a Space Invaders game and used the template as a base for my RPG game I'm making for poo's and giggles.

Everything is going peachy thus far except for the direction of the bullets. I've already got it down so the image of the character changes based on LEFT, RIGHT, UP, DOWN; but I can't seem to get the bullets to travel in the direction the character is facing.

If you test the game below the bullets will fire left or right depending on which way you're facing but if you are facing right and fire, the bullets go right, but if you turn left while those bullets are traveling they turn and start going the other way.

It's kind of hard to explain without testing it yourself. (I've added comments for the code I've added for changing bullet direction)

I believe the answer to my problem is in this bit of code adding something to handle each index of the ArrayList for each bullet, but I've been trying different things and what I have now is the best I've gotten.

for (int i = 0; i < ms.size(); i++) {
            Shoot m = (Shoot) ms.get(i);
            if (m.isVisible()) {
				faceNum = mario.facing(); //ADDED FOR BULLET DIRECTION
                m.move(faceNum); //ADDED FOR BULLET DIRECTION
			}
            else ms.remove(i);
        }

Zel.java (Main Class)

package zelm;
import javax.swing.JFrame;
import java.io.*;
import java.util.*;

public class Zel extends JFrame {

	public Zel()throws IOException {
		add(new Board());
		setTitle("Zel");
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setSize(1000, 1000);
		setLocationRelativeTo(null);
		setVisible(true);
		setResizable(false);
	}
	
	public static void main(String[] args)throws IOException {
		new Zel();
		new Character();
	}

}

Board.java

package zelm;
import java.util.*;
import java.io.*;

import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Rectangle;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

import javax.swing.JFrame;
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.ImageIcon;
import javax.swing.Timer;

public class Board extends JPanel implements ActionListener {
	BufferedImage bgImage;
	public Timer timer;
	Character mario;
	public ArrayList badGuys;
	public boolean ingame;
	public int B_WIDTH, B_HEIGHT, faceNum;
	
	public int[][] pos = {
		{2380, 29}, {2500, 59}, {1380, 89},
        {780, 109}, {580, 139}, {680, 239}, 
        {790, 259}, {760, 50}, {790, 150},
        {980, 209}, {560, 45}, {510, 70},
        {930, 159}, {590, 80}, {530, 60},
        {940, 59}, {990, 30}, {920, 200},
        {900, 259}, {660, 50}, {540, 90},
        {810, 220}, {860, 20}, {740, 180},
        {820, 128}, {490, 170}, {700, 30}
	};
	
	public Board()throws IOException  {
		bgImage = ImageIO.read(getClass().getResourceAsStream("res/forestBG.gif"));
		//setBackground(Color.WHITE);
		addKeyListener(new TAdapter());
        setFocusable(true);
        setDoubleBuffered(true);
		ingame = true;
		
		mario = new Character();
		initBadGuys();
		
		timer = new Timer(5, this);
		//timer.setInitialDelay(10);
		timer.start();
	}
	
	public void addNotify() {
		super.addNotify();
		B_WIDTH = getWidth();
		B_HEIGHT = getHeight();
	}
	
	public void initBadGuys()throws IOException {
		badGuys = new ArrayList();
		
		for (int i=0; i<pos.length; i++)
			badGuys.add(new badGuy(pos[i][0], pos[i][1]));
	}
	
	public void paint(Graphics g) {
        //g.drawImage(bgImage, 0, 0, null);
		super.paint(g);
		
		if (ingame) {
			Graphics2D g2d = (Graphics2D)g;
			g.drawImage(bgImage, 0, 0, null);
			//setBackground(Color.BLACK);
			if (mario.isVisible())
				g2d.drawImage(mario.getCharacter(), mario.getX(), mario.getY(), this);
		
			ArrayList ms = mario.getBullets();
		
			for (int i = 0; i < ms.size(); i++ ) {
				Shoot m = (Shoot) ms.get(i);
				g2d.drawImage(m.getBullet(), m.getX(), m.getY(), this);
			}
			for (int i = 0; i < badGuys.size(); i++) {
                badGuy a = (badGuy)badGuys.get(i);
                if (a.isVisible())
                    g2d.drawImage(a.getImage(), a.getX(), a.getY(), this);
            }
			
			g2d.setColor(Color.BLACK);
			g2d.drawString("Bad Guys left: " + badGuys.size(), 5, 15);
		} else {
            String msg = "Game Over";
            Font small = new Font("Helvetica", Font.BOLD, 14);
            FontMetrics metr = this.getFontMetrics(small);

            g.setColor(Color.BLACK); //color.WHITE
            g.setFont(small);
            g.drawString(msg, (B_WIDTH - metr.stringWidth(msg)) / 2,
                         B_HEIGHT / 2);
        }
		
		
		Toolkit.getDefaultToolkit().sync();
        g.dispose();
    }
	
	 public void actionPerformed(ActionEvent e) {
		if (badGuys.size() == 0) {
			ingame = true;    //false for end game
		}
		
		ArrayList ms = mario.getBullets();
		
        /*for (int i = 0; i < ms.size(); i++) {
            Shoot m = (Shoot) ms.get(i);
            if (m.isVisible()) 
                m.move();
            else ms.remove(i);
        }*/
		for (int i = 0; i < ms.size(); i++) {
            Shoot m = (Shoot) ms.get(i);
            if (m.isVisible()) {
				faceNum = mario.facing(); //ADDED FOR BULLET DIRECTION
                m.move(faceNum); //ADDED FOR BULLET DIRECTION
			}
            else ms.remove(i);
        }
		
		
		
		
		for (int i = 0; i < badGuys.size(); i++) {
            badGuy a = (badGuy) badGuys.get(i);
            if (a.isVisible()) 
                a.move();
            else badGuys.remove(i);
        }
		
        mario.move();
		checkCollisions();
        repaint();  
    }
	
	public void checkCollisions() {

        Rectangle r3 = mario.getBounds();

        for (int j = 0; j<badGuys.size(); j++) {
            badGuy a = (badGuy) badGuys.get(j);
            Rectangle r2 = a.getBounds();

            if (r3.intersects(r2)) {
                mario.setVisible(false);
                a.setVisible(false);
                ingame = false;
            }
        }
		
		ArrayList ms = mario.getBullets();

        for (int i = 0; i < ms.size(); i++) {
            Shoot m = (Shoot) ms.get(i);

            Rectangle r1 = m.getBounds();

            for (int j = 0; j<badGuys.size(); j++) {
                badGuy a = (badGuy) badGuys.get(j);
                Rectangle r2 = a.getBounds();

                if (r1.intersects(r2)) {
                    m.setVisible(false);
                    a.setVisible(false);
                }
            }
        }
		
	}
	
	
	 private class TAdapter extends KeyAdapter {

        public void keyReleased(KeyEvent e) {
            mario.keyReleased(e);
        }
		
        public void keyPressed(KeyEvent e) {
		try {
            mario.keyPressed(e);
			}catch (IOException r){}

        }
    }
}

Character.java

package zelm;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;

import java.io.*;
import java.util.*;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class Character {
	public int dx, dy, x, y, width, height, faceNum = 1;
	BufferedImage charImage, charImageLeft, charImageUp, charImageDown;
	public ArrayList bullets;
	//public final int CHAR_SIZE = 20;
	public boolean visible, charFaceLeft = false, charFaceRight = true, 
		charFaceUp = false, charFaceDown = false;
	
	public Character()throws IOException {
		charImage = ImageIO.read(getClass().getResourceAsStream("res/character.gif"));
		charImageLeft = ImageIO.read(getClass().getResourceAsStream("res/characterLeft.gif"));
		charImageUp = ImageIO.read(getClass().getResourceAsStream("res/characterUp.gif"));
		charImageDown = ImageIO.read(getClass().getResourceAsStream("res/characterDown.gif"));
		bullets = new ArrayList();
		visible = true;
		width = charImage.getWidth(null);
		height = charImage.getHeight(null);
		x = 40;
		y = 60;
	}	
	public int facing() {  //ADDED METHOD FOR BULLET DIRECTION
		if (charFaceRight)
			faceNum = 1;
		if (charFaceLeft)
			faceNum = 2;
		return faceNum;
	}
	public void move() {
		x += dx;
		y += dy;
		
		if (x < 1)
			x = 1;
		if (y < 1)
			y =1;
		if (x > 970)
			x = 970;
		if (y > 945)
			y = 945;
	}
	
	public int getX() {
		return x;
	}
	
	public int getY() {
		return y;
	}
	
	public Image getCharacter() {
		if(charFaceRight == true)
			return charImage;
		if(charFaceLeft == true)
			return charImageLeft;
		if(charFaceUp == true)
			return charImageUp;
		if(charFaceDown == true)
			return charImageDown;
		return charImageLeft;
	}
	
	public ArrayList getBullets() {
		return bullets;
	}
	
	public void setVisible(boolean visible) {
		this.visible = visible;
	}
	
	public boolean isVisible() {
		return visible;
	}
	
	public Rectangle getBounds() {
		return new Rectangle(x, y, width, height);
	}
	
	public void keyPressed(KeyEvent e)throws IOException {
		int key = e.getKeyCode();
		
		if (key == KeyEvent.VK_SPACE) {
            fire();
        }
		
		if (key == KeyEvent.VK_LEFT) {
			dx = -1;
			charFaceUp = false;
			charFaceDown = false;
			charFaceRight = false;
			charFaceLeft = true;
		}
		
		if (key == KeyEvent.VK_RIGHT) {
			dx = 1;
			charFaceUp = false;
			charFaceDown = false;
			charFaceLeft = false;
			charFaceRight = true;
		}
		
		if (key == KeyEvent.VK_UP) {
			dy = -1;
			charFaceDown = false;
			charFaceLeft = false;
			charFaceRight = false;
			charFaceUp = true;
		}
		
		if (key == KeyEvent.VK_DOWN) {
			dy = 1;
			charFaceUp = false;
			charFaceLeft = false;
			charFaceRight = false;
			charFaceDown = true;
		}
	}
	
	public void fire()throws IOException {
		if (charFaceRight = true)
			bullets.add(new Shoot(x + width, y + height/2));
    }
	
	public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_UP) {
            dy = 0;
        }

        if (key == KeyEvent.VK_DOWN) {
            dy = 0;
        }
    }
}

Shoot.java

package zelm;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.Rectangle;

import java.io.*;
import java.util.*;

import javax.swing.ImageIcon;
import javax.imageio.ImageIO;

public class Shoot {
	int x, y, width, height, faceNumber;
	BufferedImage bulletImage;
	boolean visible;
	
	final int BOARD_WIDTH = 990;
	final int BOARD_HEIGHT = 990;
	final int BULLET_SPEED = 2;
	
	public Shoot(int x, int y)throws IOException {
		bulletImage = ImageIO.read(getClass().getResourceAsStream("res/bullet.jpg"));
		visible = true;
		width = bulletImage.getWidth(null);
		height = bulletImage.getHeight(null);
		this.x = x;
		this.y = y;
	}
	
	public Image getBullet() {
		return bulletImage;
	}
	
	public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public boolean isVisible() {
        return visible;
    }
	
	public void setVisible(Boolean visible) {
		this.visible = visible;
	}
	
	public Rectangle getBounds() {
		return new Rectangle(x, y, width, height);
	}
	
	public void move(int faceNumber) {
		if(faceNumber == 1) //ADDED FOR BULLET DIRECTION
			x += BULLET_SPEED;
		if(faceNumber == 2) //ADDED FOR BULLET DIRECTION
			x-= BULLET_SPEED;
        if (x > BOARD_WIDTH || x < 1 || y > BOARD_HEIGHT || y < 1)
            visible = false;
    }
}

badGuy.java

package zelm;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;

import java.io.*;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;

public class badGuy {
	public int x, y, width, height;
	public boolean visible;
	BufferedImage bowserImage;
	
	public badGuy(int x, int y)throws IOException {
		bowserImage = ImageIO.read(getClass().getResourceAsStream("res/bowser.gif"));
		width = bowserImage.getWidth(null);
		height = bowserImage.getHeight(null);
		visible = true;
		this.x = x;
		this.y = y;
	}
	
	public void move() {
		if (x < 0)
			x = 1000;
			x -= 1;
	}
	
	public int getX() {
		return x;
	}
	
	public int getY() {
		return y;
	}
	
	public boolean isVisible() {
		return visible;
	}
	
	public void setVisible(Boolean visible) {
		this.visible = visible;
	}
	
	public Image getImage() {
		return bowserImage;
	}
	
	public Rectangle getBounds() {
		return new Rectangle(x, y, width, height);
	}
}

Any help is appreciated!

Attached image(s)

• 
• 
• 
• 
• 
• 
• 

[CasiOo]

I don't understand what you are doing completly
To me it looks like you are changing the direction of the bullets(already fired) when turning your character
You want the bullet to keep the same direction. You could provide the direction in its constructor

Some fast coding I did, not sure if correct

public class Bullet {
	private final int dx = 5;
	private final int dy = 5;
	private int x;
	private int y;
	private Vector normalizedDirection;
	
	//normalizedDirection will decide the direction to move this bullet :3
	public Bullet(int x, int y, Vector normalizedDirection) {
		this.x = x;
		this.y = y;
		this.normalizedDirection = normalizedDirection;
	}
	
	public void move() {
		x += dx * normalizedDirection.getX();
		y += dy * normalizedDirection.getY();
	}
}

[farrell2k]

Kudos to CasiOo. The problem is Shoot.java in the move() your direction check, lines 55 - 58. At one moment it could be moving left, then right, so it switches. Follow CasiOo's advice.

This post has been edited by farrell2k: 18 March 2013 - 03:59 PM

[CasiOo]

I am offended if it's me you're calling a goose

[farrell2k]

CasiOo, on 18 March 2013 - 10:35 PM, said:

I am offended if it's me you're calling a goose

HAHA. I was looking at a topic with him, g00se, and read too quickly! Corrected!

This post has been edited by farrell2k: 18 March 2013 - 03:59 PM

[Cocøa]

Thanks guys! Got it all sorted out.

<3

[pbl]

In Canada shooting and G00se go quite well together

[farrell2k]

This reminds me that I wish I were Canadian. Not because of the hunting, though.

[Cocøa]

Cocøa, on 18 March 2013 - 05:10 PM, said:

Thanks guys! Got it all sorted out.

Just kidding, I didn't.

Should I make a separate class for normalizedDirection and return the value based on the character facing?
Sorry, I know squat about Vectors.

In CasiOo's code snippet:

public void move() {
     x += dx * normalizedDirection.getX();
     y += dy * normalizedDirection.getY();
}

From what I understand here the bullets X and Y direction is moving at a speed of 5 with dx and dy so normalizedDirection would need to be a number that when multiplied with dx makes it move left or right. So normalizedDirection.getX should return 1 or -1, correct?

Meaning if character is facing right, normalizedDirection = 1 so 5 * 1 = 5 so it moves 5 units positive along the X-axis and if the character is facing left, normalizedDirection = -1 so 5 * -1 = -5 so it moves 5 units negative along the X-axis.

Is this the general idea of what should be happening here or am I completely missing it?

[farrell2k]

Consider an example. Your player is facing right. You shoot a bullet and it moves from you, thus it's direction is gong to move to the right. Bullets always move in a straight line. You need to create a way for the bullet to always move right. You would of course just give your bullet a speed and add it to the bullet's x value.

bullet.x += speed; // bullet moves to the right. 

You obviously do the same for the left, and the same with y for up and down. The issue gets more complicated when you move diagonally, because moving diagonally to the left and toward the top (north west), you need to:

bullet.x += -speed;
bullet.y += -speed;

So CasiOo suggested creating a class to hold those speed values. I wouldn't call it Vector, though, as that is already the name of a class. Maybe I would just use a Point. I guess you could create a custom clas named Vector2D, or something, but why bother?

int speed = 5;
Point direction = new Point(-speed, -speed);

Bullet bullet = new Bulley(xLocation, yLocation, direction);

//in the bullet class's move().

public void move() {
   //the bullet moves up and to the left.
   bullet.x += direction.x; //which is bullt.x += -speed, which means move left.
   bullet.y += direction.y; //which is bullet.y += -speed which means move up.
}

That's really the only way to explain it.

[CasiOo]

Cocøa, on 19 March 2013 - 09:34 PM, said:

Cocøa, on 18 March 2013 - 05:10 PM, said:

Thanks guys! Got it all sorted out.

Just kidding, I didn't.

Should I make a separate class for normalizedDirection and return the value based on the character facing?
Sorry, I know squat about Vectors.

In CasiOo's code snippet:

public void move() {
     x += dx * normalizedDirection.getX();
     y += dy * normalizedDirection.getY();
}

From what I understand here the bullets X and Y direction is moving at a speed of 5 with dx and dy so normalizedDirection would need to be a number that when multiplied with dx makes it move left or right. So normalizedDirection.getX should return 1 or -1, correct?

Meaning if character is facing right, normalizedDirection = 1 so 5 * 1 = 5 so it moves 5 units positive along the X-axis and if the character is facing left, normalizedDirection = -1 so 5 * -1 = -5 so it moves 5 units negative along the X-axis.

Is this the general idea of what should be happening here or am I completely missing it?

Yes, I think you have understood what is going on in my code snippet And yes it is a 2D vector
I guess that you can only move up/down/left/right in your game? You can make the code more simple then and not use vectors

//right and down indicates if the bullet is going in that direction
public Bullet(int x, int y, boolean right, boolean down) {
    dx = right ? dx : -dx;
    dy = down ? dy : -dy;
}

public void move() {
    x += dx
    ...
}

This post has been edited by CasiOo: 19 March 2013 - 11:23 PM

[Cocøa]

//right and down indicates if the bullet is going in that direction
public Bullet(int x, int y, boolean right, boolean down) {
    dx = right ? dx : -dx;
    dy = down ? dy : -dy;
}

public void move() {
    x += dx
    ...
}

Thank you! Your code works perfectly except I can't nail this one thing.
In the move() class I have:

x += dx;
y += dy;

With those two lines the bullets fire diagonally. When I comment one of them out it works either left and right or up and down. So I've been trying to find a way to say:

if (moving left or right) {
    move left or right;
    disable moving up and down;
}

if (moving up or down) {
    move up or down;
    disable moving left and right;
}

But I can't seem to find a way to do it without adding more variables and if() statements which I want to avoid if possible. I'm sure there is a simpler way that I am overlooking.

I feel like I need more booleans for left, right, up and down?

The fire() function in my Character class:

    public void fire()throws IOException {
	bullets.add(new Shoot(x + width, y + height/2, charFaceRight, charFaceDown));
    }
	

I tried adding more booleans and if statements to the Shoot function and the move function but I still can't seem to get this straight. ~2 hours haha.

I know the answer is staring me in the face, but I'm stumped right now.

Thanks by the way for showing me the ternary operator; I love it already

[CasiOo]

Oh.. Then I think I might actually go with the kind of solution you came up with in the first place

public enum Directions = {
	left, right, up, down
}

public Bullet(int x, int y, Directions direction) {
	//start with dx and dy being 0
	switch (direciton) {
		case left:
			dx = -SPEED;
			break;
		case right:
			dx = SPEED;
			break;
		case up:
			dy = -SPEED;
			break;
		default: //down
			dy = SPEED;
			break;
	}
}

public void move() {
	x += dx;
	y += dy;
}