STARTHILFE gesucht !! Java-Projekt für Schule !!

[death90]

Hallo,
ich melde mich mal wieder !

Bin mit dem Programm jetzt schonmal voran gekommen

Ich will jetzt in der TunnelPanel.java eine variable Timedraw einbringen,
die vom beginn der animation an in der linken oberen Ecke des Frames gezeichnet wird.
Sie soll so Aussehen: Speed 100% (und dann steigend auf 300%)!

Die Berechnung der prozentualen Geschwindigkeit hab ich schon gemacht und in einer
Variable: protected float Time; in der While Schleife gespeichert.

Wie und Wo muss ich jetzt die Variablen implementieren !

Über Graphics und dann "drawString" funktioniert das nicht

Hoffe ihr könnt mir Helfen
(mal wieder ^^)

danke natürlich, wie immer im voraus !

MFG
Benni

 

[hdi]

Die Variable sollte Member-Variable deines Threads sein, der die while-Schleife
abläuft und diese Variable ändert.
Dann noch einen schönen getter dafür und schon kannst du diese Info wo auch
immer (TunnPanel nehm ich an) auslesen, und jawohl mit g.drawString geht das sehr wohl.

Falls doch nicht, poste mal Code.

 

[death90]

Hallo,

@hdi:

Habs mal probiert, will aber nicht so richtig !

Hier mal der Code der System.java (früher TunnelPanel.java):

[HIGHLIGHT="Java"]package rocketgame;

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

import javax.swing.*;

public class System extends JPanel
{
private static final long serialVersionUID = 1L;

protected float tunnel_radius = 0;
protected float tunnel_diameter = 0;

/** diese Variable speichert den Center des vorderen Kreises (den grünen).
Diese Variable wird nach der Mausbewegung angepasst. */
protected Point2D.Float tunnel_front_center = new Point2D.Float(0f, 0f);

/** der graue Kreis */
protected MovementCircle movement_circle = null;

/** Eine Liste mit allen verfügbaren Barrieren */
protected ArrayList<AbstractBarrier> barrier_list = null;
/** die aktuell angezeigte Barriere */
protected AbstractBarrier current_barrier = null;

/** die Positionen der Seitenlinien auf dem Vorderkreis (den grünen) */
protected float [] tinnel_side_positions = {
360f*(1.0f/6.0f),
360f*(2.0f/6.0f),
360f*(3.0f/6.0f),
360f*(4.0f/6.0f),
360f*(5.0f/6.0f),
360f*(6.0f/6.0f)
};

protected Thread thread = null;
protected TunnelRunner tunnel_runner = null;

protected boolean help_graphics_enabled = false;

public System(float tunnel_radius)
{
super(null);

this.tunnel_radius = tunnel_radius;
this.tunnel_diameter = tunnel_radius*2;

this.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
this.addMouseMotionListener(new MouseController());

movement_circle = new MovementCircle();

barrier_list = new ArrayList<AbstractBarrier>();
barrier_list.add(new BigHoleBarrier());
barrier_list.add(new RectangleHoleBarrier());

// hier wird eine Barriere als aktive (die sichtbar ist) ausgewählt
current_barrier = barrier_list.get(0);
}

public boolean isHelpGraphicsEnabled()
{
return help_graphics_enabled;
}

public void setHelpGraphicsEnabled(boolean enabled)
{
this.help_graphics_enabled = enabled;
}

////////////////////////////////////////////////////////////////////////
// Paint
@Override
public void paintComponent(Graphics g)
{
super.paintComponent(g);

Dimension size = getSize();
Graphics2D g2 = (Graphics2D)g;

g2.setBackground(Color.white);
g2.clearRect(0, 0, size.width, size.height);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.translate(size.width/2, size.height/2);

paintTunnelSideLines(g2, Color.black);
paintBarrier(g2, movement_circle);
paintBarrier(g2, current_barrier);

if(help_graphics_enabled)
paintHelpGraphics(g2);
}


protected void paintSpeed(Graphics g2)
{
g2.setColor(Color.black);
g2.drawString("Speed "+getTimedraw(td), -390, -370);
}


// die nächsten zwei Funktionen zeichnen die Seitenlinien

protected void paintTunnelSideLines(Graphics2D g2, Color color)
{
g2.setColor(Color.black);
paintTunnelSideLine(g2, 0);
paintTunnelSideLine(g2, 1);
paintTunnelSideLine(g2, 2);
paintTunnelSideLine(g2, 3);
paintTunnelSideLine(g2, 4);
paintTunnelSideLine(g2, 5);
}

protected void paintTunnelSideLine(Graphics2D g2,
int side_line_index)
{
Point2D.Float poc = getPointOnCircle(tunnel_front_center,
tunnel_radius,
tinnel_side_positions[side_line_index]);

Line2D.Float base_line = new Line2D.Float(0f, 0f, poc.x, poc.y);

Point2D.Float tp1 = getPointOnLine(base_line, 0.02f);
Point2D.Float tp2 = getPointOnLine(base_line, 0.02f);

Path2D.Float path = new Path2D.Float();
path.moveTo(tp1.x, tp1.y);
path.lineTo(poc.x+tp2.y, poc.y-tp2.x);
path.lineTo(poc.x-tp2.y, poc.y+tp2.x);
path.closePath();

g2.fill(path);
}

// die nächste Funktion zeichnet eine Barriere

protected void paintBarrier(Graphics2D g2, AbstractBarrier barrier)
{
barrier.updateBarrierShapes();

if(barrier instanceof MovementCircle)
{
g2.setColor(Color.gray);
g2.draw(barrier.front);
}
else
{
g2.setColor(new Color(235, 235, 235));
g2.fill(barrier.back);
g2.setColor(Color.black);
g2.draw(barrier.back);

g2.setColor(Color.white);
g2.fill(barrier.front);
g2.setColor(Color.black);
g2.draw(barrier.front);
}
}

// die nächste Funktion zeichnet die Hilfsgrafiken

protected void paintHelpGraphics(Graphics2D g2)
{
g2.setColor(Color.green);
g2.drawOval((int)(-tunnel_radius+tunnel_front_center.x),
(int)(-tunnel_radius+tunnel_front_center.y),
(int)tunnel_diameter,
(int)tunnel_diameter);

g2.setColor(Color.blue);
g2.drawLine(0, 0, (int)tunnel_front_center.x,
(int)tunnel_front_center.y);

g2.setColor(Color.red);
g2.drawLine(-10, 0, 10, 0);
g2.drawLine(0, -10, 0, 10);
}


// Paint END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Animation & Interactivity

public synchronized void startAnimation()
{
if(thread == null)
{
tunnel_runner = new TunnelRunner();
thread = new Thread(tunnel_runner);
thread.start();
}
}

public synchronized void stopAnimation()
{
if(thread != null)
{
tunnel_runner.loop = false;
thread = null;
}
}

protected class TunnelRunner implements Runnable
{
protected boolean loop = true;
protected float Time = (float) 0.000;
protected float Timedraw = 100;
@Override
public void run()
{
// In dieser Schleife werden die Positionen und die Geschwindigkeiten
// der aktiven Elemente (Barriere, Seitenlinien) angepasst
while(loop)
{
if(Time<2)
Time=(float) (Time+0.001f);
if(Timedraw<200)
Timedraw=Timedraw+(Time*100);

// das ist der graue Kreis, der sich asymetrisch zu den Barieren bewegt
// und so ein Gefühl für Bewegung und Geschwindigkeit gibt
movement_circle.barrier_pos = (movement_circle.barrier_pos+0.0042f*(Time+movement_circle.barrier_pos*3.0f)) % 1f;

// hier wird die Position und die Geschwindigkeit eine Barriere angepasst
current_barrier.barrier_pos = (current_barrier.barrier_pos+0.0065f*(Time+current_barrier.barrier_pos*2.0f)) % 1f;

// die Seitenlinienpositionen auf dem Vorderkreis (den grünen) verschieben,
// um den Rotationseffekt zu erzeugen
float side_rotation_speed = 0.5f;
for(int i = 0; i < tinnel_side_positions.length; i++)
tinnel_side_positions = (tinnel_side_positions + side_rotation_speed) % 360f;

repaint();

try { Thread.sleep(15); }
catch(InterruptedException e) { loop = false; e.printStackTrace(); }
}
}

public void getTimedraw(float td){
td=Timedraw;
return;
}

private String toString(float f) {
// TODO Auto-generated method stub
return null;
}
}

protected class MouseController extends MouseAdapter
{
@Override
public void mouseMoved(MouseEvent e)
{
super.mouseMoved(e);

Dimension size = getSize();

// tunnel_center.setLocation(e.getX() - size.width/2, e.getY() - size.height/2);
tunnel_front_center.setLocation(-(e.getX() - size.width/2), -(e.getY() - size.height/2));

repaint();
}
}

// Animation & Interactivity END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Barriers

protected abstract class AbstractBarrier
{
/** Form, welche die Vorderseite eine Barriere darstellt */
protected Shape front = null;
/** Form, welche die Hinterseite eine Barriere darstellt */
protected Shape back = null;

/** Position im Tunnel zwischen 0f (Hinten) und 1f (Vorne).
Kann man auch als Tiefe ansehen */
protected float barrier_pos = 0.5f;

protected abstract void updateBarrierShapes();
}

protected class MovementCircle extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

float barrier_radius = barrier_pos*tunnel_radius;

front = new Ellipse2D.Float(-barrier_radius+pit.x, -barrier_radius+pit.y,
barrier_radius*2, barrier_radius*2);
}
}

