Applet mit einem beweglichem Block

[Zerod]

Hallo,

ich bin noch Java Anfänger und probiere zur zeit nur so ein bisschen rum. zur zeit möchte ich ein Applet machen in dem man nur ein kleinen 10*10 Großen Block bewegen kann.
aber irgendwie hab ich da an allen Ecken und Enden Probleme.

Deshalb meine Frage: kann mir jemand einen Quellcode geben, für ein Apples, in dem man mit WASD einen Block bewegen kann? der Code sollte nach Möglichkeit sehr einfach geschrieben sein. Also Anfänger freundlich^^.

 

[0x7F800000]

ich da an allen Ecken und Enden Probleme.

noch unkonkreter ging's nicht?

Deshalb meine Frage: kann mir jemand einen Quellcode geben, für ein Apples, in dem man mit WASD einen Block bewegen kann?

Hmm, gut. Also, ich hoffe doch sehr, dass das keine blöde Hausaufgabe ist, sondern dass du tatsächlich just for fun nur so rumprobierst... Als ich mit Java angefangen hab, war ich nach einer Woche völlig frustriert, und wollte auch wissen, wie, verdammt nochmal, man mit diesem java irgendeine Animation hinbekommt^^ Damals hätte ich wohl lieber auch in einem Forum fragen sollen, kann mich noch wunderbar dran erinnern, was da für ein monströser Code rausgekommen ist ;oops:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

//die klasse erweitert JApplet weil's ein Applet ist, 
//und implementiert KeyListener, weil man auf Tasten-Aktionen hören will.
public class MovingRectangle extends JApplet implements KeyListener{
	private static final long serialVersionUID = 1L;
	
	private int[] position;							//x,y koordinaten des Rechtecks				  
	private HashMap<Character,Boolean> keyStates;	//zustände der tasten wasd
	private JComponent canvas;						//ein JComponent zum draufzeichnen
	
	//diese methode hilft, die verschiedenen tastenkombinationen korrekt 
	//zu verknüpfen. bei "a+d" soll das rechteck genauso halten, als wenn keine
	//taste gedrückt wäre
	private static int getDirection(boolean a, boolean b){
		return a^b?b?1:-1:0;
	}
	
	//der JComponent der alles zeichnet
	private class AnimationComponent extends JComponent{
		private static final long serialVersionUID = 1L;

		@Override
		public void paint(Graphics g){
			//zwei rechtecke malen: ein großes weißes und ein kleins schwarzes
			g.setColor(Color.WHITE);
			g.fillRect(0,0,getWidth(), getHeight());
			g.setColor(Color.BLACK);
			g.fillRect(position[0],position[1],17,19);
		}
	}
	
	//der Animationsthread
	private class AnimationThread extends Thread{
		@Override
		public void run(){
			while(true){
				//kleines rechteck verschieben
				position[0]+=getDirection(keyStates.get('a'),keyStates.get('d'));
				position[1]+=getDirection(keyStates.get('w'),keyStates.get('s'));
				//alles neuzeichnen
				canvas.repaint();
				//kurz warten
				try{
					sleep(10);
				}catch(InterruptedException e){
					break;
				}
			}
		}
	}
	
	@Override
	public void init(){
		position=new int[2];						//starten bei (0,0)
		keyStates=new HashMap<Character,Boolean>();	//alle tasten beim start als nicht gedrückt annehmen
		for(char c:"wasd".toCharArray()){
			keyStates.put(c,false);
		}
		addKeyListener(this);						//KeyListener anhängen. In diesem fall sich selbst.
		canvas=new AnimationComponent();			//Komponente zum malen hinzufügen
		this.getContentPane().add(canvas);
		new AnimationThread().start();				//Animationsthread starten
	
	}
	
	@Override public void start(){}					//unbenutztes zeugs...
	@Override public void stop(){}
	@Override public void destroy(){}
	
	//zwei methoden des Listeners markieren die tasten als gedrückt bzw losgelassen,
	//wenn die entsprechenden ereignisse ankommen.
	@Override
	public void keyPressed(KeyEvent e) {
		if(keyStates.keySet().contains(e.getKeyChar())){
			keyStates.put(e.getKeyChar(),true);
		}
	}

