Partikelprograemmchen

[Kappadona]

Hallo zusammen.
Ich weiss das es schon viele Partikelprogramme gibt, aber ich wollte halt selber eines machen, damit ich es auch selber lerne. Und jetzt habe ich es total anders als die, die ich im Internet gefunden habe. Also kann ich da jetzt auch nicht mehr spicken.
Und jetzt habe ich zwei Bitten an euch; Also 1. könntet ihr mir ev. mal sagen wie ich so programmiere, also auf Konventionen bezogen, nicht auf die Funktionalität.
Und 2. habe ich eben ein Problem, das es nicht funktioniert..
Der Fehler: Die Partikel verschwinden einfach so nach 3-5 sek(manchmal auch später)
Und sie ziehen sich nicht wirklich an..
Ich habe 3 Klassen: Main, Frame, Particle.
Im Main initialisiere ich ein Particle-Array mit 200 plätzen, das gebe ich dann ans Frame, dort Zeichne ich auch mit BufferStrategy, und an die Particle Klasse selbst.
Nun der Code der Particle Klasse:

import java.awt.Color;
import java.util.Random;

public class Particle {

	private float f_posx;
	private float f_posy;
	private float f_speedx;
	private float f_speedy;
	private Color color;
	private Random random = new Random();

	// Initialisiere ein Partikel an einer Position, und mit einer Farbe, dass
	// klappt meiner Meinung nach ziemlich gut.
	public Particle(float x, float y) {
		this.f_posx = x;
		this.f_posy = y;
		color = new Color(random.nextInt(200), random.nextInt(200),
				random.nextInt(200));
	}

	public Color getColor() {
		return color;
	}

	public float getX() {
		return f_posx;
	}

	public float getY() {
		return f_posy;
	}

	public void update(Particle[] particles) {

		// Hier addiere ich den Speed auf die momentane Position das Paricle
		// Array gebe ich hier auch weiter, da die Speed Methode private ist.
		f_posx += getSpeedx(particles);
		f_posy += getSpeedy(particles);

		// Dass sind einfach die Randbegrenzungen, und ich rechen den speed mal
		// -1 wenn das Partikel einen Rand erreicht
		if (f_posx < 50) {
			f_posx = 50;
			f_speedx = f_speedx * (-1);
		} else if (f_posx > 950) {
			f_posx = 950;
			f_speedx = f_speedx * (-1);
		}

		if (f_posy < 50) {
			f_posy = 50;
			f_speedy = f_speedy * (-1);
		} else if (f_posy > 570) {
			f_posy = 570;
			f_speedy = f_speedy * (-1);
		}
	}

	private float getSpeedx(Particle[] particles) {
		for (int i = 0; i < particles.length; i++) {
			// Wenn die Position genau Gleich ist ist es entweder das Gleiche
			// Partikel, oder Es liegt genau auf dem gleichen Punkt
			if (!(particles[i].getX() - f_posx == 0)) {
				// Hier Mache ich mir ein "Dreieck, zwischen den zwei Punkten,
				// x, y = katethen, stecke = hypothenuse
				float x = (particles[i].getX() - f_posx);
				float y = (particles[i].getY() - f_posy);
				float f_stecke = (float) Math.sqrt(Math.pow(x, 2)
						+ Math.pow(y, 2));
				// Dann brauche ich das Verhätniss zwischen den katheten da dass
				// viel zu gross wäre mutipliziere ich es mit einer sehr kleinen
				// Zahl..
				float f_verhaeltnis = (x / y) * 0.00000001f;
				// Mit dem Verhältniss multipliziere ich nun einfach die sie
				// Hypothenuse, denn wenn x klein ist, aber y riesig, muss ja
				// speedx trotzdem nicht gross sein.
				f_speedx += f_stecke * f_verhaeltnis;
			}
		}
		return f_speedx;
	}