protected class BigHoleBarrier extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

// Vorderform für die Barriere aufbauen

float barrier_radius = (barrier_pos*tunnel_radius);
float barrier_diameter = barrier_radius*2;
float hole_radius = barrier_radius*0.9f;
float hole_diameter = hole_radius*2;

Ellipse2D.Float barrier_base = null;
Ellipse2D.Float barrier_hole = null;
Area area = null;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Ellipse2D.Float(-hole_radius+pit.x,
-hole_radius+pit.y,
hole_diameter,
hole_diameter);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.front = area;

// Hinterform für die Barriere aufbauen

barrier_radius = barrier_radius*0.96f;
barrier_diameter = barrier_radius*2;
hole_radius = barrier_radius*0.9f;
hole_diameter = hole_radius*2;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Ellipse2D.Float(-hole_radius+pit.x,
-hole_radius+pit.y,
hole_diameter,
hole_diameter);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.back = area;
}
}

protected class RectangleHoleBarrier extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

// Vorderform für die Barriere aufbauen

float barrier_radius = (barrier_pos*tunnel_radius);
float barrier_diameter = barrier_radius*2;
float hole_width = barrier_radius*0.7f;
float hole_height = barrier_radius*0.2f;

Ellipse2D.Float barrier_base = null;
Rectangle2D.Float barrier_hole = null;
Area area = null;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Rectangle2D.Float(-hole_width+pit.x,
-hole_height+pit.y,
hole_width*2,
hole_height*2);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.front = area;

// Hinterform für die Barriere aufbauen

barrier_radius = barrier_radius*0.96f;
barrier_diameter = barrier_radius*2;
hole_width = barrier_radius*0.7f;
hole_height = barrier_radius*0.2f;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Rectangle2D.Float(-hole_width+pit.x,
-hole_height+pit.y,
hole_width*2,
hole_height*2);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.back = area;
}
}

// Barriers END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Geometric Help Functions

protected static Point2D.Float getPointOnCircle(Point2D.Float center,
float radius, float angle)
{
return getPointOnCircle(center.x, center.y, radius, angle);
}

protected static Point2D.Float getPointOnCircle(float x, float y,
float radius, float angle)
{
return new Point2D.Float(x + (float)(radius*Math.cos(Math.toRadians(angle))),
y + (float)(radius*Math.sin(Math.toRadians(angle))));
}

public static Point2D.Float getPointOnLine(Line2D.Float line,
float t)
{
return getPointOnLine(line.x1, line.y1, line.x2, line.y2, t);
}

public static Point2D.Float getPointOnLine(float x1, float y1,
float x2, float y2,
float t)
{
return new Point2D.Float((x2 - x1)*t + x1,
(y2 - y1)*t + y1);
}

// Geometric Help Functions END
////////////////////////////////////////////////////////////////////////
}[/HIGHLIGHT]

Hoffe du findest was !

danke schonmal für die Antwort bzw. Hilfe !

MFG
Benni

 

[hdi]

JA die paintSpeed() musst du schon irgendwo aufrufen.
In der paintComponent oder sonstwo, wo du das Graphics-Objekt zur Verfügung hast.

 

[death90]

Hallo,

ich habe meine paintSpeed methode in der paintComponent nun aufgerufen,
aber irgendwie haut meine getter methode nicht hin !

Er kann irgendwie die variable Timedraw, die ein float ist nicht in dem String
verarbeiten bzw. abrufen !

...habe die methode in die while-schleife integriert, die sich in der Klasse TunnelRunner befindet... hmmm bin nun ein wenig ratlos !???:L

Hier nun nochmal der etwas veränderte Code:

[HIGHLIGHT="Java"]package rocketgame;

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

import javax.swing.*;