	@Override
	public void keyReleased(KeyEvent e) {
		if(keyStates.keySet().contains(e.getKeyChar())){
			keyStates.put(e.getKeyChar(),false);
		}
	}

	@Override public void keyTyped(KeyEvent arg0) {}	//noch mehr unbenutztes zeugs...
}

der Code sollte nach Möglichkeit sehr einfach geschrieben sein. Also Anfänger freundlich^^.

Das Thema an sich ist nun mal überhaupt nicht so sehr anfängerfreundlich. Ohne konkretere Fragen schreib ich da jetzt nicht die halbe Insel hin. Das kannst du auch gerne alleine im Original durchlesen.

edit: ah mist, das flackert jetzt wie bescheuert... was soll'n das... Moment^^ :autsch:
edit2: ok, behoben... Aber bitte skeptisch bleiben, ich habe da bestimmt 379 Swing-Todsünden begangen, ich garantiere für nichts

 

[Zerod]

Thx für den Code und ja es ist nur just 4 fun. Hatte mal die Idee und keine Ahnung wie ich das umsetzen soll.

Aber ich muss sagen, das ich mir das irgendwie einfacher vorgestellt habe. hab so etwas schon mal in c++ geschrieben als Jump and Run und da war das nur eine schleife, die:
1. Tastaturabfragen mit if(taste gedrückt){x/y Pos -/+ Geschwindigkeit}
2. Spielinterne Berechnungen (Kollision und Auslöser)
3. alles was gezeichnet werden muss Zeichen.

Fertig. mehr war da nicht. Da hat mich dein Code schon sehr Überwältigt^^.

 

[0x7F800000]

mehr war da nicht. Da hat mich dein Code schon sehr Überwältigt^^.

Das ist seltsam, denn in diesem code ist noch weniger, als du beschrieben hast...
Ich mein: da hört man halt auf die 4 tasten, ein thread läuft und verschiebt das rechteck hin und her, und auf einer JComponent wird das ganze gezeichnet. Ich hab den code jetzt ein wenig kommentiert, vielleicht erscheint es dadurch etwas weniger mysteriös. Ich weiß halt überhaupt nicht, was du schon kennst, und ob es dir vielleicht alles trivial erscheint.

Mit C++ hab ich mal vor langer Zeit unter Windows programmiert, dort war's afaik nicht wesentlich weniger unangenehm, und den back buffer musste man auch noch selbst einbaun Da hab ich mich auch lange gefragt, wieso man 100 Zeilen von irgendeinem unverständlichen code braucht, um ein fenster aufzukriegen... Aber diese "Grundgerüste" sind immer schall und rauch, und beinhalten eigentlich nix interessantes. Davon sollte man sich nicht abschrecken lassen. Oder (wenn man nur rechtecke rumschieben will), kann man auch auf irgendwelchen kram wie Flash oder JavaFX ausweichen, da muss man für sowas in der tat weniger tippen... Aber andererseits: wozu gibt's IDE's^^

 

[Zerod]

ich dachte nur das es eine einfache abfrage gibt ob Taste xyz gedrückt wurde mit nem einfachem "if taste gedrückt" aber das ist ja irgendwie viel komplizierter^^

 

[0x7F800000]

ich dachte nur das es eine einfache abfrage gibt ob Taste xyz gedrückt wurde mit nem einfachem "if taste gedrückt" aber das ist ja irgendwie viel komplizierter^^

Ähm... vielleicht gibt's das sogar... Nur ich war ehrlich gesagt zu faul danach lange rumzusuchen, aber den KeyListener den kennt ja jeder Mensch, und so erschien's mir irgendwie am einfachsten... feif: Sorry, sowas "spieleähnliches" programmiere ich leider selten, wenn was getippt wird, dann höchstens in ein textfeld Da müsste man entweder in der Api bisschen blättern oder rumgoogln oder Quaxli fragen^^ :rtfm:

 

[0x7F800000]

