Hallo,
ich habe mit folgender Codezeile versucht einen Vektor2D zu erzeugen:
Vektor2D vektor = new Vector2D(x, y);
Leider wird Vektor2D rot unterstrichen.
Fehlermeldung:
Vektor2d cannot be resolved to a type.
Ich verwende Slick2D.
Kurze Frage noch:
Bei Vector2f bedutet das “2f” -> to float.
Vector2D steht für to Double.
Wofür steht z.B. Vector4f??
Vector2f bedeutet es ist ein 2 dimensionaler Vektor des Typs floats.
Vector4f bedeutet damit es handelt sich um einen 4 dimensionalen Vektor des Typs floats.
Ein Vektor ist nichts anderes als ein Haufen Zahlen denen die Mathematik eine Bedeutung bei bestimmten Rechnungen beimisst.
Die Vektorklasse wird also in etwa einfach nur so aussehen:
class Vector2f {
private float x, y;
public Vector2f(float x, float y) {
this.x = x;
this.y = y;
}
public float getX() { return x; }
public float getY() { return y; }
}
und das war es.
Vielleicht noch ein paar spezielle Standard-Rechnungen für Vektoren.
Der Unterschied zwischen c und k ist geläufig?
Vector
Vektor
Java bringt ein Package für Vektoren mit. Die Implementierung ist mässig und würde man heute anders machen.
Slick2D bringt wie man auch hier sehen kann
eine eigene Implementierung mit, die man eben für Slick2D nutzen sollte.
Die 2 wird wohl für die Dimension stehen.
Das f für float.
Vector4d wird also für einen 4-Dimensionalen Vector stehen, bei dem die 4 Datenpunkte vom Typ Double sind.
Es geht darum, das ich diesen Code implementieren möchte:
Siehe Listing 6.7
Da in diesem Code Beispiel mit double Zahlen gerechnet wird, benötige ich einen Vektor der mit double zu recht kommt also kann ich nur einen Vector2D nehmen.
Im beispielcode wird ein einfacher Vector verwendet. Leider funktioniert dieser auch nicht bei mir, wird ebenfalls rot unterstrichen.
Was muss ich importieren, damit ich den Vector2D verwenden kann?
MfG
Das Buch bezieht sich auf dieses “Greenfoot”. Anscheinend hat da mal jemand eine Vektor-Klasse geschrieben, die in zig verschiedenen Variationen im Web rumgeistert. Man findet “die” mit sowas wie https://www.google.de/search?q=vector+“Poul+Henriksen”
Aber bevor du da jetzt irgendeine kopierst und damit die 1001. Version davon in die Welt setzt, solltest du vielleicht sagen (oder dir selbst klar werden), was du vorhast. Diese Gravitation willst du ja nicht “für sich” implementieren. Wenn du irgend eine Library verwendest, wie Slick, LWJGL oder sonstwas, ist da wahrscheinlich schon eine Vector-Klasse dabei. Notfalls vecmath oder JOML nehmen.
Ich kann das Buch unter dem Link nicht lesen (“Seitenbeschränkung anzeigbarer Seiten überschritten”), deshalb weiß ich nicht worum es geht.
Nach der Doku von Slick2D
Vector2f (Slick - The 2D Library)
gibt es eine Vector2f (mit c (!) geschrieben) Klasse im Package org.newdawn.slick.geom.Vector2f.
Eine Vector2D Klasse wird in der Slick2d Doc nicht gelistet. Ist auch nicht wichtig ob float oder double in einem Spiel, kommt aufs gleiche heraus. (Wenn sich darüber überhaupt jmd mal den Kopf zerbrechen musste.).
Meistens verwendet man float, weil es vollkommen ausreicht und weil der ganze andere Code auch float verwendet und damit die Präzision sowieso wieder flöten geht.
[ot]
Oh mann, bin ich blind - dass Slick verwendet wird steht im TITEL! Dann ist der Hinweis von TMII genau der richtige
[/ot]
[ot]aber erst seit gestern 23:52, gewiss hattest du ein Tab (bis 1:35) schon länger offen 
hinsichtlich Text freilich noch blinder 
[/ot]
Leider funktioniert mit Vektor2f diese Methode nicht: “setLength”.
Und addForce funktioniert auch nicht.
vektor.setLength(beschleunigung);
addForce(vektor);
Wie könnte ich das lösen?
MfG
setLength könnte man durch
vector.normalise();
vector.scale(beschleunigung);
emulieren. Und addForce einfach durch “add”.
“normalise” funktioniert nicht, aber scale wird schon mal nicht rot unterstrichen.
“addForce” durch “add” ersetzen funktioniert nicht, add wird rot unterstrichen.
Ihr habt ja gesagt, das double bei der Spiele programmierung nicht notwendig sei, float reiche völlig aus.
Wenn ich einen Vector mit float erzeuge, dann müssen alle variablen ebenfalls float sein.
Meine universelle Gravitationskonstante funktioniert mit dem Datentyp float leider nicht wird also rot unterstrichen,
da der Zahlenwert für float einfach zu lange ist:
“float gravity = 0.0000000000667250;”
Wert habe ich aus dem Internet.
Wie kann ich das problem mit “add” und dem zu langen gravity Wert lösen?
Danke für die Hilfe!!
MfG
Ist das Konzept von Packages und Imports in Java bekannt?
Welcher Vektor oder Vector wird denn jetzt überhaupt verwendet? Einfach mal mit ganzem Namen, samt package nennen.
rot unterstrichen ist eine Sache, die Fehlermeldung die es dazu gibt eine andere. In Eclipse einfach mal am Rand mit der Maus über das rote Kreuz fahren um mehr zu erfahren.
Naja den Vector hat er, aber es fehlt die Info welche Physics Engine verwendet wird, oder hat Slick2D eine integrierte?
Das Buch ist über Greenfoot - nach Google ein DragNDrop Java-Lernprogramm - aber was hat das mit Slick2d zu tun? Und was hat Slick2d mit einer Physics Engine zu tun?
Der Code aus dem Buch der sich auf Greenfoot bezieht, funktioniert nur mit der Greenfoot Library.
In was für einer IDE programmierst du denn und welche Bibliotheken verwendest du neben Slick2D noch?
Auf welchem Planeten und in welcher Einheit soll das sein? Physics Engines verwenden meist SI-Einheiten, auf der Erde entspricht das
float = 9.81; // in N/kg bzw. m/s^2
Es sei denn es handelt sich um irgendeinen Pixelwert Zeugs…
Dafür brauchen wir mehr Informationen.
https://de.wikipedia.org/wiki/Gravitationskonstante , ja, ist falsch, vermutlich sollte die Gravitation ein Vektor (0,-9.81) sein.
Ich programmiere in Eclipse. Wie ihr schon erfahren habt verwende ich Slick2D, da es viele Klassen und Methoden zur Spieleprogrammierung zur vefügung stellt die ich benötigt habe. Nun geht es einfach darum, das ich diesen Code in Java realisieren möchte. Ich benötige für meine Spiel eine realistische Gravitation. Mit diesem Code sollte es funktionieren. Zurzeit verwende ich nur Slick2D-Bibliotheken.
Hier der Fehlercode von: “add(vector);” => The method add(Vector2f) is undefined for the type (Hier der name meiner Klasse).
Wie kann ich die Gravitationskonstante: 6,67408e-11 in einer Variable abspeichern?
Die Methode “addForce”, die in dem verlinkten Buchkapitel verwendet wird, muss man selbst implementieren. Dort bezieht sie sich offenbar auf diese “SmoothMover”-Klasse, von der weiter oben schon die Rede war.
Die Gravitationskonstante:
private static final float GRAVITY = 6.67408e-11f;
Vir ein paar Jahren hatte ich da mal was gebastelt. Hat nur indirekt mit der Frage zu tun, ist aber hübsch anzuschauen.
package bytewelt;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
public class ThouHeartlessBitch
{
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);
f.setSize(600,600);
final ParticleSystem particleSystem = new ParticleSystem();
final ParticleSystemPanel particleSystemPanel = new ParticleSystemPanel(particleSystem);
Thread thread = new Thread(new Runnable()
{
@Override
public void run()
{
long previousNS = System.nanoTime();
while (true)
{
long currentNS = System.nanoTime();
double seconds = (currentNS - previousNS) / 1e9;
previousNS = currentNS;
particleSystem.doStep(seconds);
particleSystemPanel.repaint();
try
{
Thread.sleep(10);
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
return;
}
}
}
});
thread.setDaemon(true);
thread.start();
f.getContentPane().add(particleSystemPanel);
f.setVisible(true);
}
}
class ParticleSystemPanel extends JPanel
{
private final ParticleSystem particleSystem;
public ParticleSystemPanel(ParticleSystem particleSystem)
{
this.particleSystem = particleSystem;
}
@Override
protected void paintComponent(Graphics gr)
{
super.paintComponent(gr);
Graphics2D g = (Graphics2D)gr;
g.setColor(Color.RED);
for (Particle particle : particleSystem.getParticles())
{
Point2D position = particle.getPosition();
int x = (int)(position.getX()*getWidth());
int y = getHeight() - (int)(position.getY()*getHeight());
g.fillOval(x-5, y-5, 10, 10);
}
}
}
interface Force
{
Point2D computeAcceleration(Particle particle);
}
class Gravity implements Force
{
@Override
public Point2D computeAcceleration(Particle particle)
{
return new Point2D.Double(0, -9.81*0.1);
}
}
class ParticleSystem
{
private static final Random random = new Random(0);
private final List<Particle> particles;
private final List<Force> forces;
private double totalTime = 0;
public ParticleSystem()
{
particles = new CopyOnWriteArrayList<Particle>();
forces = new ArrayList<Force>();
forces.add(new Gravity());
}
public List<Particle> getParticles()
{
return Collections.unmodifiableList(particles);
}
public void doStep(double t)
{
removeOld();
emitNew();
updateAccelerations();
updateVelocities(t);
updatePositions(t);
totalTime += t;
//System.out.println("After "+totalTime+": "+particles);
}
private void removeOld()
{
List<Particle> toRemove = new ArrayList<Particle>();
for (Particle particle : particles)
{
Point2D position = particle.getPosition();
if (position.getY() < 0)
{
toRemove.add(particle);
}
}
particles.removeAll(toRemove);
}
private void emitNew()
{
List<Particle> toAdd = new ArrayList<Particle>();
for (int i=0; i<2; i++)
{
Particle particle = new Particle();
particle.setPosition(new Point2D.Double(0.5,0));
double vx = -0.5+random.nextDouble();
double vy = 1.5*random.nextDouble();
particle.setVelocity(new Point2D.Double(vx,vy));
toAdd.add(particle);
}
particles.addAll(toAdd);
}
private void updateAccelerations()
{
for (Particle particle : particles)
{
Point2D totalAcceleration = new Point2D.Double();
for (Force force : forces)
{
Point2D acceleration = force.computeAcceleration(particle);
addAssign(totalAcceleration, acceleration);
}
particle.setAcceleration(totalAcceleration);
//System.out.println("acc "+particle.getAcceleration());
}
}
private void updateVelocities(double t)
{
for (Particle particle : particles)
{
Point2D velocity = particle.getVelocity();
Point2D acceleration = particle.getAcceleration();
scaleAddAssign(velocity, t, acceleration);
particle.setVelocity(velocity);
//System.out.println("vel "+particle.getVelocity());
}
}
private void updatePositions(double t)
{
for (Particle particle : particles)
{
Point2D position = particle.getPosition();
Point2D velocity = particle.getVelocity();
scaleAddAssign(position, t, velocity);
particle.setPosition(position);
//System.out.println("pos "+particle.getPosition());
}
}
private static void addAssign(Point2D result, Point2D addend)
{
double x = result.getX() + addend.getX();
double y = result.getY() + addend.getY();
result.setLocation(x, y);
}
private static void scaleAddAssign(Point2D result, double factor, Point2D addend)
{
double x = result.getX() + factor * addend.getX();
double y = result.getY() + factor * addend.getY();
result.setLocation(x, y);
}
}
class Particle
{
private final Point2D position;
private final Point2D velocity;
private final Point2D acceleration;
private final double mass;
public Particle()
{
position = new Point2D.Double();
velocity = new Point2D.Double();
acceleration = new Point2D.Double();
mass = 1;
}
public Point2D getPosition()
{
return new Point2D.Double(position.getX(), position.getY());
}
public void setPosition(Point2D point)
{
position.setLocation(point);
}
public Point2D getVelocity()
{
return new Point2D.Double(velocity.getX(), velocity.getY());
}
public void setVelocity(Point2D point)
{
velocity.setLocation(point);
}
public Point2D getAcceleration()
{
return new Point2D.Double(acceleration.getX(), acceleration.getY());
}
public void setAcceleration(Point2D point)
{
acceleration.setLocation(point);
}
public double getMass()
{
return mass;
}
@Override
public String toString()
{
return String.format("Particle[p=(%.2f,%.2f),v=(%.2f,%.2f),a=(%.2f,%.2f)]",
position.getX(), position.getY(),
velocity.getY(), velocity.getY(),
acceleration.getX(), acceleration.getY());
}
}
Sieht hübsch aus!
[ot]
Hm???!??? Das hat damit nichts zu tun, da gibt’s keine Gravitation und nichts physikalisches. Das war nur eine Antwort auf eine Frage nach ~“Formeln für einfache Schwerkraft” in einem anderen Forum.
[/ot]
Der entscheidende Unterschied ist, dass es in DIESEM Thread schon um Gravitation im allgemeinen Sinn (abhängig von der Masse) geht. In dem Besipiel ist die Masse quasi als “Masse der Erde” vorgegeben (und die der Partikel ist vernachlässigbar). Deswegen kann man in dem Beispiel die Gravitationsbeschleunigung direkt als 9.81 m/s*s hartverdrahten, während genau diese Beschleunigung (d.h. eigentlich die Kraft) in diesem Thread ja (auf Basis der Gravitationskonstanten und der Massen) erst berechnet werden soll.
[ot][quote=Marco13]Hm???!??? Das hat damit nichts zu tun, da gibt’s keine Gravitation und nichts physikalisches.[/quote]
Ist schon klar, daher auch der Clown. Es hat mich nach ein paar Sekunden zuschauen nur an meinen eingereichten Bot erinnert, der auch “wie wild” im Kreis herum geschossen hat. Ich hab gerade nochmal kurz nachgeschaut, die Website mit den Ergebnissen auf der man sich das nochmal hätte ansehen können, ist mittlerweile leider offline.[/ot]