Liste führt sich nicht weiter

Lukases2 · 12. Feb 2015

Hallo,

ich habe ein Spiel geschrieben, welches Level über eine txt-Datei einlesen kann. Genau erklärt habe ich das in diesem Beitrag: http://www.java-forum.org/allgemeine-java-themen/165621-level-einlesen.html

Wenn ich jetzt aber zeichne, dann entsteht das selbe Monster in der Liste an verschiedenen Stellen, was dazu führt, dass wenn ich eines "töte", alle anderen auch verschwinden. Die Liste an Monstern besteht also immer nur aus einem einzigen Monster. Ich vermute, dass das Problem in der Klasse Frame hier liegt:

Java:

if(l.getTempArray(x, y) == 5){
  g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
  monsterGrün.add(new MonsterGrün());
  monsterGrün.get(0).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
  g.drawImage(monsterGrün.get(0).getLook1(), x*skalierung, y*skalierung, null);
  monsterGrün.get(1).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
  g.drawImage(monsterGrün.get(1).getLook1(), x*skalierung, y*skalierung, null);
}

Eigentlich habe ich eine Schleife für die Erstellung der Monster vorgesehen, aber es klappt ja nicht mal so ...
Bevor sich einer die Klassen alle anschaut, bitte zuerst hier nach einem Denkfehler schauen.

Alle sonstigen relevanten Klassen sind diese hier:

Frame: Hier wird gezeichnet

Java:

package mainGame;

