Liste führt sich nicht weiter

Lukases2

Aktives Mitglied
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;
	}
}
 
Zuletzt bearbeitet von einem Moderator:

Joose

Top Contributor
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.
 
Zuletzt bearbeitet:

Lukases2

Aktives Mitglied
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

Bekanntes Mitglied
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

Aktives Mitglied
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.
 
Zuletzt bearbeitet:

Bananabert

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

Ähnliche Java Themen


Oben