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 ?

	Titel	Forum	Antworten	Datum
	Liste sortieren ohne Array und ohne vorgegebene Sortierung	Allgemeine Java-Themen	24	22. Apr 2024
	Filtern von TableView Liste	Allgemeine Java-Themen	2	10. Apr 2024
B	Liste aller Kombintionen mit Einschränkungen	Allgemeine Java-Themen	8	22. Jan 2023
	Wie kann man Leerzeichen aus einer Array liste entfernen?	Allgemeine Java-Themen	10	18. Aug 2022
B	Liste ändern während Iteration über Diese?	Allgemeine Java-Themen	16	3. Jun 2022
D	Erste Schritte Liste erweitern	Allgemeine Java-Themen	11	5. Mai 2022
	Variablen Liste erstellt und ein Problem mit dem Index	Allgemeine Java-Themen	6	29. Jan 2022
L	allgemein Strings händisch in Liste sortieren	Allgemeine Java-Themen	47	20. Dez 2021
M	einfach verkettete Liste verstehen	Allgemeine Java-Themen	23	1. Nov 2021
	wie kann ich alle instanzen einer Klasse durchsehen, ohne, dass diese in einer Liste erzeugt wurden?	Allgemeine Java-Themen	11	23. Dez 2020
	Skip Liste erstellen in Java	Allgemeine Java-Themen	3	6. Dez 2020
G	Java Editor Löschen doppelter Zahlen einer Liste	Allgemeine Java-Themen	2	8. Nov 2020
	Spring Boot Entity mit Liste	Allgemeine Java-Themen	4	3. Nov 2020
	Werte in liste speichern?	Allgemeine Java-Themen	3	10. Jun 2020
	Collections Liste anhand mehrere Kriterien sortieren	Allgemeine Java-Themen	6	30. Mrz 2020
K	verkettete Liste	Allgemeine Java-Themen	3	4. Feb 2020
G	Liste (UsageStats) sortieren (Android)	Allgemeine Java-Themen	5	7. Dez 2019
T	Google Links in einer Liste	Allgemeine Java-Themen	4	19. Okt 2019
	Liste filtern nach Prädikaten verschiedener Typen	Allgemeine Java-Themen	3	3. Okt 2019
	Einfach verkettete Liste ändern	Allgemeine Java-Themen	43	26. Sep 2019
L	Liste überschreibt alte Elemte	Allgemeine Java-Themen	10	25. Jun 2019
H	Länge einer verketteten Liste	Allgemeine Java-Themen	4	18. Jun 2019
E	Erstellen einer Liste mit einer maximalen Menge an Elementen	Allgemeine Java-Themen	13	19. Feb 2019
P	Element einer Liste wurde hinzugefügt, aber es gibt keinen Zugriff	Allgemeine Java-Themen	2	28. Okt 2018
S	Methoden Liste soll Methode aus innerer Klasse aufrufen	Allgemeine Java-Themen	4	16. Mrz 2018
L	Erste Schritte Liste von Datums filter nach Monate	Allgemeine Java-Themen	4	12. Sep 2017
Y	Liste in Stream Packen	Allgemeine Java-Themen	1	1. Aug 2017
K	Einfache Verkettete Liste mit Node	Allgemeine Java-Themen	3	9. Jul 2017
	Reflection : Element in generische Liste hinzufügen	Allgemeine Java-Themen	4	5. Jul 2017
	Liste mit generics zurück liefern	Allgemeine Java-Themen	8	27. Feb 2017
S	Verkettete (Teil)Liste sortieren ( rekursiv bis n)	Allgemeine Java-Themen	2	27. Jan 2017
G	Liste zwischen zwei Kalenderdaten erstellen	Allgemeine Java-Themen	3	21. Dez 2016
B	Wie vergleiche ich Strings in einer Liste?	Allgemeine Java-Themen	5	16. Jul 2016
	Threads Liste In unterschiedlichen Threads bearbeiten	Allgemeine Java-Themen	23	4. Jul 2016