public class System extends JPanel
{
private static final long serialVersionUID = 1L;

protected float tunnel_radius = 0;
protected float tunnel_diameter = 0;

/** diese Variable speichert den Center des vorderen Kreises (den grünen).
Diese Variable wird nach der Mausbewegung angepasst. */
protected Point2D.Float tunnel_front_center = new Point2D.Float(0f, 0f);

/** der graue Kreis */
protected MovementCircle movement_circle = null;

/** Eine Liste mit allen verfügbaren Barrieren */
protected ArrayList<AbstractBarrier> barrier_list = null;
/** die aktuell angezeigte Barriere */
protected AbstractBarrier current_barrier = null;

/** die Positionen der Seitenlinien auf dem Vorderkreis (den grünen) */
protected float [] tinnel_side_positions = {
360f*(1.0f/6.0f),
360f*(2.0f/6.0f),
360f*(3.0f/6.0f),
360f*(4.0f/6.0f),
360f*(5.0f/6.0f),
360f*(6.0f/6.0f)
};

protected Thread thread = null;
protected TunnelRunner tunnel_runner = null;

protected boolean help_graphics_enabled = false;

public System(float tunnel_radius)
{
super(null);

this.tunnel_radius = tunnel_radius;
this.tunnel_diameter = tunnel_radius*2;

this.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
this.addMouseMotionListener(new MouseController());

movement_circle = new MovementCircle();

barrier_list = new ArrayList<AbstractBarrier>();
barrier_list.add(new BigHoleBarrier());
barrier_list.add(new RectangleHoleBarrier());

// hier wird eine Barriere als aktive (die sichtbar ist) ausgewählt
current_barrier = barrier_list.get(0);
}

public boolean isHelpGraphicsEnabled()
{
return help_graphics_enabled;
}

public void setHelpGraphicsEnabled(boolean enabled)
{
this.help_graphics_enabled = enabled;
}

////////////////////////////////////////////////////////////////////////
// Paint
public void paintComponent(Graphics g)
{
super.paintComponent(g);

Dimension size = getSize();
Graphics2D g2 = (Graphics2D)g;

g2.setBackground(Color.white);
g2.clearRect(0, 0, size.width, size.height);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.translate(size.width/2, size.height/2);

paintTunnelSideLines(g2, Color.black);
paintBarrier(g2, movement_circle);
paintBarrier(g2, current_barrier);
paintSpeed(g2);

if(help_graphics_enabled)
paintHelpGraphics(g2);
}


protected void paintSpeed(Graphics g2)
{
g2.setColor(Color.black);
g2.drawString("Speed ", -390, -370);
}


// die nächsten zwei Funktionen zeichnen die Seitenlinien

protected void paintTunnelSideLines(Graphics2D g2, Color color)
{
g2.setColor(Color.black);
paintTunnelSideLine(g2, 0);
paintTunnelSideLine(g2, 1);
paintTunnelSideLine(g2, 2);
paintTunnelSideLine(g2, 3);
paintTunnelSideLine(g2, 4);
paintTunnelSideLine(g2, 5);
}

protected void paintTunnelSideLine(Graphics2D g2,
int side_line_index)
{
Point2D.Float poc = getPointOnCircle(tunnel_front_center,
tunnel_radius,
tinnel_side_positions[side_line_index]);

Line2D.Float base_line = new Line2D.Float(0f, 0f, poc.x, poc.y);

Point2D.Float tp1 = getPointOnLine(base_line, 0.02f);
Point2D.Float tp2 = getPointOnLine(base_line, 0.02f);

Path2D.Float path = new Path2D.Float();
path.moveTo(tp1.x, tp1.y);
path.lineTo(poc.x+tp2.y, poc.y-tp2.x);
path.lineTo(poc.x-tp2.y, poc.y+tp2.x);
path.closePath();

g2.fill(path);
}

// die nächste Funktion zeichnet eine Barriere

protected void paintBarrier(Graphics2D g2, AbstractBarrier barrier)
{
barrier.updateBarrierShapes();

if(barrier instanceof MovementCircle)
{
g2.setColor(Color.gray);
g2.draw(barrier.front);
}
else
{
g2.setColor(new Color(235, 235, 235));
g2.fill(barrier.back);
g2.setColor(Color.black);
g2.draw(barrier.back);

g2.setColor(Color.white);
g2.fill(barrier.front);
g2.setColor(Color.black);
g2.draw(barrier.front);
}
}

// die nächste Funktion zeichnet die Hilfsgrafiken

protected void paintHelpGraphics(Graphics2D g2)
{
g2.setColor(Color.green);
g2.drawOval((int)(-tunnel_radius+tunnel_front_center.x),
(int)(-tunnel_radius+tunnel_front_center.y),
(int)tunnel_diameter,
(int)tunnel_diameter);

g2.setColor(Color.blue);
g2.drawLine(0, 0, (int)tunnel_front_center.x,
(int)tunnel_front_center.y);

g2.setColor(Color.red);
g2.drawLine(-10, 0, 10, 0);
g2.drawLine(0, -10, 0, 10);
}


// Paint END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Animation & Interactivity

public synchronized void startAnimation()
{
if(thread == null)
{
tunnel_runner = new TunnelRunner();
thread = new Thread(tunnel_runner);
thread.start();
}
}

public synchronized void stopAnimation()
{
if(thread != null)
{
tunnel_runner.loop = false;
thread = null;
}
}

protected class TunnelRunner implements Runnable
{
protected boolean loop = true;
protected float Time = (float) 0.000;
protected float Timedraw = 100;
@Override
public void run()
{
// In dieser Schleife werden die Positionen und die Geschwindigkeiten
// der aktiven Elemente (Barriere, Seitenlinien) angepasst
while(loop)
{
if(Time<2)
Time=(float) (Time+0.001f);
if(Timedraw<200)
Timedraw=Timedraw+(Time*100);

// das ist der graue Kreis, der sich asymetrisch zu den Barieren bewegt
// und so ein Gefühl für Bewegung und Geschwindigkeit gibt
movement_circle.barrier_pos = (movement_circle.barrier_pos+0.0042f*(Time+movement_circle.barrier_pos*3.0f)) % 1f;

// hier wird die Position und die Geschwindigkeit eine Barriere angepasst
current_barrier.barrier_pos = (current_barrier.barrier_pos+0.0065f*(Time+current_barrier.barrier_pos*2.0f)) % 1f;

// die Seitenlinienpositionen auf dem Vorderkreis (den grünen) verschieben,
// um den Rotationseffekt zu erzeugen
float side_rotation_speed = 0.5f;
for(int i = 0; i < tinnel_side_positions.length; i++)
tinnel_side_positions = (tinnel_side_positions + side_rotation_speed) % 360f;

repaint();

try { Thread.sleep(15); }
catch(InterruptedException e) { loop = false; e.printStackTrace(); }
}
}

public float getTimedraw(float td){
td=Timedraw;
return td;
}

}

protected class MouseController extends MouseAdapter
{
@Override
public void mouseMoved(MouseEvent e)
{
super.mouseMoved(e);

Dimension size = getSize();

// tunnel_center.setLocation(e.getX() - size.width/2, e.getY() - size.height/2);
tunnel_front_center.setLocation(-(e.getX() - size.width/2), -(e.getY() - size.height/2));

repaint();
}
}

// Animation & Interactivity END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Barriers

protected abstract class AbstractBarrier
{
/** Form, welche die Vorderseite eine Barriere darstellt */
protected Shape front = null;
/** Form, welche die Hinterseite eine Barriere darstellt */
protected Shape back = null;

/** Position im Tunnel zwischen 0f (Hinten) und 1f (Vorne).
Kann man auch als Tiefe ansehen */
protected float barrier_pos = 0.5f;

protected abstract void updateBarrierShapes();
}

protected class MovementCircle extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

float barrier_radius = barrier_pos*tunnel_radius;

front = new Ellipse2D.Float(-barrier_radius+pit.x, -barrier_radius+pit.y,
barrier_radius*2, barrier_radius*2);
}
}

