Ist dieses Framework als Grundlage geeignet?

[Ruzmanz]

Hallo zusammen,
da ich ein kleines Jump and Run Spiel programmieren möchte, wollte ich fragen, ob sich dieses Framework als Grundlage eignet? (Das Spiel wird übrigens nur 2D Grafiken enthalten)

 

[Marco13]

Beim ersten Drüberschauen sieht's ganz vernünftig aus - gut kommentiert und dokumentiert, und keine offensichtlichen, groben Schnitzer drin. "Besser geht immer", manche Sachen könnte man natürlich noch allgemeingültiger machen, aber das kann wohl für viele Spiele schonmal eine Grundlage sein.
Kannst dir auch noch Quaxli's Spieletutorial ansehen, da ist vieles noch genauer und ausführlicher erklärt.

 

[Evolver]

Naja, es macht kein aktives Rendering, sondern nutzt nur - ist eben swing - passives Rendering. Das heißt, es wird nicht gezeichnet, wenn Du repaint() aufrufst, sondern repaint() sag nur "Hey, zeichne mal bei nächster Gelegenheit neu" ... während dein Logikthread weiterläuft.
Das ist für Spiele im Allgemeinen nicht so toll. Das von Marco13 ewähnte Tutorial enthält meines Wissens nach auch eine Anleitung, wie man mit AWT zu aktivem Rendering kommt.

 

[Marco13]

"Im Allgemeinen nicht so toll" ist etwas zu pauschal. Ich würde eher sagen: Im allgemeinen ist das genau richtig. Ausnahmen wären dann nur (IMHO SEHR) wenige "Echtzeit-Spiele", wo es auf hohe Frameraten ankommt. Die werden dann aber u.U. auch entsprechend aufwändiger (bzgl. der genauen Gestaltung des Game Loops). Für alles von TicTacToe bis Breakout dürfte das dortige Framework OK sein...

 

[Evolver]

Nun, ich habe mit passivem Rendering keine guten Erfahrungen gemacht. Du hast Recht, handelt es sich um etwas wie TicTacToe oder eine Brettspielnachbildung und ähnliches, ist passive Rendering okay. Aber für ein Jump'n'Run finde ich es ungeeignet.

 

[Ruzmanz]

Der Vorteil vom aktivem und passiven Rendering leuchtet mir jetzt ein, nur ich sehe zwischen dem GamePanel von Quaxli und diesem Framework keinen Unterschied. (Hat eigentlich nicht viel zu bedeuten, weil ich ziemlicher Anfänger bin.)

Bei beiden Projekten wird eine mehr oder weniger endliche Schleife aufgerufen, die eine Methode zum Repaint aufruft. So wie ich das verstehe ist diese Konstruktion das passive Rendering:

[highlight="java"]
Schleife {
repaint();
}

@Override
public void paintComponent(Graphics g) {
}
[/highlight]

Wenn ich das jetzt mit diesem Tutorial für Aktives Rendering und Space Invaders vergleiche, dann müsste dies das aktive Rendering sein:

[highlight="java"]
setIgnoreRepaint(true);
strategy = getBufferStrategy();

Schleife {
Graphics2D g = (Graphics2D) strategy.getDrawGraphics();
g.dispose();
strategy.show();
}
[/highlight]

Wäre nett, wenn ihr mich korrigieren würdet, falls ich falsch liege. Das würde im endeffekt bedeuten, dass ich "paintComponent(Graphics g)" aus dem Framework verwerfen und die gameLoop() mit so einem Strategy Buffer ausbessern könnte?

 

[Evolver]

Ich habe nochmal geschaut, ab Seite 126 erläutert Quaxli den Einstieg in aktives Rendern. Das wird meines Erachtens nach deutlich sauberer umgesetzt bzw. auch übersichtlicher dargestellt, als in dem Tutorial von GameDev.net. Mein Tipp, schaue es dir nochmal in Ruhe an und programmiere es vielleicht auch nach.

 

[Quaxli]

Danke Euch Beiden für das Lob bzw. die Werbung.

 

[Ruzmanz]

[highlight=Java]import java.awt.*;
import java.awt.image.BufferStrategy;
import javax.swing.*;

public class GameMain extends Canvas {

private static final int CANVAS_WIDTH = 800;
private static final int CANVAS_HEIGHT = 600;

static enum State {
INITIALIZED, PLAYING, PAUSED, GAMEOVER, DESTROYED
}
static State state;

private Frame frame;
private BufferStrategy strategy;

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new GameMain();
}
});
}

public GameMain() {
this.setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
frame = new JFrame("Game");
frame.add(this);
frame.pack();
frame.setIgnoreRepaint(true);
frame.setVisible(true);
createBufferStrategy(2);
strategy = getBufferStrategy();
gameInitializations();
}

public void gameInitializations() {
state = State.INITIALIZED;
gameStart();
}

public void gameStart() {
Thread gameThread = new Thread() {
@Override
public void run() {
gameLoop();
}
};
gameThread.start();
}

public void gameLoop() {
state = State.PLAYING;
while (state != State.GAMEOVER) {
if (state == State.PLAYING) {
gameUpdate();
}
try {
Thread.sleep(30);
} catch (InterruptedException ex) { }
}
}

public void gameUpdate() {
doPainting();
}

public void doPainting() {
Graphics2D g = (Graphics2D) strategy.getDrawGraphics();
// Pictures
g.dispose();
strategy.show();
}
}[/highlight]

Wäre das so richtig, mal von der Tastatureingabe abgesehen?