Hallo erstmal,
Ich habe vor einigen Tagen dieses Tutorial von Quaxli gefunden und es einmal komplett durchgelesen, da ich gerade dabei bin eines meiner Projekte von vor einem Jahr komplett neu zu erstellen. Damals hatte ich gerade mal ein Jahr mit Java gearbeitet und dementsprechend schlecht war der Code (und wenn ich schlecht sage dann meine ich auch wirklich schlecht
).
Da ich mein Projekt dabei gleich erweitern will und mit eigenen Animationen/Musik etc aufpeppen will hat mir das Tutorial von Quaxli in der Hinsicht sehr weitergeholfen. Deshalb habe ich mich auch für das Grundgerüst (Sprites etc) daran orientiert. Aber da ich wie gesagt das Projekt direkt auch erweiterbar aufbauen will habe ich mir anstatt, wie zuerst die ganzen Sprites im JPanel des Spiels abzulegen, eine eigene SpriteLib programmiert. Damit komme ich auch zu dem warum ich hier poste. Undzwar wollte ich das mal jemand drüber schaut und mir seine Meinung dazu sagt. Es ist für mich eben wichtig das die Datenstruktur stimmt, damit ich nicht dann in paar Wochen irgendwelche Probleme damit hab und wieder bei 0 Anfangen muss ... Danke schon mal im Vorraus!
Ich habe vor einigen Tagen dieses Tutorial von Quaxli gefunden und es einmal komplett durchgelesen, da ich gerade dabei bin eines meiner Projekte von vor einem Jahr komplett neu zu erstellen. Damals hatte ich gerade mal ein Jahr mit Java gearbeitet und dementsprechend schlecht war der Code (und wenn ich schlecht sage dann meine ich auch wirklich schlecht
). Da ich mein Projekt dabei gleich erweitern will und mit eigenen Animationen/Musik etc aufpeppen will hat mir das Tutorial von Quaxli in der Hinsicht sehr weitergeholfen. Deshalb habe ich mich auch für das Grundgerüst (Sprites etc) daran orientiert. Aber da ich wie gesagt das Projekt direkt auch erweiterbar aufbauen will habe ich mir anstatt, wie zuerst die ganzen Sprites im JPanel des Spiels abzulegen, eine eigene SpriteLib programmiert. Damit komme ich auch zu dem warum ich hier poste. Undzwar wollte ich das mal jemand drüber schaut und mir seine Meinung dazu sagt. Es ist für mich eben wichtig das die Datenstruktur stimmt, damit ich nicht dann in paar Wochen irgendwelche Probleme damit hab und wieder bei 0 Anfangen muss ... Danke schon mal im Vorraus!
Java:
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import java.util.Hashtable;
import java.util.Vector;
import javax.imageio.ImageIO;
import data.Sprite;
/**
* Eine Sprite Library in der verschiedenste Sprites, Bilder und Animationen
* gespeichert werden können. Dient als Datenbank für das Spielgeschehen.
*
* @author Lucas
* @version 0.1
*/
public class SpriteLib {
/**
* Speichert alle geladenen Sprites mit einem dazugehörigen Key.
*/
private Hashtable<String, Sprite> sprites;
/**
* Speichert alle geladenen Bilder. Hierraus können entweder Animationen
* erstellt werden oder diese direkt verwendet werden.
*/
private Hashtable<String, BufferedImage> pics;
/**
* Speichert alle erstellten Animationen mitsamt einem Key über den diese
* Abgerufen werden können. Somit können für ein Sprite auch verschiedene
* Animationen benutzt werden, aber auch Animationen für andere Objekte
* benutzt werden (e.g. Explosionen)
*/
private Hashtable<String, BufferedImage[]> animations;
/**
* Instanziiert die drei Hashtables der SpriteLib.
*/
public SpriteLib() {
sprites = new Hashtable<String, Sprite>();
pics = new Hashtable<String, BufferedImage>();
animations = new Hashtable<String, BufferedImage[]>();
}
/**
* Lädt ein Bild aus dem Angebenen Pfad in die Datenbank ein und gibt dieses
* auch zurück.
*
* @param key
* Name des Pics unter dem es in die DB abgelegt werden soll
* @param path
* Pfad des Bildes ("pics/xxxxx.xxx")
* @return Gibt das geladene Bild zurück
*/
public BufferedImage loadPic(String key, String path) {
BufferedImage source = null;
URL pic_url = getClass().getClassLoader().getResource(path);
try {
source = ImageIO.read(pic_url);
} catch (IOException e) {
}
this.pics.put(key, source);
return source;
}
/**
* Lädt ein Image aus dem angegebenen Pfad aus. Erstellt daraus dann eine
* Animation und gibt diese zurück.
*
* @param key
* Key für die Hashtabelle
* @param path
* Pfad der Animation
* @param pics
* Anzahl der Einzelbilder
* @return Die erstellte Animation
*/
public BufferedImage[] loadAnimation(String key, String path, int pics) {
BufferedImage source = null;
URL pic_url = getClass().getClassLoader().getResource(path);
try {
source = ImageIO.read(pic_url);
} catch (IOException e) {
}
return createAnimatedImage(key, source, pics);
}
/**
* Erstellt aus einem einfachen Bild mit mehreren Einzelbildern eine
* Animation die zurückgegeben wird und in der DB abgespeichert wird.
*
* @param key
* Name für die Datenbank
* @param source
* Die original Bilddatei
* @param pics
* Die Anzahl der Einzelbilder
* @return Die erstellte Animation
*/
public BufferedImage[] createAnimatedImage(String key,
BufferedImage source, int pics) {
BufferedImage[] anim = new BufferedImage[pics];
for (int x = 0; x < pics; x++) {
anim[x] = source.getSubimage(x * source.getWidth() / pics, 0,
source.getWidth() / pics, source.getHeight());
}
animations.put(key, anim);
return anim;
}
/**
* Wandelt die vorhandene Hashtable der Sprites in einen Vector um der alle
* gespeicherten Sprites dieser SpriteLib beinhaltet und gibt diesen zurück.
*
* @return einen Vector mit allen Sprites dieser SpriteLib
*/
public Vector<Sprite> getSprites() {
Vector<Sprite> temp = new Vector<Sprite>();
Sprite[] tmp = new Sprite[sprites.size()];
sprites.values().toArray(tmp);
for (int i = 0; i < sprites.size(); i++) {
temp.add(tmp[i]);
}
return temp;
}
public BufferedImage getPic(String key) {
return pics.get(key);
}
public void removePic(String key) {
pics.remove(key);
}
public BufferedImage[] getAnimation(String key) {
return animations.get(key);
}
public void removeAnimation(String key) {
animations.remove(key);
}
public Sprite getSprite(String key) {
return sprites.get(key);
}
public void addSprite(String key, Sprite sprite) {
sprites.put(key, sprite);
}
}