protected class BigHoleBarrier extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

// Vorderform für die Barriere aufbauen

float barrier_radius = (barrier_pos*tunnel_radius);
float barrier_diameter = barrier_radius*2;
float hole_radius = barrier_radius*0.9f;
float hole_diameter = hole_radius*2;

Ellipse2D.Float barrier_base = null;
Ellipse2D.Float barrier_hole = null;
Area area = null;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Ellipse2D.Float(-hole_radius+pit.x,
-hole_radius+pit.y,
hole_diameter,
hole_diameter);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.front = area;

// Hinterform für die Barriere aufbauen

barrier_radius = barrier_radius*0.96f;
barrier_diameter = barrier_radius*2;
hole_radius = barrier_radius*0.9f;
hole_diameter = hole_radius*2;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Ellipse2D.Float(-hole_radius+pit.x,
-hole_radius+pit.y,
hole_diameter,
hole_diameter);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.back = area;
}
}

protected class RectangleHoleBarrier extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

// Vorderform für die Barriere aufbauen

float barrier_radius = (barrier_pos*tunnel_radius);
float barrier_diameter = barrier_radius*2;
float hole_width = barrier_radius*0.7f;
float hole_height = barrier_radius*0.2f;

Ellipse2D.Float barrier_base = null;
Rectangle2D.Float barrier_hole = null;
Area area = null;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Rectangle2D.Float(-hole_width+pit.x,
-hole_height+pit.y,
hole_width*2,
hole_height*2);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.front = area;

// Hinterform für die Barriere aufbauen

barrier_radius = barrier_radius*0.96f;
barrier_diameter = barrier_radius*2;
hole_width = barrier_radius*0.7f;
hole_height = barrier_radius*0.2f;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Rectangle2D.Float(-hole_width+pit.x,
-hole_height+pit.y,
hole_width*2,
hole_height*2);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.back = area;
}
}

// Barriers END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Geometric Help Functions

protected static Point2D.Float getPointOnCircle(Point2D.Float center,
float radius, float angle)
{
return getPointOnCircle(center.x, center.y, radius, angle);
}

protected static Point2D.Float getPointOnCircle(float x, float y,
float radius, float angle)
{
return new Point2D.Float(x + (float)(radius*Math.cos(Math.toRadians(angle))),
y + (float)(radius*Math.sin(Math.toRadians(angle))));
}

public static Point2D.Float getPointOnLine(Line2D.Float line,
float t)
{
return getPointOnLine(line.x1, line.y1, line.x2, line.y2, t);
}

public static Point2D.Float getPointOnLine(float x1, float y1,
float x2, float y2,
float t)
{
return new Point2D.Float((x2 - x1)*t + x1,
(y2 - y1)*t + y1);
}

// Geometric Help Functions END
////////////////////////////////////////////////////////////////////////
}[/HIGHLIGHT]

So hoffe du kannst mir das nochmal erklären bzw. sagen, wo ichs lieber einfügen sollte !

Naja danke schonmal...

MFG
Benni

 

[slawaweis]

@death90
erstens, es ist eine ziemlich dumme Idee eine Klasse "System" und eine Variable "Time" zu nennen. Diese Namen werden schon im Kern-API für ziemlich prominente Klassen verwenden. Wie willst Du jetzt System.out.println() schreiben? Variablennamen solle man außerdem klein schreiben, also "time" und "timedraw".

Die Variablen "Time" "Timedraw" können auch in der Hauptklasse definiert werden und nicht erst im TunnelRunner. Bei mehreren Threads ist nur wichtig zu beachten, welcher Thread welche Variable nur liest und welcher diese liest und schreibt. Falls Du die Variablen doch im TunnelRunner haben willst, musst Du über die Variable tunnel_runner darauf zugreifen, aber am Prinzip ändert es nichts.

Das Du paintSpeed erstellt hast, ist schon ein guter Weg, es sollte aber schon ein Graphics2D als Parameter bekommen. Weiterhin ist es nicht nötig, den Speed mit Minuskoordinaten auf den Bildschirm zu malen. Dazu sollte man sich ein zusätzliches Graphics2D Objekt machen:

[HIGHLIGHT="Java"]
public void paintComponent(Graphics g)
{
super.paintComponent(g);

Dimension size = getSize();
Graphics2D g2 = (Graphics2D)g;

// zwei Graphics2D Objekte für verschiedene Arten der Darstellung

// ein Graphics2D für das Interface, beginnt oben links
Graphics2D g2_interface = (Graphics2D)g2.create();
// ein Graphics2D für den Tunnel, beginnt in der mitte des Bildschirms
Graphics2D g2_tunnel = (Graphics2D)g2.create();

g2_tunnel.setBackground(Color.white);
g2_tunnel.clearRect(0, 0, size.width, size.height);
g2_tunnel.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2_tunnel.translate(size.width/2, size.height/2);

g2_interface.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

paintTunnelSideLines(g2_tunnel, Color.black);
paintBarrier(g2_tunnel, movement_circle);
paintBarrier(g2_tunnel, current_barrier);

if(help_graphics_enabled)
paintHelpGraphics(g2_tunnel);

paintSpeed(g2_interface);
}


protected void paintSpeed(Graphics2D g2)
{
g2.setColor(Color.black);
g2.drawString("Speed ", 20, 20);
}
[/HIGHLIGHT]

Slawa

 

[hdi]

ein Getter ist per Definition parameterlos und führt keine Seiteneffekt aus.
D.h. das muss so aussehen:

[HIGHLIGHT="Java"]public float getTimedraw(){
return this.Timedraw // Variablen schreibt man übrigens klein
}[/HIGHLIGHT]

und:

[HIGHLIGHT="Java"]paintSpeed(Graphics g){
g.drawString("Speed: " + deinTunnelObjekt.getTimedraw() + " %",5,5);
}[/HIGHLIGHT]

 

[death90]

Hallo,

ich meld mich mal wieder !

habe es mittlerweile hinbekommen, dass Zeit und Geschwindigkeit angezeigt werden !

Nun gibt es noch 3 Dinge die ich machen muss:
1. ca. 3 versch. Barrieren erstellen, die sich eventuell mit drehen (nur wie ? polygon-objekt ?)
2. Kollisionsabfrage (stopAnimation, wenn kollision =true,. oder so, bloß wie soll die aussehen ? )
3. das zeichnen von 2 Barrieren während des Gameloops in einem bestimmten abstand, so dass nicht immer erst eine neue erscheint, wenn die erste schon vorbei ist !

ich stell mir vor das das erstellen dieser Barrieren das schwerste ist oder ?

Naja ich hoffe auf tatkräftige unterstützung, da morgen schon eine erste Generalprobe des Spiels erfolgt

vielen Dank schonmal im Vorraus !

MFG
Benni

 

[g0d3x]