so, hab jetzt rumgegoogld, scheint mir nicht der fall zu sein, dass es sowas in der standard API gäbe. Weil: braucht kein Mensch, du bist der erste^^ :bae: (korrekt gebaute Sätze sind toll, ja) Wenn man gewöhnliche passive GUI's schreibt, dann braucht man sowas wirklich selten, und wenn man spiele schreibt, hat man eh viel umfangreichere Pakete, um irgendwelche Tastatur- Joystik- Lenkrad- oder was auch immer für eingaben zu verarbeiten.

Und wenn man sowas dann doch braucht, dann kann man's ja schnell basteln:

import java.awt.event.*;
import java.util.*;

public class KeyStateListener implements KeyListener{
	
	private Map<Integer,Boolean> observedKeys;
	
	public KeyStateListener(){
		this.observedKeys=new HashMap<Integer,Boolean>();
	}
	
	@Override
	public void keyPressed(KeyEvent e){
		observedKeys.put(e.getKeyCode(),true);
	}
	
	@Override
	public void keyReleased(KeyEvent e){
		observedKeys.put(e.getKeyCode(),false);
	}
	
	@Override 
	public void keyTyped(KeyEvent e){}
	
	public boolean isPressed(int keyCode){
		Boolean b=observedKeys.get(keyCode);
		return b==null?false:b;
	}
}

Damit sieht der Code so aus:

import javax.swing.*;
import java.awt.*;
import static java.awt.event.KeyEvent.*;

//die klasse erweitert JApplet weil's ein Applet ist, 
//und implementiert KeyListener, weil man auf Tasten-Aktionen hören will.
public class MovingRectangle extends JApplet{
	private static final long serialVersionUID = 1L;
	
	private int[] position;							//x,y koordinaten des Rechtecks		
	private JComponent canvas;						//ein JComponent zum draufzeichnen
	private KeyStateListener keyStateListener;		//listener der auf das "gedrücktsein" aufpasst
	
	//diese methode hilft, die verschiedenen tastenkombinationen korrekt 
	//zu verknüpfen. bei "a+d" soll das rechteck genauso halten, als wenn keine
	//taste gedrückt wäre
	private static int getDirection(boolean a, boolean b){
		return a^b?b?1:-1:0;
	}
	
	//der JComponent der alles zeichnet
	private class AnimationComponent extends JComponent{
		private static final long serialVersionUID = 1L;

		@Override
		public void paint(Graphics g){
			//zwei rechtecke malen: ein großes weißes und ein kleins schwarzes
			g.setColor(Color.WHITE);
			g.fillRect(0,0,getWidth(), getHeight());
			g.setColor(Color.BLACK);
			g.fillRect(position[0],position[1],17,19);
		}
	}
	
	//der Animationsthread
	private class AnimationThread extends Thread{
		@Override
		public void run(){
			while(true){
				//kleines rechteck verschieben
				position[0]+=getDirection(keyStateListener.isPressed(VK_A),keyStateListener.isPressed(VK_D));
				position[1]+=getDirection(keyStateListener.isPressed(VK_W),keyStateListener.isPressed(VK_S));
				//alles neuzeichnen
				canvas.repaint();
				//kurz warten
				try{
					sleep(10);
				}catch(InterruptedException e){
					break;
				}
			}
		}
	}
	
	@Override
	public void init(){
		position=new int[2];						//starten bei (0,0)
		keyStateListener=new KeyStateListener();
		addKeyListener(keyStateListener);			//KeyListener anhängen. In diesem fall sich selbst.
		canvas=new AnimationComponent();			//Komponente zum malen hinzufügen
		this.getContentPane().add(canvas);
		new AnimationThread().start();				//Animationsthread starten
	
	}
}

So. Das sind jetzt grad mal 65 zeilen, davon 12 Kommentarzeilen, 2 für sinnlose UID's, 3 Override Annotationen, 7 leerzeilen, 3 Imports... Bleiben 38 Zeilen, dabei stehen in den meisten nur gschlossene Klammern^^ Da ist doch jetzt echt einfach nur noch Luft drinne

Die blöden Array-additionen sollte man noch Auslagern, und sich eine angemessene Klasse für "geometrische Pfeilchen-Vektoren" basteln.

 

[Zerod]

vielen dank für all die Mühe. ich werde jetzt erst mal gucken wie ich weiter machen will^^.