Java/Tutorials/Karteneditor II Kapitel 8

SpielFenster

import java.awt.Dimension;
import java.awt.Point;
 
import javax.swing.JFrame;
 
public class SpielFenster extends JFrame{
 
 	Point ansichtsPunkt=new Point(0,0);
	SpielAnsicht ansicht;
	Steuerung steuerung;
	SpielerSprite spieler;
	SpielSchleife schleife;
	Karte karte;
 
	Thread zeichenThread;
	Thread schleifenThread;
 
	public SpielFenster()
	{
		steuerung=new Steuerung();
		addKeyListener(steuerung);
 
		spieler=new SpielerSprite("Char.png",this);
		karte=Karte.ladeKarte("1.karte");
		ansicht=new SpielAnsicht(this);
		schleife=new SpielSchleife(this);
 
		add(ansicht);
 
		zeichenThread=new Thread(ansicht);
		schleifenThread=new Thread(schleife);
		zeichenThread.start();
		schleifenThread.start();
 
		setSize(new Dimension(640,480));
		setTitle("Spiel");
		setVisible(true);
	}
}

SpielSchleife

import java.awt.Point;
 
public class SpielSchleife implements Runnable{
 
	SpielFenster fenster;
	Karte karte;
	Steuerung steuerung;
	Point punkt;
	int MAX_GAME_SPEED=33;
 
	public SpielSchleife(SpielFenster f)
	{
		fenster=f;
		karte=fenster.karte;
		steuerung=fenster.steuerung;
		punkt=fenster.ansichtsPunkt;
	}
 