Hey hab auch solche Probleme

 

[death90]

Hallo,

niemand da der mir helfen kann ??

;(

MFG
Benni

 

[hdi]

Dass das Einbauen von Hindernissen grad erst die Schwierigkeit an dem Game ist,
war doch von Anfang an klar.
Damit hättest du auch anfangen sollen, bevor du den Schnickschnack drumrum machst.

...wie sieht denn deine Röhre im Moment aus? Java3D, oder per Mapping?
Oder sogar komplett 2d gespeichert?
Kann man sich darin schon bewegen?

 

[death90]

Hallo,

hab mal ne Jar-Datei im Anhang !
Die Bilddatei dazu muss in einen Ordner "images" !

So nunja, also wie ich weitere Barrieren erstelle wei0 ich schon, ich brauch nun noch
einen Zufallsgenerator, der per Zufall in der Game-Schleife die current_barrier ermittelt !

und denn brauche ich noch eine Kollisionsabfrage ! und evtl. noch eine Möglichkeit, dass diese Barrieren rotieren.

naja aber wie schon gesagt, das ist erstmal noch Schnickschnack !

PS: 2 Barrieren habe ich ja schon !

Hier nochmal der aktuelle Code zum Verständnis:

FallOfBall.java

[HIGHLIGHT="Java"]import java.awt.*;
import java.awt.event.*;
import javax.swing.*;



public class FallOfBall extends JPanel
{
private static final long serialVersionUID = 1L;

public static boolean run = false;

public static void main(String [] args)
{
new FallOfBall(800,800);
}
public FallOfBall(int w, int h){
this.setPreferredSize(new Dimension(800,800));
this.setBackground(Color.white);

JLabel label = new JLabel(new ImageIcon("images/logo.jpg"));
label.setSize(new Dimension(800,222));
label.add(this);
label.setLocation(0,0);

JLabel caption = new JLabel("Copyright © 2009 by H@ckz0r");
caption.setSize(new Dimension(800,50));
caption.setFont(new Font("Tw Cen MT",Font.PLAIN,18));
caption.add(this);
caption.setLocation(280, 700);


JButton but = new JButton();
but.setSize(new Dimension(794,40));
but.setBackground(Color.white);
but.setBorderPainted(true);
but.setRolloverEnabled(true);
but.setText(" Start ");
but.setFont(new Font("Tw Cen MT",Font.ITALIC,34));
but.setForeground(Color.black);
but.setLocation(0,400);

JFrame frame = new JFrame("Fall Of Ball - Pre-Alpha 0.12");
frame.setLocation(100,100);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(caption);
frame.add(but);
frame.add(label);
frame.add(this);
frame.setSize(new Dimension(800, 800));
frame.setResizable(false);
frame.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
frame.setVisible(true);

while(run==false){
but.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e){
run = true;
}
}
);
}


if(run==true) {

frame.remove(but);
frame.remove(label);
frame.remove(this);
frame.remove(caption);

final Function func = new Function(1100);
func.setHelpGraphicsEnabled(false);
frame.add(func);

frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e)
{
func.stopAnimation();
}
});


frame.setVisible(true);


SwingUtilities.invokeLater(new Runnable() {
@Override
public void run()
{
func.startAnimation();
}
});

}
}

}[/HIGHLIGHT]

und hier die Function.java

[HIGHLIGHT="Java"]package rocketgame;

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

import javax.swing.*;

