Hallo,
gerade bin ich mit 2 Kollegen im Rahmen eiens Netzwerkprogrammieren-Praktikums dabei, ein Multiuser-game im Peer-To-Peer-Netzwerk zu realisieren. Wir haben uns für ein einfaches 2D-Schießspiel entschieden, wo sich bis zu n Spieler mit Raumschiffen abscheißen können.
Jetzt ist gerade ein Raumschiff fertig, aber es tut sich ein Problem mit der Synchronisation auf. Je nach eingesetztem Betriebssystem und je nach Rechnerleistung fliegt das Raumschiff unterschiedlich schnell.
Jetzt habe ich versucht, die sleep-Zeit an die rechenleistung anzupassen(siehe Code), indem ich eine for-schleife durchlaufen lasse und proprtional abhängig von der Zeit, die der Rechner dafür benötigt hat eine sleep-time ausrechne. Das Problem ist, dass das Schiff auf verschiedenen Systemen immernoch unterschiedlich schnell fliegt, was alleine ja schon nicht sein kann, da man die sleep-Zeit in Millisekunden angibt. Dauert das Zeichnen etwa so lange? Wenn doch, dann sage mir bitte irgendwer, wie ich die sleep-Zeit dynamisch an die Rechenleitsung anpassen kann.
Hier mein bisheriger Code:
[/code]
gerade bin ich mit 2 Kollegen im Rahmen eiens Netzwerkprogrammieren-Praktikums dabei, ein Multiuser-game im Peer-To-Peer-Netzwerk zu realisieren. Wir haben uns für ein einfaches 2D-Schießspiel entschieden, wo sich bis zu n Spieler mit Raumschiffen abscheißen können.
Jetzt ist gerade ein Raumschiff fertig, aber es tut sich ein Problem mit der Synchronisation auf. Je nach eingesetztem Betriebssystem und je nach Rechnerleistung fliegt das Raumschiff unterschiedlich schnell.
Jetzt habe ich versucht, die sleep-Zeit an die rechenleistung anzupassen(siehe Code), indem ich eine for-schleife durchlaufen lasse und proprtional abhängig von der Zeit, die der Rechner dafür benötigt hat eine sleep-time ausrechne. Das Problem ist, dass das Schiff auf verschiedenen Systemen immernoch unterschiedlich schnell fliegt, was alleine ja schon nicht sein kann, da man die sleep-Zeit in Millisekunden angibt. Dauert das Zeichnen etwa so lange? Wenn doch, dann sage mir bitte irgendwer, wie ich die sleep-Zeit dynamisch an die Rechenleitsung anpassen kann.
Hier mein bisheriger Code:
Code:
package spaceships;
import java.awt.*;
public class MoveShip extends Thread {
public static final Color ownShipColor = Color.green;
public static final Color otherShipColor = Color.red;
private Color shipColor;
private int shipWidth;
private int shipHeight;
private int x;
private int y;
private int direction = 0;
private Graphics g;
private int maxX;
private int maxY;
private long sleepTime;
//Test-Methode
public void setXY(int x, int y) {
this.x = x;
this.y = y;
}
//Funktion, die ein bisschen wartet
public void pause() {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public MoveShip(Graphics g, Color shipColor) {
x = 100;
y = 100;
long l = System.currentTimeMillis();
System.out.println(System.currentTimeMillis());
int a;
for (int i = 0; i < 50000000 ; i ++)
{
}
l = System.currentTimeMillis() - l;
System.out.println(System.currentTimeMillis());
System.out.println(l);
sleepTime = l / 200;
System.out.println(sleepTime);
this.g = g;
this.shipColor = shipColor;
//Bildschirmauflösung herausfinden
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
maxX = d.getSize().width;
maxY = d.getSize().height;
//Schiff an Bildschirmauflösung anpassen
shipWidth = Math.round(maxX / 32);
shipHeight = Math.round(maxY / 16);
}
public void moveDown(Graphics g) {
//Schiff-Koordinaten
int[] xPol = { x, x - Math.round(shipWidth / 2), x,
x + Math.round(shipWidth / 2), x };
int[] yPol = { y, y - shipHeight, y - 2 * Math.round(shipHeight / 3),
y - shipHeight, y };
g.setColor(shipColor);
//Schiff zeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
pause(); //Das Schiff soll nicht rasen!
g.setColor(Color.black);
//Schiff überzeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
//Schiff nach unten bewegen
y = y + 1;
yPol[0] = y;
yPol[1] = y - shipHeight;
yPol[2] = y - 2 * Math.round(shipHeight / 3);
yPol[3] = y - shipHeight;
yPol[4] = y;
}
public void moveUp(Graphics g) {
//Schiff-Koordinaten
int[] xPol = { x, x - Math.round(shipWidth / 2), x,
x + Math.round(shipWidth / 2), x };
int[] yPol = { y, y + shipHeight, y + 2 * Math.round(shipHeight / 3),
y + shipHeight, y };
g.setColor(shipColor);
//Schiff zeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
pause(); //Das Schiff soll nicht rasen!
g.setColor(Color.black);
//Schiff überzeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
//Schiff nach oben bewegen
y = y - 1;
yPol[0] = y;
yPol[1] = y + shipHeight;
yPol[2] = y + 2 * Math.round(shipHeight / 3);
yPol[3] = y + shipHeight;
yPol[4] = y;
}
public void moveLeft(Graphics g) {
//Schiff-Koordinaten
int[] xPol = { x, x + shipHeight, x + 2 * Math.round(shipHeight / 3),
x + shipHeight, x };
int[] yPol = { y, y - Math.round(shipWidth / 2), y,
y + Math.round(shipWidth / 2), y };
g.setColor(shipColor);
//Schiff zeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
pause(); //Das Schiff soll nicht rasen!
g.setColor(Color.black);
//Schiff überzeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
//Schiff nach links bewegen
x = x - 1;
xPol[0] = x;
xPol[1] = x + shipHeight;
xPol[2] = x + 2 * Math.round(shipHeight / 3);
xPol[3] = x + shipHeight;
xPol[4] = x;
}
public void moveRight(Graphics g) {
//Schiff-Koordinaten
int[] xPol = { x, x - shipHeight, x - 2 * Math.round(shipHeight / 3),
x - shipHeight, x };
int[] yPol = { y, y - Math.round(shipWidth / 2), y,
y + Math.round(shipWidth / 2), y };
g.setColor(shipColor);
//Schiff zeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
pause(); //Das Schiff soll nicht rasen!
g.setColor(Color.black);
//Schiff überzeichnen
g.drawPolygon(xPol, yPol, 5);
g.fillPolygon(xPol, yPol, 5);
//Schiff nach rechts bewegen
x = x + 1;
xPol[0] = x;
xPol[1] = x - shipHeight;
xPol[2] = x - 2 * Math.round(shipHeight / 3);
xPol[3] = x - shipHeight;
xPol[4] = x;
}
public void setDirection(int direction) {
this.direction = direction;
}
public void run() {
while (true) {
//Schiff auf der anderen Seite wieder erscheinen lassen, wenn
//es über den Bildschirmrand hinausgeht
if (x < 0)
x = maxX;
else if (x > maxX)
x = 0;
if (y < 0)
y = maxY;
else if (y > maxY)
y = 0;
//Das Schiff kann in 4 unterschiedliche Richtungen fliegen
switch (direction) {
case 0 : moveLeft(g);
break;
case 1 : moveRight(g);
break;
case 2 : moveUp(g);
break;
case 3 : moveDown(g);
break;
}
}
}
}