A	Collections Inhalt einer Liste mit Inhalt anderer Liste vergleichen ?	Allgemeine Java-Themen	7	5. Mrz 2016
I	Abstrakte Datentypen - Liste	Allgemeine Java-Themen	9	2. Feb 2016
D	Datentypen Klassenattribut aus Objekt in generischer Liste	Allgemeine Java-Themen	15	19. Jan 2016
P	Liste zu Objekt umwandeln	Allgemeine Java-Themen	4	20. Okt 2015
Z	In die Liste kann ich nichts adden	Allgemeine Java-Themen	16	6. Okt 2015
C	Liste checken auf MINDESTENS ein Objekt \| Bukkit	Allgemeine Java-Themen	3	27. Sep 2015
M	liste von listen anders ausgeben	Allgemeine Java-Themen	1	26. Mai 2015
B	Per Buttonklicks einer Liste Wörter hinzufügen - Wie umsetzen?	Allgemeine Java-Themen	11	20. Mai 2015
H	Liste sortieren anhand optionalem Property	Allgemeine Java-Themen	3	7. Apr 2015
A	Input/Output Liste der Dateien in einem Ordner in einer Jar Datei erhalten	Allgemeine Java-Themen	11	22. Dez 2014
J	Fragen zu generischer doppelt verketteter Liste (bei fehlendem Grundverständnis)	Allgemeine Java-Themen	1	19. Dez 2014
B	Prüfen, ob ein Element in der Liste nicht existiert	Allgemeine Java-Themen	3	14. Dez 2014
B	Klassen JTable mit einer Liste	Allgemeine Java-Themen	0	12. Dez 2014
X	HTTP Auslesen der Ergebnisse von einer Webseite und in eine Liste packen	Allgemeine Java-Themen	1	29. Okt 2014
A	Auslesen einer Datei sowie ausgeben als Liste in App	Allgemeine Java-Themen	5	6. Jul 2014
E	Liste löscht sich selbstständig	Allgemeine Java-Themen	5	9. Jun 2014
H	Liste von Objekten generisch sortieren	Allgemeine Java-Themen	0	15. Jan 2014
D	Liste anhand Standardnormalverteilung befüllen	Allgemeine Java-Themen	1	26. Dez 2013
M	Threads synchroner Zugriff (add/delete/read) auf eine Liste	Allgemeine Java-Themen	6	5. Nov 2013
T	Datentypen Eine Liste - verschiedenen Klassen - eine Abstracte Klasse	Allgemeine Java-Themen	3	1. Nov 2013
M	Werte aus DB in Liste speichern ohne mehrfach speicherung	Allgemeine Java-Themen	18	14. Okt 2013
G	Liste anzahl der gleichen Objekte	Allgemeine Java-Themen	6	11. Okt 2013
S	Pattern.Match Suche: For Schleife einbinden und in Liste schreiben	Allgemeine Java-Themen	3	24. Jan 2013
O	aus Liste ein beliebiges Element auswählen	Allgemeine Java-Themen	7	23. Jan 2013
J	Liste aller Com-Ports - zweistellige Ports?	Allgemeine Java-Themen	15	8. Jan 2013
O	MVC - wo Liste der ComboBox-Items ermitteln	Allgemeine Java-Themen	3	31. Dez 2012
	Liste von Pfaden in eine textArea schreiben	Allgemeine Java-Themen	7	12. Dez 2012
K	kontinuierlich aktuelle Bestellsystem-Liste mit farbigem Status	Allgemeine Java-Themen	2	28. Nov 2012
A	Auswählbare Liste	Allgemeine Java-Themen	2	31. Okt 2012
D	Sortieren von Liste zu unperformant	Allgemeine Java-Themen	6	22. Aug 2012
N	Liste gesucht	Allgemeine Java-Themen	2	15. Jul 2012
Z	Sortiertes Einfügen in doppelt verkettete Liste	Allgemeine Java-Themen	5	21. Jun 2012
S	Probleme beim Auslesen einer Liste	Allgemeine Java-Themen	8	15. Jun 2012
O	JSON String bauen aus Liste	Allgemeine Java-Themen	2	12. Jun 2012
M	Über Liste verschiendene JComponents mit eigenem implementierten Interface ansprechen	Allgemeine Java-Themen	7	12. Mai 2012
T	Hashmap mit geordneter/ungeordneter liste als Value	Allgemeine Java-Themen	5	28. Mrz 2012
D	Zugriff auf Array-Liste	Allgemeine Java-Themen	19	5. Mrz 2012
S	Threads Liste mit Objekten in Teillisten zerlegen und abarbeiten	Allgemeine Java-Themen	3	20. Feb 2012
R	ThreadPool - vorhandene thread liste überprüfen bzw. aufräumen	Allgemeine Java-Themen	3	16. Jan 2012
	Liste füllen	Allgemeine Java-Themen	2	11. Jan 2012