public class Function extends JPanel
{
private static final long serialVersionUID = 1L;

protected float tunnel_radius = 0;
protected float tunnel_diameter = 0;

/** diese Variable speichert den Center des vorderen Kreises (den grünen).
Diese Variable wird nach der Mausbewegung angepasst. */
protected Point2D.Float tunnel_front_center = new Point2D.Float(0f, 0f);

/** der graue Kreis */
protected MovementCircle movement_circle = null;

/** Eine Liste mit allen verfügbaren Barrieren */
protected ArrayList<AbstractBarrier> barrier_list = null;
/** die aktuell angezeigte Barriere */
protected AbstractBarrier current_barrier = null;

/** die Positionen der Seitenlinien auf dem Vorderkreis (den grünen) */
protected float [] tinnel_side_positions = {
360f*(1.0f/6.0f),
360f*(2.0f/6.0f),
360f*(3.0f/6.0f),
360f*(4.0f/6.0f),
360f*(5.0f/6.0f),
360f*(6.0f/6.0f)
};

protected Thread thread = null;
protected TunnelRunner tunnel_runner = null;

protected boolean help_graphics_enabled = false;

public Function(float tunnel_radius)
{
super(null);

this.tunnel_radius = tunnel_radius;
this.tunnel_diameter = tunnel_radius*2;

this.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
this.addMouseMotionListener(new MouseController());

movement_circle = new MovementCircle();

barrier_list = new ArrayList<AbstractBarrier>();
barrier_list.add(new BigHoleBarrier());
barrier_list.add(new RectangleHoleBarrier());

// hier wird eine Barriere als aktive (die sichtbar ist) ausgewählt
current_barrier = barrier_list.get(0);
}

public boolean isHelpGraphicsEnabled()
{
return help_graphics_enabled;
}

public void setHelpGraphicsEnabled(boolean enabled)
{
this.help_graphics_enabled = enabled;
}

////////////////////////////////////////////////////////////////////////
// Paint
public void paintComponent(Graphics g)
{
super.paintComponent(g);

Dimension size = getSize();
Graphics2D g2 = (Graphics2D)g;

// zwei Graphics2D Objekte für verschiedene Arten der Darstellung

// ein Graphics2D für das Interface, beginnt oben links
Graphics2D g2_interface = (Graphics2D)g2.create();
// ein Graphics2D für den Tunnel, beginnt in der mitte des Bildschirms
Graphics2D g2_tunnel = (Graphics2D)g2.create();

g2_tunnel.setBackground(Color.white);
g2_tunnel.clearRect(0, 0, size.width, size.height);
g2_tunnel.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2_tunnel.translate(size.width/2, size.height/2);

g2_interface.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

paintTunnelSideLines(g2_tunnel, Color.black);
paintBarrier(g2_tunnel, movement_circle);
paintBarrier(g2_tunnel, current_barrier);

if(help_graphics_enabled)
paintHelpGraphics(g2_tunnel);

paintSpeed(g2_interface);
}


protected void paintSpeed(Graphics2D g2)
{
g2.setColor(Color.red);
g2.setFont(new Font("Tw Cen MT",Font.PLAIN,20));
g2.drawString("Speed: " + getspeed() + " %", 20, 20);
g2.drawString("Speed-Factor: " + getspeedfactor(), 20, 40);
g2.drawString("Zeit: " + gettimeM() + ":" + gettimeS(), 700, 20);
}


// die nächsten zwei Funktionen zeichnen die Seitenlinien

protected void paintTunnelSideLines(Graphics2D g2, Color color)
{
g2.setColor(Color.black);
paintTunnelSideLine(g2, 0);
paintTunnelSideLine(g2, 1);
paintTunnelSideLine(g2, 2);
paintTunnelSideLine(g2, 3);
paintTunnelSideLine(g2, 4);
paintTunnelSideLine(g2, 5);
}

protected void paintTunnelSideLine(Graphics2D g2,
int side_line_index)
{
Point2D.Float poc = getPointOnCircle(tunnel_front_center,
tunnel_radius,
tinnel_side_positions[side_line_index]);

Line2D.Float base_line = new Line2D.Float(0f, 0f, poc.x, poc.y);

Point2D.Float tp1 = getPointOnLine(base_line, 0.02f);
Point2D.Float tp2 = getPointOnLine(base_line, 0.02f);

Path2D.Float path = new Path2D.Float();
path.moveTo(tp1.x, tp1.y);
path.lineTo(poc.x+tp2.y, poc.y-tp2.x);
path.lineTo(poc.x-tp2.y, poc.y+tp2.x);
path.closePath();

g2.fill(path);
}

// die nächste Funktion zeichnet eine Barriere

protected void paintBarrier(Graphics2D g2, AbstractBarrier barrier)
{
barrier.updateBarrierShapes();

if(barrier instanceof MovementCircle)
{
g2.setColor(Color.gray);
g2.draw(barrier.front);
}
else
{
g2.setColor(new Color(235, 235, 235));
g2.fill(barrier.back);
g2.setColor(Color.black);
g2.draw(barrier.back);

g2.setColor(Color.white);
g2.fill(barrier.front);
g2.setColor(Color.black);
g2.draw(barrier.front);
}
}

// die nächste Funktion zeichnet die Hilfsgrafiken

protected void paintHelpGraphics(Graphics2D g2)
{
g2.setColor(Color.green);
g2.drawOval((int)(-tunnel_radius+tunnel_front_center.x),
(int)(-tunnel_radius+tunnel_front_center.y),
(int)tunnel_diameter,
(int)tunnel_diameter);

g2.setColor(Color.blue);
g2.drawLine(0, 0, (int)tunnel_front_center.x,
(int)tunnel_front_center.y);

g2.setColor(Color.red);
g2.drawLine(-10, 0, 10, 0);
g2.drawLine(0, -10, 0, 10);
}


// Paint END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Animation & Interactivity
private float speedfactor = (float) 0.0000;
private double speed = 100;
public double speedfactorR;
public double speedR;
public int timeS;
public int timeM;
public double t;
public String string_timeM;
public double time_buffer;

public synchronized void startAnimation()
{
if(thread == null)
{
tunnel_runner = new TunnelRunner();
thread = new Thread(tunnel_runner);
thread.start();
}
}

public synchronized void stopAnimation()
{
if(thread != null)
{
tunnel_runner.loop = false;
thread = null;
}
}

protected class TunnelRunner implements Runnable
{
protected boolean loop = true;
@Override
public void run()
{
time_buffer=System.currentTimeMillis();

// In dieser Schleife werden die Positionen und die Geschwindigkeiten
// der aktiven Elemente (Barriere, Seitenlinien) angepasst
while(loop)
{
if(speed<400.0)
{
speedfactor=(float)(speedfactor+0.0001*2);
speed=speed+(speedfactor/10);

speedfactorR=Math.round(speedfactor*100)/100.00;
speedR=Math.round(speed);
}

// das ist der graue Kreis, der sich asymetrisch zu den Barieren bewegt
// und so ein Gefühl für Bewegung und Geschwindigkeit gibt
movement_circle.barrier_pos = (movement_circle.barrier_pos+0.0042f*(speedfactor+movement_circle.barrier_pos*3.0f)) % 1f;

// hier wird die Position und die Geschwindigkeit eine Barriere angepasst
current_barrier.barrier_pos = (current_barrier.barrier_pos+0.0065f*(speedfactor+current_barrier.barrier_pos*2.0f)) % 1f;

// die Seitenlinienpositionen auf dem Vorderkreis (den grünen) verschieben,
// um den Rotationseffekt zu erzeugen
float side_rotation_speed = 0.2f;
for(int i = 0; i < tinnel_side_positions.length; i++)
tinnel_side_positions = (tinnel_side_positions + side_rotation_speed) % 360f;

if(timeS<60){
timeS=(int)Math.round(((System.currentTimeMillis()-time_buffer)/100)*100.0)/1000;
}
else{
timeM=timeM+1;
timeS=0;
time_buffer=System.currentTimeMillis();
}

repaint();

try { Thread.sleep(15); }
catch(InterruptedException e) { loop = false; e.printStackTrace(); }

if(current_barrier.barrier_pos==0.5){
for (int i=0; i<1;i++)
{
current_barrier =barrier_list.get((int) Math.floor(2*Math.random()));
System.out.println(current_barrier);
}
}
}
}

}


public double getspeed(){
return this.speedR;
}

public double getspeedfactor(){
return this.speedfactorR;
}

public int gettimeS(){
return this.timeS;
}
public int gettimeM(){
return this.timeM;
}


protected class MouseController extends MouseAdapter
{
@Override
public void mouseMoved(MouseEvent e)
{
super.mouseMoved(e);

Dimension size = getSize();

// tunnel_center.setLocation(e.getX() - size.width/2, e.getY() - size.height/2);
tunnel_front_center.setLocation(-(e.getX() - size.width/2), -(e.getY() - size.height/2));

repaint();
}
}

// Animation & Interactivity END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Barriers

protected abstract class AbstractBarrier
{
/** Form, welche die Vorderseite eine Barriere darstellt */
protected Shape front = null;
/** Form, welche die Hinterseite eine Barriere darstellt */
protected Shape back = null;

/** Position im Tunnel zwischen 0f (Hinten) und 1f (Vorne).
Kann man auch als Tiefe ansehen */
protected float barrier_pos = 0.5f;

protected abstract void updateBarrierShapes();
}

protected class MovementCircle extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

float barrier_radius = barrier_pos*tunnel_radius;

front = new Ellipse2D.Float(-barrier_radius+pit.x, -barrier_radius+pit.y,
barrier_radius*2, barrier_radius*2);
}
}

protected class BigHoleBarrier extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

// Vorderform für die Barriere aufbauen

float barrier_radius = (barrier_pos*tunnel_radius);
float barrier_diameter = barrier_radius*2;
float hole_radius = barrier_radius*0.9f;
float hole_diameter = hole_radius*2;

Ellipse2D.Float barrier_base = null;
Ellipse2D.Float barrier_hole = null;
Area area = null;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Ellipse2D.Float(-hole_radius+pit.x,
-hole_radius+pit.y,
hole_diameter,
hole_diameter);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.front = area;

// Hinterform für die Barriere aufbauen

barrier_radius = barrier_radius*0.96f;
barrier_diameter = barrier_radius*2;
hole_radius = barrier_radius*0.9f;
hole_diameter = hole_radius*2;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Ellipse2D.Float(-hole_radius+pit.x,
-hole_radius+pit.y,
hole_diameter,
hole_diameter);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.back = area;
}
}