	public void run()
	{
		while(true)
		{
 
			float START = System.currentTimeMillis();
 
			if(steuerung.hoch == true)
			{
				punkt.y--;
			}
			else if(steuerung.runter == true)
			{
				punkt.y++;
			}
			else if(steuerung.links == true)
			{
				punkt.x--;
			}
			else if(steuerung.rechts == true)
			{
				punkt.x++;
			}
 
			if(punkt.x > karte.breite-20)
			{
				punkt.x--;
			}
			else if(punkt.y > karte.höhe-15)
			{
				punkt.y--;
			}
			else if(punkt.x < 0)
			{
				punkt.x++;
			}
			else if(punkt.y < 0)
			{
				punkt.y++;
			}			
			float AUSFUEHR = System.currentTimeMillis()-START;
			if(MAX_GAME_SPEED>AUSFUEHR)
			{
				try {
					Thread.sleep(MAX_GAME_SPEED-(int)AUSFUEHR);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

SpielAnsicht

import java.awt.Dimension;
import java.awt.Graphics;
 
import javax.swing.JPanel;
 
public class SpielAnsicht extends JPanel implements Runnable{
 
	SpielerSprite spieler;
	SpielFenster fenster;
	Karte karte;
	final int MAX_GAME_SPEED=33;
 
	public SpielAnsicht(SpielFenster f)
	{
		fenster=f;
		karte=fenster.karte;
		spieler=fenster.spieler;
		setPreferredSize(new Dimension(640,480));
		setDoubleBuffered(true);
	}
 
	public void paintComponent(Graphics g)
	{
		zeichneKarte(g);
		zeichneSpieler(g);
	}
 
	public void zeichneSpieler(Graphics g)
	{
		g.drawImage(spieler.getImage(), spieler.position.x*32, spieler.position.y*32-16, this);
	}
 
	public void zeichneKarte(Graphics g)
	{
		int startx=fenster.ansichtsPunkt.x;
		int starty=fenster.ansichtsPunkt.y;
		int endx=startx+20;
		int endy=starty+15;
		for(int x=startx, rx=0;x<endx;x++, rx++)
		{
			for(int y=starty,ry=0;y<endy;y++,ry++)
			{
				g.drawImage(karte.getTileImage(x, y), rx*32, ry*32,this);
			}
		}
	}
 
	@Override
	public void run() {
		while(true)
		{
			float START = System.currentTimeMillis();
			repaint();
			float AUSFUEHR = System.currentTimeMillis()-START;
			if(MAX_GAME_SPEED>AUSFUEHR)
			{
				try {
					Thread.sleep(MAX_GAME_SPEED-(int)AUSFUEHR);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

Spirte

import java.awt.image.BufferedImage;
 
public abstract class Sprite {
	public abstract BufferedImage getImage();
}

SpielerSprite

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
 
public class SpielerSprite extends Sprite{
 
	BufferedImage charset;
	Point position=new Point(9,8);
	SpielFenster fenster;
	Steuerung steuerung;
	float animation=0.0f;
 
	public SpielerSprite(String dateiname, SpielFenster f)
	{
		fenster=f;
		steuerung=fenster.steuerung;
 
		try {
			charset=ImageIO.read(new File(dateiname));
		} catch (IOException fehler) {
			fehler.printStackTrace();
		}
	}
 
	@Override
	public BufferedImage getImage() {
		if(steuerung.bewegung)animation+=0.33;
		else animation=0.0f;
 
		if((int)animation ==4 ) animation=0.0f;
		return charset.getSubimage(((int)animation)*32, steuerung.letzterichtung*48, 32, 48);
	}
}

Steuerung

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
 
public class Steuerung implements KeyListener{
 
	public int letzterichtung=0;// 3=hoch, 0=runter,1=links,2=rechts
	boolean bewegung=false;
 
	public boolean hoch=false;
	public boolean runter=false;
	public boolean links=false;
	public boolean rechts=false;
 
	@Override
	public void keyPressed(KeyEvent e) {
		switch(e.getKeyCode())
		{
			case KeyEvent.VK_UP:
				letzterichtung=3;
				hoch=true;
				bewegung=true;
				break;
			case KeyEvent.VK_DOWN:
				letzterichtung=0;
				runter=true;
				bewegung=true;
				break;
			case KeyEvent.VK_LEFT:
				letzterichtung=1;
				links=true;
				bewegung=true;
				break;
			case KeyEvent.VK_RIGHT:
				letzterichtung=2;
				rechts=true;
				bewegung=true;
				break;
		}
	}
 
	@Override
	public void keyReleased(KeyEvent e) {
		switch(e.getKeyCode())
		{
			case KeyEvent.VK_UP:
				hoch=false;
				bewegung=false;
				break;
			case KeyEvent.VK_DOWN:
				runter=false;
				bewegung=false;
				break;
			case KeyEvent.VK_LEFT:
				links=false;
				bewegung=false;
				break;
			case KeyEvent.VK_RIGHT:
				rechts=false;
				bewegung=false;
				break;
		}
	}
 
	@Override
	public void keyTyped(KeyEvent e) {
 
	}
 
}

Karte

import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
 
import javax.imageio.ImageIO;
 
public class Karte
{
	int[][] karte;
 
	int breite;
	int höhe;
 
	String kartenName;
	String tilesetDateiname;
 
	ArrayList<BufferedImage> tileset=new ArrayList<BufferedImage>();
 
	public Karte(int[][] karte, String dateiname, String name)
	{
		this.kartenName=name;
		this.karte=karte;
		this.tilesetDateiname=dateiname;
 
		breite=karte.length;
		höhe=karte[0].length;
 
		try {
			BufferedImage bildTileset=ImageIO.read(new File(dateiname));
			int breite=bildTileset.getWidth()/32;
			int höhe=bildTileset.getHeight()/32;
			for(int x=0;x<breite;x++)
			{
				for(int y=0;y<höhe;y++)
				{
					BufferedImage tile=bildTileset.getSubimage(x*32, y*32, 32, 32);
					this.tileset.add(tile);
				}				
			}
		} catch (IOException fehler) {
			fehler.printStackTrace();
		}
	}
 
 
	public BufferedImage getTileImage(int x, int y)
	{
		int tile=karte[x][y];
		return tileset.get(tile);
	}
 
	public void setTile(int x, int y, int tileID)
	{
		karte[x][y]=tileID;
	}
 
	public static Karte ladeKarte(String kartendateiname)
	{
		try {
			FileInputStream datei = new FileInputStream(new File(kartendateiname));
			BufferedInputStream buf=new BufferedInputStream(datei);
			ObjectInputStream lese = new ObjectInputStream(buf);
 
			int[][]karte=(int[][]) lese.readObject();
			String name=(String) lese.readObject();
			String dateiname=(String) lese.readObject();
 
			Karte geladeneKarte=new Karte(karte,dateiname, name);
 
			lese.close();
			return geladeneKarte;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}

Main

public class Main
{
	public static void main(String[] args) {
		SpielFenster spiel=new SpielFenster();
 
	}
}