U	Große Liste von Strings mit indiziertem Zugriff	Allgemeine Java-Themen	31	7. Dez 2011
B	Properties File Liste	Allgemeine Java-Themen	3	22. Nov 2011
	Collections Liste zusammenfassen für JSP	Allgemeine Java-Themen	4	14. Nov 2011
	Collections (Unbekannte) Liste Sortieren	Allgemeine Java-Themen	10	7. Nov 2011
T	Collections Liste schnell/nebenläufig durchgehen	Allgemeine Java-Themen	2	23. Okt 2011
M	Objekt aus Liste in Liste suchen/löschen	Allgemeine Java-Themen	6	18. Okt 2011
Q	"Doppelte" Einträge einer Liste entfernen	Allgemeine Java-Themen	14	5. Okt 2011
C	Exponentielle Verteilung in einer Liste	Allgemeine Java-Themen	7	30. Sep 2011
	liste der installierten Zertifikate ?!	Allgemeine Java-Themen	3	5. Sep 2011
T	Liste mit GregorianCalendar-Objekten in List einlesen, mit Collection sortieren und ausgeben	Allgemeine Java-Themen	3	7. Aug 2011
M	Verständnisfragen bezüglich Liste	Allgemeine Java-Themen	3	29. Mai 2011
S	AWT Wie bekomme ich eine Liste aller chars in einem Font?	Allgemeine Java-Themen	3	6. Apr 2011
J	Zeichenketten-Liste filtern	Allgemeine Java-Themen	6	12. Feb 2011
S	Aus einer Liste<Oberklasse> alle Elemente die eine bestimmte Unterklasse von Oberklasse haben filter	Allgemeine Java-Themen	8	1. Feb 2011
K	Liste aller implementierenden Klassen einer Oberklasse anzeigen	Allgemeine Java-Themen	4	17. Jan 2011
M	Eintrag verschwindet aus Liste	Allgemeine Java-Themen	3	7. Dez 2010
E	Objekte in einer Liste suchen.	Allgemeine Java-Themen	4	16. Okt 2010
I	Über eine Liste iterieren und Objekte löschen. Wie löst man das sauber?	Allgemeine Java-Themen	5	15. Okt 2010
	Kopie einer Liste	Allgemeine Java-Themen	4	20. Sep 2010
N	Liste mit Map abgleichen extrem langsam	Allgemeine Java-Themen	6	26. Jul 2010
C	Darstellung der Liste bei vielen Daten extrem langsam	Allgemeine Java-Themen	11	18. Jun 2010
T	Liste sortieren	Allgemeine Java-Themen	6	7. Jun 2010
L	Objekte in Liste packen	Allgemeine Java-Themen	2	21. Apr 2010
N	Liste aendern waehrend des iterierens ueber selbige	Allgemeine Java-Themen	11	18. Dez 2009
B	Datenstruktur: Liste	Allgemeine Java-Themen	5	17. Nov 2009
S	Liste mit verschiedenden Objekten	Allgemeine Java-Themen	15	27. Okt 2009

Liste führt sich nicht weiter

Lukases2

Aktives Mitglied

Joose

Top Contributor

Lukases2

Aktives Mitglied

Bananabert

Bekanntes Mitglied

Lukases2

Aktives Mitglied

Bananabert

Bekanntes Mitglied

Ähnliche Java Themen

Aktuelle Jobs

Neue Themen