protected class RectangleHoleBarrier extends AbstractBarrier
{
@Override
protected void updateBarrierShapes()
{
// 2D Postion im Tunnel anhand der Tiefe ermitteln
Point2D.Float pit = getPointOnLine(0, 0,
tunnel_front_center.x,
tunnel_front_center.y,
barrier_pos);

// Vorderform für die Barriere aufbauen

float barrier_radius = (barrier_pos*tunnel_radius);
float barrier_diameter = barrier_radius*2;
float hole_width = barrier_radius*0.7f;
float hole_height = barrier_radius*0.2f;

Ellipse2D.Float barrier_base = null;
Rectangle2D.Float barrier_hole = null;
Area area = null;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Rectangle2D.Float(-hole_width+pit.x,
-hole_height+pit.y,
hole_width*2,
hole_height*2);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.front = area;

// Hinterform für die Barriere aufbauen

barrier_radius = barrier_radius*0.96f;
barrier_diameter = barrier_radius*2;
hole_width = barrier_radius*0.7f;
hole_height = barrier_radius*0.2f;

barrier_base = new Ellipse2D.Float(-barrier_radius+pit.x,
-barrier_radius+pit.y,
barrier_diameter,
barrier_diameter);
barrier_hole = new Rectangle2D.Float(-hole_width+pit.x,
-hole_height+pit.y,
hole_width*2,
hole_height*2);

area = new Area(barrier_base);
area.subtract(new Area(barrier_hole));
this.back = area;
}
}

// Barriers END
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// Geometric Help Functions

protected static Point2D.Float getPointOnCircle(Point2D.Float center,
float radius, float angle)
{
return getPointOnCircle(center.x, center.y, radius, angle);
}

protected static Point2D.Float getPointOnCircle(float x, float y,
float radius, float angle)
{
return new Point2D.Float(x + (float)(radius*Math.cos(Math.toRadians(angle))),
y + (float)(radius*Math.sin(Math.toRadians(angle))));
}

public static Point2D.Float getPointOnLine(Line2D.Float line,
float t)
{
return getPointOnLine(line.x1, line.y1, line.x2, line.y2, t);
}

public static Point2D.Float getPointOnLine(float x1, float y1,
float x2, float y2,
float t)
{
return new Point2D.Float((x2 - x1)*t + x1,
(y2 - y1)*t + y1);
}

// Geometric Help Functions END
////////////////////////////////////////////////////////////////////////
}[/HIGHLIGHT]

Vielen Dank schonmal im vorraus !

PPS: Ich habe schon einen Zufallsgenerator drin, weiß aber nicht so recht wie bzw. eher wo ich ihn einbinden muss, damit er jeweils nur am Anfang der Röhre (wenn die Barrieren gezeichnet werden) die aktuelle Barriere abfragt !

MFG
Benni

 

[hdi]

Sieht ja schon mal ganz gut aus, aber eine Frage:
Kann es sein, dass deine Röhre viieeeeel zu weit in die Tiefe geht?
Und gleichzeitig die Geschwindigkeit etwas zu hoch ist?

Denn diese Zwischen-Dinger, die immermal wieder kommen, tauchen plötzlich
wie mit Lichtgeschwindigkeit aus dem nix auf, mitten in der Röhre, und sind auf
einmal wieder weg...

Dann noch etwas:
Vllt sieht es ja nur so aus aber ich hatte das Gefühl, ich konnte mit der Maus nicht
ganz an die Seiten der Röhre gehen, weil die Bewegung zu langsam war. D.h. meine Maus
war schon ausserhalb des Fenster bevor ich nach ganz rechts gehen konnte.
Hier sollte man vllt den Wert der Bewegung etwas erhöhen.

Und Barrieren... habe ich aber keine gesehen?
Hast du denn schon ein Klassen-Konzept für so eine Barriere?

PS: Nicht dass es so rüberkommt ich will das Spiel nur schlecht reden, ich wollte nur
sagen wie jetzt mein Eindruck war.

 

[death90]

Hallo,

ja einiges stimmt schon,..

aber wichtig wäre mir nun mal, wo ich den Zufallsgenerator hinsetze, damit er zu beginn jedes Durchlaufes, abfragt, welche Barriere er nehmen soll,...halt den Zufallsgenerator abfragt ?

und wie ich so eine Kollisionsabfrage schreiben kann !

danke schonmal

MFG
Benni

 

[hdi]

Was ich grad per Zufall in deinem Code gesehen habe:

[HIGHLIGHT="Java"]while(run==false){
but.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e){
run = true;
}
}
);[/HIGHLIGHT]

Du addest dem Button permanent einen ActionListener. D.h. du erstellst in der Sekunde
ca. 500 ActionListener-Klassen, implementierst sie, und addest sie zu dem Button, um
sie gleich danach wieder wegzuwerfen.

Lass mal die while-Schleife drumrum komplett weg! Es reicht, das einmal zu tun.

Um jetzt den Spielablauf zu steuern sollte der Klick auf den Button nicht den boolean
run auf true setzen, sondern einfach eine Methode aufrufen:

[HIGHLIGHT="Java"]
but.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e){
startGame();
}
});
[/HIGHLIGHT]

[HIGHLIGHT="Java"]private void startGame(){
// hier kommt alles rein was in deiner Version in dem Block
// zu (if run == true) steht
}[/HIGHLIGHT]

...diese Methode wird ja nicht aufgerufen, solange du nicht auf den Button drückst,
kein Grund das Programm in einer Endlosschleife mit "busy waiting" zu knechten.
Das ist ja noch schlimmer als Busy-Waiting, ich weiss ja nicht was so eine inner class
an Speicher frisst, bzw. wie aktiv der GC da ist.
Aber damit kannste denk ich (sehr) alte System glatt lahmlegen :toll:

Wegen den Barrieren: Die solltest du halt an enstprechender Stelle in deinen GameLoop
schreiben, also while(loop){... hier ...}

 

[slawaweis]

habe es mittlerweile hinbekommen, dass Zeit und Geschwindigkeit angezeigt werden !

gut gemacht.

Nun gibt es noch 3 Dinge die ich machen muss:
1. ca. 3 versch. Barrieren erstellen, die sich eventuell mit drehen (nur wie ? polygon-objekt ?)

um weitere Barrieren zu erstellen, musst Du von der Klasse AbstractBarrier ableiten und die Funktion updateBarrierShapes() implementieren. In dem Quelltext sind zwei Beispiele schon drin. Der Rest ist Java2D, Geometrie/Trigonometrie und boolesche Operationen, das hier zu erklären würde zu lange dauern. Schnapp Dir am besten ein Buch über Java2D.

Das Drehen ist nicht schwer, die Barrieren sind einfache Kreise. Dazu sollte die Klasse AbstractBarrier eine neue Variable bekommen, den Drehwinkel, analog zu "barrier_pos". Diese neue Variable wird dann zusammen mit barrier_pos verändert. Am Ende der updateBarrierShapes() Funktion von jeder Barriere muss man dann die "front" und "back" Formen mit AffineTransform um den Zentralenpunkt der Barriere "pit" drehen. Alternativ kann man auch eine Funktion in AbstractBarrier erstellen, welche es für alle Barrieren macht.

