Also, ein bißchen mit der Kristallkugel zusammengeratener Code… das wird so natürlich nicht funktionieren, aber … was soll man machen…
Man kann mit Slidern die Position und Bewegung des Eimers einstellen, und die Bewegung des Tropfens. Er gibt aus, ob der Tropfen gefangen wurde oder nicht. Wie man die benötigten Informationen in der render-Methode bokmmen KÖNNTE, ist in der auskommentierten Methode skizziert.
package bytewelt;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.geom.Rectangle2D;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
class Rectangle
{
float x;
float y;
float width;
float height;
}
public class DropCatcher
{
public static void main(String[] args)
{
SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run()
{
createAndShowGUI();
}
});
}
private static void createAndShowGUI()
{
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
final DropCatcherPanel dropCatcherPanel = new DropCatcherPanel();
dropCatcherPanel.setPreferredSize(new Dimension(600,600));
JPanel panel = new JPanel(new GridLayout(0,2));
panel.add(new JLabel("Bucket position"));
final JSlider bucketPositionSlider = new JSlider(-100, 100, 0);
bucketPositionSlider.addChangeListener(new ChangeListener()
{
@Override
public void stateChanged(ChangeEvent e)
{
dropCatcherPanel.setBucketPositionX(
260+bucketPositionSlider.getValue());
}
});
panel.add(bucketPositionSlider);
panel.add(new JLabel("Bucket movement"));
final JSlider bucketMovementSlider = new JSlider(-100, 100, 0);
bucketMovementSlider.addChangeListener(new ChangeListener()
{
@Override
public void stateChanged(ChangeEvent e)
{
dropCatcherPanel.setBucketMovementX(
bucketMovementSlider.getValue());
}
});
panel.add(bucketMovementSlider);
panel.add(new JLabel("Raindrop"));
final JSlider raindropMovementSlider = new JSlider(0, 100, 0);
raindropMovementSlider.addChangeListener(new ChangeListener()
{
@Override
public void stateChanged(ChangeEvent e)
{
dropCatcherPanel.setRaindropMovementY(
raindropMovementSlider.getValue());
}
});
panel.add(raindropMovementSlider);
f.getContentPane().setLayout(new BorderLayout());
f.getContentPane().add(panel, BorderLayout.NORTH);
f.getContentPane().add(dropCatcherPanel, BorderLayout.CENTER);
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
}
}
class DropCatcherPanel extends JPanel
{
private Rectangle bucket;
private Rectangle raindrop;
private float bucketMovementX;
private float raindropMovementY;
DropCatcherPanel()
{
bucket = new Rectangle();
bucket.x = 260;
bucket.y = 500;
bucket.width = 80;
bucket.height = 80;
raindrop = new Rectangle();
raindrop.x = 280;
raindrop.y = 400;
raindrop.width = 40;
raindrop.height = 40;
}
public void setBucketPositionX(float bucketPositionX)
{
bucket.x = bucketPositionX;
repaint();
}
void setBucketMovementX(float bucketMovementX)
{
this.bucketMovementX = bucketMovementX;
repaint();
}
void setRaindropMovementY(float raindropMovementY)
{
this.raindropMovementY = raindropMovementY;
repaint();
}
@Override
protected void paintComponent(Graphics gr)
{
super.paintComponent(gr);
Graphics2D g = (Graphics2D)gr;
g.setColor(Color.WHITE);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(new Color(128,128,128,128));
g.fill(new Rectangle2D.Double(
bucket.x, bucket.y, bucket.width, bucket.height));
g.setColor(new Color(128,128,128,64));
g.fill(new Rectangle2D.Double(
bucket.x+bucketMovementX, bucket.y, bucket.width, bucket.height));
g.setColor(new Color(0,0,255, 128));
g.fill(new Rectangle2D.Double(
raindrop.x, raindrop.y, raindrop.width, raindrop.height));
g.setColor(new Color(0,0,255,64));
g.fill(new Rectangle2D.Double(
raindrop.x, raindrop.y+raindropMovementY, raindrop.width, raindrop.height));
boolean wasCought =
raindropWasCought(
raindrop, raindropMovementY,
bucket, bucketMovementX);
g.setColor(Color.RED);
g.drawString("Was cought? "+wasCought, 20,40);
}
private boolean raindropWasCought(
Rectangle raindrop, float raindropMovementY,
Rectangle bucket, float bucketMovementX)
{
// Minimaler und maximaler x-Wert des Buckets
// VOR der Bewegung...
float bxMinOld = bucket.x;
float bxMaxOld = bucket.x + bucket.width;
// ...und NACH der Bewegung
float bxMinNew = bxMinOld + bucketMovementX;
float bxMaxNew = bxMaxOld + bucketMovementX;
// Oberkante des Buckets
float byMin = bucket.y;
// Minimaler und maximaler y-Wert des Drops
// VOR der Bewegung....
float dyMinOld = raindrop.y;
float dyMaxOld = raindrop.y + raindrop.height;
// ...und NACH der Bewegung
float dyMinNew = dyMinOld + raindropMovementY;
float dyMaxNew = dyMaxOld + raindropMovementY;
// Minimaler und maximaler x-Wert des Drops
float dxMin = raindrop.x;
float dxMax = raindrop.x + raindrop.width;
// Die eigentliche Abfrage: Der Tropfen gilt als "gefangen",
// wenn er vor und nach der Bewegung zwischen dem
// linken und dem rechten Rand des Buckets war, und
// NACH der Bewegung tiefer war als der obere Rand
// des Buckets.
// Er wurde NICHT gefangen, wenn er nach der Bewegung
// noch komplett oberhalb vom Bucket war.
if (dyMaxNew < byMin)
{
System.out.println(
"Lower border of drop is "+dyMaxNew+
", upper border of of bucket is "+byMin);
return false;
}
// Er wurde NICHT gefangen, wenn er vor oder
// nach der Bewegung komplett links oder
// komplett rechts vom Bucket war.
if (dxMax < bxMinOld)
{
System.out.println(
"Right border of drop is "+dxMax+
", left border of bucket before movement is "+bxMinOld);
return false;
}
if (dxMin > bxMaxOld)
{
System.out.println(
"Left border of drop is "+dxMin+
", right border of bucket before movement is "+bxMaxOld);
return false;
}
if (dxMax < bxMinNew)
{
System.out.println(
"Right border of drop is "+dxMax+
", left border of bucket after movement is "+bxMinNew);
return false;
}
if (dxMin > bxMaxNew)
{
System.out.println(
"Left border of drop is "+dxMin+
", right border of bucket after movement is "+bxMaxNew);
return false;
}
// Er wurde vermutlich auch nicht gefangen, wenn er
// vor oder nach der Bewegung des Buckets teilweise
// außerhalb des Buckets war
if (dxMin < bxMinOld)
{
System.out.println(
"Left border of drop is "+dxMin+
", left border of bucket before movement is "+bxMinOld);
return false;
}
if (dxMax > bxMaxOld)
{
System.out.println(
"Left border of drop is "+dxMax+
", right border of bucket before movement is "+bxMaxOld);
return false;
}
if (dxMin < bxMinNew)
{
System.out.println(
"Left border of drop is "+dxMin+
", left border of bucket after movement is "+bxMinOld);
return false;
}
if (dxMax > bxMaxNew)
{
System.out.println(
"Left border of drop is "+dxMax+
", right border of bucket after movement is "+bxMaxOld);
return false;
}
return true;
}
// void updateGameStateInRenderMethod()
// {
// int bucketMovementX = 0;
//
// // Berechne Bewegung des Eimers in X-richtung,
// // abhängig von touch und Tastendruck
// f (Gdx.input.isTouched())
// {
// this.touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
// this.camera.unproject(touchPos);
// bucketMovementX = touchPos.x - 64 / 2 - this.bucket.x;
// }
// if (Gdx.input.isKeyPressed(Keys.LEFT))
// {
// bucketMovementX = - 400 * Gdx.graphics.getDeltaTime();
// }
// if (Gdx.input.isKeyPressed(Keys.RIGHT))
// {
// bucketMovementX = 400 * Gdx.graphics.getDeltaTime();
// }
//
// //Regentropfen bewegen lassen, zerstören und entfernen
// Iterator<Rectangle> iter = this.raindrops.iterator();
// while (iter.hasNext())
// {
// Rectangle raindrop = iter.next();
//
// int raindropMovementY = -200 * Gdx.graphics.getDeltaTime();
//
// if (raindrop.y + 64 + raindropMovementY < 0)
// {
// iter.remove();
// // Tropfen wurde entfernt, gehe zurück
// // zum Schleifenanfang
// continue;
// }
//
// if (raindropWasCought(raindrop, raindropMovementY, bucket, bucketMovementX)
// {
// this.dropsGathered++;
// this.dropSound.play();
// iter.remove();
// // Tropfen wurde entfernt, gehe zurück
// // zum Schleifenanfang
// continue;
// }
//
// raindrop.y += raindropMovementY;
//
// }
//
// bucket.x += bucketMovementX;
//
//
// // Hier kommt dann vermutlich das eigentliche Zeichnen...
// // ...
//
// }
}
Man müßte wissen, wie die alte und neue Position gespeichert sind und verwendet werden, und wo genau dort die Kollisionsabfrage stattfindet, und was bei einer Kollision passiert (bzw. was passiert, wenn keine Kollision stattfand) etc.