import java.awt.Font;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.IOException;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Frame extends JFrame {
	
	private JButton button;
	private Screen screen;
	
	final Player player;	
	final Boden boden;
	final Tuer tuer;
	final Wand wand;
	final Schluessel schluessel;
	private List<Bullet> bullets;
	private static List<MonsterGrün> monsterGrün;
	private static List<MonsterRot> monsterRot;
	
	
	private boolean key_up = false;
	private boolean key_down = false;
	private boolean key_left = false;
	private boolean key_right = false;
	private boolean key_space = false;
	private boolean key_r = false;
	
	public Frame(Player player, Boden boden, Wand wand, Tuer tuer, List<Bullet> bullets, Schluessel schluessel, List<MonsterGrün> monsterGrün, List<MonsterRot> monsterRot){
		super("Canberra");
		setLayout(null);
		screen = new Screen();
		screen.setBounds(0, 0, 800, 600);
		//--------- add(button) funzt nicht ... ----------------//
		button = new JButton();
		button.setBounds(495, 10, 70, 30);
		button.setFont(new Font("Serif", Font.BOLD, 20));
		button.setText("Karte aufdecken");
		//------------------------------------------------------//
		add(screen);
		addKeyListener(new KeyHandler());
		this.player = player;
		this.boden = boden;
		this.wand = wand;
		this.tuer = tuer;
		this.schluessel = schluessel;
		this.bullets = bullets;
		this.monsterGrün = monsterGrün;
		this.monsterRot = monsterRot;
	}
	
	
	public boolean getUp(){
		return key_up;
	}
	public boolean getDown(){
		return key_down;
	}
	public boolean getLeft(){
		return key_left;
	}
	public boolean getRight(){
		return key_right;
	}
	public boolean getSpace(){
		return key_space;
	}
	public boolean getRespawn(){
		return key_r;
	}
	
	
	
	public void repaintScreen(){
		screen.repaint();
	}
	
	private class Screen extends JLabel{
		protected void paintComponent(Graphics g){
			//------Einstellungen Kollisionserkennung ------//
			int skalierung = 32;
			int boundingSizeObjects = 15;
			int zentralität = 7;
			//------Ende------------------------------------//
			super.paintComponent(g);
			try {
				for(int x = 0; x < 15; x++){
					for(int y = 0; y < 15; y++){
						
						LevelReader l = new LevelReader();
						if(l.getTempArray(x, y) == 1){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
						}
						
						if(l.getTempArray(x, y) == 5){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							monsterGrün.add(new MonsterGrün());
								monsterGrün.get(0).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
								g.drawImage(monsterGrün.get(0).getLook1(), x*skalierung, y*skalierung, null);
								monsterGrün.get(1).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
								g.drawImage(monsterGrün.get(1).getLook1(), x*skalierung, y*skalierung, null);
						}
						
						if(l.getTempArray(x, y) == 6){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
						}
						//---------------------Wand------------------------//
						if(l.getTempArray(x, y) == 0){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							g.drawImage(wand.getLook(), x*skalierung, y*skalierung, null);
							wand.setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
							if(wand.getBounding().intersects(player.getBounding())){
								player.updateNeq(key_up, key_down, key_left, key_right, false, false);
							}
							//g.fillRect(x*skalierung+zentralität, y*skalierung+zentralität, boundingSizeObjects, boundingSizeObjects);
						}
						//---------------------Tür------------------------//
						if(l.getTempArray(x, y) == 3){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							g.drawImage(tuer.getLook(), x*skalierung, y*skalierung, null);
							tuer.setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
							if(player.getHasKey() == true && player.getBounding().intersects(tuer.getBounding())){
								player.setLevelGeschafft(true);
							}else{
								player.setLevelGeschafft(false);
							}
						}
						//---------------------Schlüssel------------------------//
						if(l.getTempArray(x, y) == 2){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							if(player.getHasKey() == false){
								g.drawImage(schluessel.getLook(), x*skalierung, y*skalierung, null);
								schluessel.setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
							}
							if(player.getBounding().intersects(schluessel.getBounding())){
								player.setHasKey(true);
								g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
								schluessel.setBounding(new Rectangle(0, 0, 0, 0));
							}
						}
						//--------------------- Player ------------------------//
						if(l.getTempArray(x, y) == 4){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
						}
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			g.drawImage(player.getLook(), player.getBounding().x, player.getBounding().y, null);
			
			
			if(player.getLevelGeschafft()){
				System.out.println("Du hast es geschafft!");
				player.updateLevelGeschafft(key_up, key_down, key_left, key_right, false, false);
			}
			System.out.println(monsterGrün.get(0).getBounding());
			g.fillRect(198, 224, 15, 15);
			//System.out.println(player.getLeben()+"\t"+monsterGrün.get(0).getLeben()+"\t"+monsterGrün.get(1).getLeben());
			//System.out.println(monsterGrün.get(0).getBounding()+"\t"+monsterGrün.get(1).getBounding()+"\t"+monsterGrün.get(2).getBounding()+"\t");
		}
	}
	
	
	private class KeyHandler implements KeyListener{

		@Override
		public void keyPressed(KeyEvent e) {
			if(e.getKeyCode() == KeyEvent.VK_S)key_down = true;
			if(e.getKeyCode() == KeyEvent.VK_W)key_up = true;
			if(e.getKeyCode() == KeyEvent.VK_D)key_right = true;
			if(e.getKeyCode() == KeyEvent.VK_A)key_left = true;
			if(e.getKeyCode() == KeyEvent.VK_R)key_r = true;
			
			
		}

		@Override
		public void keyReleased(KeyEvent e) {
			if(e.getKeyCode() == KeyEvent.VK_S)key_down = false;
			if(e.getKeyCode() == KeyEvent.VK_W)key_up = false;
			if(e.getKeyCode() == KeyEvent.VK_D)key_right = false;
			if(e.getKeyCode() == KeyEvent.VK_A)key_left = false;
			if(e.getKeyCode() == KeyEvent.VK_R)key_r = false;
		}

		
		
		
		
		
		//Unnötig
		@Override
		public void keyTyped(KeyEvent arg0) {}
		
	}
}

SpielMain: Hier entsteht die Liste für die Monster

Java:

package mainGame;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


public class SpielMain {
	
	static List<MonsterGrün> monsterGrün = new LinkedList<MonsterGrün>();
	static List<MonsterRot> monsterRot = new LinkedList<MonsterRot>();
	
	public static void createEnemyGreen(){
		monsterGrün.add(new MonsterGrün());
	}
	
	public static void createEnemyRed(){
		monsterRot.add(new MonsterRot());
	}
	
		
	public static void main(String[] args) throws IOException {
		
		List<Bullet> bullets = new LinkedList<Bullet>();
		Player player = new Player(200, 200, 20, bullets);   //3. Wert: Größe der Bounding-box des Players
		Boden boden = new Boden(0, 0);
		Wand wand = new Wand(0, 0);
		Schluessel schluessel = new Schluessel(0, 0);
		Tuer tuer = new Tuer(0, 0);
		
		Frame f = new Frame(player, boden, wand, tuer, bullets, schluessel, monsterGrün, monsterRot);
		f.setDefaultCloseOperation(Frame.EXIT_ON_CLOSE);
		f.setSize(485, 500);
		f.setVisible(true);
		f.setResizable(false);
		f.setLocationRelativeTo(null);
		
		
		while(true){
			player.update(f.getUp(), f.getDown(), f.getLeft(), f.getRight(), f.getSpace(), f.getRespawn());
			boden.update(f.getUp(), f.getDown(), f.getLeft(), f.getRight());
			
			f.repaintScreen();
			
			for(int i = 0; i < bullets.size(); i++){
				bullets.get(i).update();
			}
			
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
}

LevelReader: Liest die Level ein

Java:

package mainGame;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LevelReader {
	
	String level;
	
	private int[][] tempArray = new int[79][59];	

	public LevelReader() throws IOException{
		
		FileReader f = new FileReader("C:/Users/Lukas/Workspace2/MyProject/src/txt/level5.txt");
		BufferedReader b = new BufferedReader(f);
		
		ArrayList<String> data = new ArrayList<>();
		while(b.ready()){
			String level = b.readLine();
			data.add(level);
		}
		f.close();
		
		for(int i = 0; i < data.size(); i++){
			char[] line = data.get(i).toCharArray();
				for(int k = 0; k < line.length; k++){
					int digit = Integer.parseInt(line[k] + "");
					tempArray[i][k] = digit;
				}
		}
		
		for(int j = 0; j < tempArray.length; j++){
			//System.out.println("Zeile " + (j + 1));
				for(int l = 0; l < tempArray[j].length; l++){
					//System.out.print(tempArray[j][l]);
				}
		}
	}
	
	public int getTempArray(int i, int j){
		return tempArray[i][j];
	}
	
	public void setLevel(String level){
		this.level = level;
	}
}

MonsterGrün: Hier entsteht das Objekt

Java:

package mainGame;

import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.IOException;

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

public class MonsterGrün {
	
	private boolean alive = true;
	private int leben = 30;
	private Rectangle bounding;
	private BufferedImage look;
	private BufferedImage look_dead;
	
	public MonsterGrün(){
		try {
			look = ImageIO.read(getClass().getClassLoader().getResourceAsStream("gfx/drache1.png"));
			look_dead = ImageIO.read(getClass().getClassLoader().getResourceAsStream("gfx/boden.png"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public BufferedImage getLook1(){
		return look;
	}
	
	public BufferedImage getLookDead(){
		return look_dead;
	}
	
	public Rectangle getBounding(){
		return bounding;
	}
	
	public void setBounding(Rectangle bounding){
		this.bounding = bounding;
	}
	
	public boolean getAlive(){
		return alive;
	}
	
	public void setAlive(boolean alive){
		this.alive = false;
	}
	
	public int getLeben(){
		return leben;
	}
	
	public void setLeben(int leben){
		this.leben = leben;
	}
}

Joose · 12. Feb 2015

Lukases2 hat gesagt.:
Wenn ich jetzt aber zeichne, dann entsteht das selbe Monster in der Liste an verschiedenen Stellen, was dazu führt, dass wenn ich eines "töte", alle anderen auch verschwinden. Die Liste an Monstern besteht also immer nur aus einem einzigen Monster. Ich vermute, dass das Problem in der Klasse Frame hier liegt:

Zeige doch bitte die Stellen wo ein Monster zur Liste hinzugefügt wird und wo ein Monster entfernt wird.
Das sind die relevanten Stellen! Du fügst wahrscheinlich immer das gleiche Objekt zur Liste hinzu.

Anmerkung zu deinem Code:
Du verwendest dort wo man es nicht machen sollte und dort wo es sinnvoll sein könnte verwendest du es nicht.
Beispiel: In der Klasse "MonsterGrün" (umlaute sind eine schlechte Wahl!) liest du für jedes Monster Objekt das Bild neu ein. Stattdessen könntest du es auch einfach 1x einlesen (spart Zeit und Speicher). Die Liste von Monstern (egal ob rot oder grün) sollte nicht statisch sein. Dadurch kommst du zu leicht in Versuchung irgendwo mal hier oder ein Monster hinzuzufügen/löschen oder damit was anderes anzustellen.

Ansonsten bin ich noch verwundert das die ein JLabel verwendest um deine Sachen zu zeichnen! Überlicherweise wird dazu ein JPanel verwendet.

Lukases2 · 12. Feb 2015

Ich habe nochmal was geändert, 'Frame' sieht jetzt so aus:

Java:

package mainGame;

import java.awt.Font;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.IOException;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Frame extends JFrame {
	
	private JButton button;
	private Screen screen;
	
	final Player player;	
	final Boden boden;
	final Tuer tuer;
	final Wand wand;
	final Schluessel schluessel;
	private List<Bullet> bullets;
	private static List<MonsterGrün> monsterGrün;
	private static List<MonsterRot> monsterRot;
	
	
	private boolean key_up = false;
	private boolean key_down = false;
	private boolean key_left = false;
	private boolean key_right = false;
	private boolean key_space = false;
	private boolean key_r = false;
	
	public Frame(Player player, Boden boden, Wand wand, Tuer tuer, List<Bullet> bullets, Schluessel schluessel, List<MonsterGrün> monsterGrün, List<MonsterRot> monsterRot){
		super("Canberra");
		setLayout(null);
		screen = new Screen();
		screen.setBounds(0, 0, 800, 600);
		//--------- add(button) funzt nicht ... ----------------//
		button = new JButton();
		button.setBounds(495, 10, 70, 30);
		button.setFont(new Font("Serif", Font.BOLD, 20));
		button.setText("Karte aufdecken");
		//------------------------------------------------------//
		add(screen);
		addKeyListener(new KeyHandler());
		this.player = player;
		this.boden = boden;
		this.wand = wand;
		this.tuer = tuer;
		this.schluessel = schluessel;
		this.bullets = bullets;
		this.monsterGrün = monsterGrün;
		this.monsterRot = monsterRot;
	}
	
	
	public boolean getUp(){
		return key_up;
	}
	public boolean getDown(){
		return key_down;
	}
	public boolean getLeft(){
		return key_left;
	}
	public boolean getRight(){
		return key_right;
	}
	public boolean getSpace(){
		return key_space;
	}
	public boolean getRespawn(){
		return key_r;
	}
	
	
	
	public void repaintScreen(){
		screen.repaint();
	}
	
	private class Screen extends JLabel{
		protected void paintComponent(Graphics g){
			//------Einstellungen Kollisionserkennung ------//
			int skalierung = 32;
			int boundingSizeObjects = 15;
			int zentralität = 7;
			//------Ende------------------------------------//
			super.paintComponent(g);
			try {
				for(int x = 0; x < 15; x++){
					for(int y = 0; y < 15; y++){
						
						LevelReader l = new LevelReader();
						if(l.getTempArray(x, y) == 1){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
						}
						
						if(l.getTempArray(x, y) == 5){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							monsterGrün.add(new MonsterGrün());
								monsterGrün.get(0).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
								g.drawImage(monsterGrün.get(0).getLook1(), x*skalierung, y*skalierung, null);
						}
						
						if(l.getTempArray(x, y) == 6){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							if(player.getHasKey()){
							monsterRot.add(new MonsterRot());
								monsterRot.get(0).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
								g.drawImage(monsterRot.get(0).getLook(), x*skalierung, y*skalierung, null);
							}
						}
						//---------------------Wand------------------------//
						if(l.getTempArray(x, y) == 0){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							g.drawImage(wand.getLook(), x*skalierung, y*skalierung, null);
							wand.setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
							if(wand.getBounding().intersects(player.getBounding())){
								player.updateNeq(key_up, key_down, key_left, key_right, false, false);
							}
							//g.fillRect(x*skalierung+zentralität, y*skalierung+zentralität, boundingSizeObjects, boundingSizeObjects);
						}
						//---------------------Tür------------------------//
						if(l.getTempArray(x, y) == 3){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							g.drawImage(tuer.getLook(), x*skalierung, y*skalierung, null);
							tuer.setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
							if(player.getHasKey() == true && player.getBounding().intersects(tuer.getBounding())){
								player.setLevelGeschafft(true);
							}else{
								player.setLevelGeschafft(false);
							}
						}
						//---------------------Schlüssel------------------------//
						if(l.getTempArray(x, y) == 2){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
							if(player.getHasKey() == false){
								g.drawImage(schluessel.getLook(), x*skalierung, y*skalierung, null);
								schluessel.setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));
							}
							if(player.getBounding().intersects(schluessel.getBounding())){
								player.setHasKey(true);
								g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
								schluessel.setBounding(new Rectangle(0, 0, 0, 0));
							}
						}
						//--------------------- Player ------------------------//
						if(l.getTempArray(x, y) == 4){
							g.drawImage(boden.getLook(), x*skalierung, y*skalierung, null);
						}
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			g.drawImage(player.getLook(), player.getBounding().x, player.getBounding().y, null);
			
			
			if(player.getLevelGeschafft()){
				System.out.println("Du hast es geschafft!");
				player.updateLevelGeschafft(key_up, key_down, key_left, key_right, false, false);
			}
			//System.out.println(player.getLeben()+"\t"+monsterGrün.get(0).getLeben()+"\t"+monsterGrün.get(1).getLeben());
			//System.out.println(monsterGrün.get(0).getBounding()+"\t"+monsterGrün.get(1).getBounding()+"\t"+monsterGrün.get(2).getBounding()+"\t");
		}
	}
	
	
	private class KeyHandler implements KeyListener{

		@Override
		public void keyPressed(KeyEvent e) {
			if(e.getKeyCode() == KeyEvent.VK_S)key_down = true;
			if(e.getKeyCode() == KeyEvent.VK_W)key_up = true;
			if(e.getKeyCode() == KeyEvent.VK_D)key_right = true;
			if(e.getKeyCode() == KeyEvent.VK_A)key_left = true;
			if(e.getKeyCode() == KeyEvent.VK_R)key_r = true;
			
			
		}

		@Override
		public void keyReleased(KeyEvent e) {
			if(e.getKeyCode() == KeyEvent.VK_S)key_down = false;
			if(e.getKeyCode() == KeyEvent.VK_W)key_up = false;
			if(e.getKeyCode() == KeyEvent.VK_D)key_right = false;
			if(e.getKeyCode() == KeyEvent.VK_A)key_left = false;
			if(e.getKeyCode() == KeyEvent.VK_R)key_r = false;
		}

		
		
		
		
		
		//Unnötig
		@Override
		public void keyTyped(KeyEvent arg0) {}
		
	}
}

In Zeile 105 füge ich nun das Monster ein. Es funktioniert aber immer noch nicht.

Du fügst wahrscheinlich immer das gleiche Objekt zur Liste hinzu.

Davon gehe ich auch aus. Aber ich verstehe nicht warum.

Generell weiß ich, das mein Code nicht wirklich der Effizienteste ist. Um ihn besser zu gestalten, fehlt mir noch die Erfahrung. Erstmal ist mir wichtig, das er funktioniert. Für Verbesserungen bin ich natürlich offen, nur das Umsetzen fällt mir nich schwer.

Bananabert · 12. Feb 2015

Wie Joose schon sagte, der Code in dem ein Monster entfernt wird ist noch Interessant. Oder wo du die Position des Monsters setzt, sowie der Kampf zwischen Spieler und Monster.

Lukases2 · 12. Feb 2015

der Code in dem ein Monster entfernt wird

Den suche ich auch vergeblich :bahnhof: Alles was ich probiere funktioniert nicht. Hast du eine Idee?

wo du die Position des Monsters setzt

Eine Level-datei sieht z.B. so aus:

Java:

0000000000000000
0000000000000000
0000000400000000
0001111111160000
0001115111110000
0001161121510000
0001111511110000
0001110001110000
0000011311000000
0000011111000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000

Die Werte stehen für Objekte, z.B. die 5 für das grüne Monster. Sie wird om LevelReader eingelesen. So ergibt sich die Position des Monsters, sie ist da, wo die Zahl 5 in der Datei steht. Zum LevelReader hatte ich hier schon mal ein Thema, indem ich erklärt habe wie er funktioniert, oben findest du den Link

Kampf zwischen Spieler und Monster

Den gibt auch noch nicht. Ich hatte schonmal was, was funktioniert hat, aber das lasse ich der Einfachhalt halber erstmal weg, bis ich dieses Problem gelöst habe.

Bananabert · 12. Feb 2015

Und wie "tötest" du dann ein Monster ?

Ich denke mal es liegt an Zeile 105 in der Frame Klasse :

Java:

monsterGrün.add(new MonsterGrün());

monsterGrün.get(0).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));

g.drawImage(monsterGrün.get(0).getLook1(), x*skalierung, y*skalierung, null);

monsterGrün.get(1).setBounding(new Rectangle(x*skalierung, y*skalierung, boundingSizeObjects, boundingSizeObjects));

g.drawImage(monsterGrün.get(1).getLook1(), x*skalierung, y*skalierung, null);

Jedes mal wenn du zeichnest, fügst du deiner Liste neue Monster hinzu.

Warum zeichnest du eigentlich das Monster 2x an der gleichen Stelle ?

Liste führt sich nicht weiter

Lukases2

Aktives Mitglied

Joose

Top Contributor

Lukases2

Aktives Mitglied

Bananabert

Bekanntes Mitglied

Lukases2

Aktives Mitglied

Bananabert

Bekanntes Mitglied

Aktuelle Jobs

Neue Themen

Ähnliche Themen