2. Kollisionsabfrage (stopAnimation, wenn kollision =true,. oder so, bloß wie soll die aussehen ? )

das habe ich eigentlich schon im meinen ersten Post mit dem Quelltext erwähnt. Der Spieler sitzt immer auf dem Punkt (0, 0), welcher mit dem roten Kreuz markiert ist, d.h. man muss nur die Kollision zwischen der Front der vordersten Barriere und dem (0, 0) Punkt berechnen, ungefähr so:

[highlight="java"]
if(current_barrier.front.contains(0, 0))
{
// Kollision
}
[/highlight]

3. das zeichnen von 2 Barrieren während des Gameloops in einem bestimmten abstand, so dass nicht immer erst eine neue erscheint, wenn die erste schon vorbei ist !

dazu muss Du eine zweite Liste anlegen. In barrier_list liegen alle möglichen Barrieren. Jetzt muss noch eine Liste "visible_barrier_list" her, die nur die aktuell sichtbaren Barrieren enthält, sagen wir mit der Anzahl N. Eigentlich ist es auch keine Liste, sondern eine Schlange, First-In-First-Out.

Nehmen wir jetzt an, wir haben N=5, also 5 gleichzeitig sichtbare (oder durch die Röhre laufenden) Barrieren. Diese werden mit einem gleichen Abstand zwischeneinander angeordnet. Die Tiefe beträgt immer 1.0f, d.h. die Barrieren laufen von 0.0f bis 1.0f. Deshalb müssen die Barrieren für N=5 mit 0.2f Abstand laufen. Zuerst wird die erste Barriere bei 0.0f eingefügt und läuft durch. Wenn diese 0.2f erreicht, wird die zweite eingefügt. So geht es bis zu fünften Barriere durch. Wenn dann die erste Barriere, die zuerst in die Schlange eingefügt wurde, 1.0f erreicht, wird diese aus der Schlange entfernt und hinten kommt eine neue rein. Zum Schluss muss man die Barrieren in umgekehrten Reihenfolge zeichnen, also die hinterste zuerst, die vorderste zuletzt.

ich stell mir vor das das erstellen dieser Barrieren das schwerste ist oder ?

würde ich nicht sagen.

Naja ich hoffe auf tatkräftige unterstützung, da morgen schon eine erste Generalprobe des Spiels erfolgt

dann viel Erfolg!

Slawa

 

[death90]

Hallo,

habe schon angefangen deine Lösungsvorschlage umzusetzten,...klappt schon ganz gut !

Meine Frage wäre nun noch wie ich den Zufallsgenerator vernünftig einfügen könnte ?
Hab schon einiges probiert, doch irgendwie funktioniert das nicht richtig
Der Generator soll ja lediglich zufällig eine Barriere auswählen !
(Barrier_list.get(Zufallsgenerator))

Hat da jemand ne Idee ?

danke schonmal

MFG
Benni

 

[hdi]

Generell kriegst du aus einer Liste von Objekten ein zufälliges so:

[HIGHLIGHT="Java"]Random ran = new Random();
Object randomObject = myListOfObjects.get(ran.nextInt(myListOfObjects.size()));[/HIGHLIGHT]

Aber Vorsicht: ran.nextInt(0) gibt einen Runtime-Error, also stell vorher sicher dass die Liste auch nicht leer ist.

 

[death90]

Hallo,

ich weiß ja wie ich den Zufallsgenerator hinbekomme, nur nicht wo ich ihn in
meinem Programm einbinde, da er immer nur zum Einsatz kommen soll, wenn die
Barrieren erneut durch die Röhre laufen.
Es soll quasi bei jedem Röhrendurchlauf eine zufällig gewählte Barriere gezeichnet werden!

Wenn ich den Zufallsgenerator einfach in die Hauptschleife einbinde, dann wählt er bei jedem schritt vorwärts in der Röhre eine neue Barriere, ist ja klar !

Nur wie bzw. wo kann ich sonst diesen Generator einbinden ?

Der code des Zufallsgenerators: Math.floor(3*Math.random());

Schonmal vielen Dank für Ideen

MFG
Benni

 

[hdi]

Nur weil etwas in einer Schleife steht, heisst das ja nicht gleich, dass es bei
jedem Schleifendurchlauf ausgeführt wird:

[HIGHLIGHT="Java"]while(true){
barriere.z--;
if(barriere.z < 0){
barriere = Generator.getRandomBarriere();
}
} [/HIGHLIGHT]

D.h. du lässt eine Barriere solange näher kommen / bewegst dich selbst darauf zu,
bis du halt vorbei bist (bzw die Barriere vorbei ist).
Dann machste ne neue...

 

[death90]

Hallo,

habe das mit der Position der Barrieren schon probiert !

Nur leider funktioniert das aus irgendeinem Grund nicht. Er ermittelt ab einer bestimmten
hinter dem sichtbaren Bereich per zufall eine neue Barriere, aber zeichnet diese noch
1-2 mal vor einem neuen Röhrendurchlauf und man sieht, das 2 mal eine Scheibe direkt vor der ich-Perspektive gezeichnet wird, bevor eine neue Runde startet !

Das funktioniert dann zwar mit dem Zufall, aber sieht beschissen aus !

Hat jemand eine Idee ? ( iehe weiter oben den Code zum verständnis )

vielen Dank mal wieder

MFG
Benni

 

[death90]

Hallo,

ich mal wieder ^^

Habs jezz etwas besser hinbekommen mit dem Zufallsgenerator !

Meine neue Frage ist nun, wie ich bei ner Barriere die position der Aussparung bzw. des Loches zum Rand hin veränder ?

Ich bekomm das irgendwie nich hin

! siehe Code weiter oben !

vielen Dank mal wieder

MFG
Benni

 

[death90]

Hallo,

schade das sich noch keiner gemeldet hat, aber ich habs jezz
mittlerweile hinbekommen ! :toll:

Nun noch eine letzte Frage:

Wie kann ich, wenn die Abbruchbedingung der Game-Schleife erfüllt ist und die Animation
gestoppt ist, einen transparenten roten Bildschirm zeichnen lassen, mit einem text in der Mitte ?

Es soll dabei das gesamte Frame rot transparent sein, so dass man durch das rot noch die gestoppte Animation sieht !

Wäre für Ideen und Lösungen sehr sehr dankbar

MFG
Benni

 

[hdi]

Dafür brauchst du doch nicht extra ein Frame erstellen.
Dein Spiel läuft ja wohl in einem JPanel. In dessen paintComponent-Methode
kannst du ja einbauen (als letzte Anweisung):

[HIGHLIGHT="Java"]if(gameover){
Color c = new Color(255,0,0,200) // der letzte Wert ist der alpha-Kanal -> transparenz
g.setColor(c);
g.fillRect(...);
g.setColor(Color.black);
g.drawString("Du hast leider verloren, oh wie schade usw usw",...);
}[/HIGHLIGHT]