	// Dann das selbe für y.
	private float getSpeedy(Particle[] particles) {
		for (int i = 0; i < particles.length; i++) {
			if (!(particles[i].getY() - f_posy == 0)) {
				float x = (particles[i].getX() - f_posx);
				float y = (particles[i].getY() - f_posy);
				float f_verhaeltnis = (y / x) * 0.00000001f;
				float f_stecke = (float) Math.sqrt(Math.pow(x, 2)
						+ Math.pow(y, 2));
				f_speedy += f_stecke * f_verhaeltnis;
			}
		}
		return f_speedy;
	}
}

OK, also ich hoffe das Forum ist überhaupt für solche sachen Gedacht!
Gruss

 

[JohannisderKaeufer]

Die Farbe würde ich im Konstruktor übergeben.
Das Random im Konstruktor ist nicht unbedingt der schönste Platz.
Farbwerte können von 0-255 gehen.

Das f_ ist jetzt auch nicht der Hit.

posX posY

sind geläufiger.
Wenn man ein

getX()

und

getY()

hat ist sogar einfach ein

x

und

y

angebracht.

particles[i].getY()

geht auch als

particles[i].y

mit dem for-each-loop kann das sogar als

for(Particle particle : particles){
  ...
  particle.y
}

Als Datentyp hätte ich jetzt einen double genommen anstatt floats. Evtl. sogar Integer.

Die variablen f_speedx und f_speedy würde ich nicht als member sondern als locale Variablen in den Methoden in denen Sie berechnet werden als locale Variablen berechnen.

Genauso würde ich das Ergebnisse nicht in Zeile 38 und 39 zur Position dazuaddieren, sondern sie in localen Variablen zwischenspeichern.

Dann die Überprüfung ob sich die Punkte am Rand befinden und erst danach die Addition der zwischenergebnisse zur Position.

Zudem kann es sich lohnen eine Aussagekräftige toString Methode zu implementieren um sich die Positionen auf der Console ausgeben zu lassen. Speziell wenn die Particel visuell nicht mehr Wahrzunehmen sind.

Anstatt die Punkte in double oder float Werten zu speichern, kann man sich auch überlegen dafür die Klasse Point bzw. Point2D zu nehmen.

 

[Timothy Truckle]

Im Prinzip sieht dass schon mal ganz gut aus.

Mich stören nur 2 Dinge:

private float f_posx;[/JAVA=6] passt nict zu den Java Namenskonventionen. Besser wäre IMHO:
[code=Java]private float xPosition;

Und dies:[JAVA=87] if (!(particles.getY() - f_posy == 0)) {
float x = (particles.getX() - f_posx);
float y = (particles.getY() - f_posy);
float f_verhaeltnis = (y / x) * 0.00000001f;
float f_stecke = (float) Math.sqrt(Math.pow(x, 2)
+ Math.pow(y, 2));
f_speedy += f_stecke * f_verhaeltnis;
}[/code]gehort in eine eigene Methode:

public float calculateSpeedY(float xPosition, float yPosition){
            if (!(yPosition - this.yPosition == 0)) {
                float x = (this.xPosition - xPosition);
                float y = (this.yPosition - yPosition);
                float f_verhaeltnis = (y / x) * 0.00000001f;
                float f_stecke = (float) Math.sqrt(Math.pow(x, 2)
                        + Math.pow(y, 2));
                return f_stecke * f_verhaeltnis;
            }
}

und in der Schleife dann:

  float speed =0.0;
        for (int i = 0; i < particles.length; i++) {
            speed +=particles[i].calculatSpeedX(xPosition,yPosition);
        }
        return speed;

bye
TT

 

[Stroker89]

Hab mir jetzt deinen Code nicht durchgeschaut, aber zu deiner ersten Bitte kann ich dir diesen Artikel empfehlen:

Creating a Particle System in Processing: Beginning with Particle Animation — CMD-c && CMD-v

EDIT: Auch noch ganz gut The Nature of Code
Diese Seite kann noch viel mehr als nur Beispiele für Partikelsysteme zu geben
Sind echt coole Sachen dabei

Gruß