Zufällige Bewegung

[Javt]

Hi,

Ich hab ein Panel, in dem ich lauter Dreiecke bewegen lasse. Wie kann ich am besten zufällige Bewegungsrichtungen und Größen der Dreiecke erreichen. Wenn ich nur folgendes mache:

Random gen = new Random(System.currentTimeMillis())
[code=Java]

So klappt es ganz gut, wenn ich selber manuell per Hand die Anzahl der Dreiecke erhöhe. Wenn ich aber zu viele Dreicke gleichzeitig zeichnen lasse (1000), dann sieht man die Änderung garnicht, es werden dann nur ein Paar Dreiecke gezeichnet. Das hat wahrscheinlich damit zu tun, dass der Computer zu schnell ist und das dann die Größen der Dreiecke und die Bewegungseigenschaft identisch ist. 

Kann mir da jemand einen Tipp geben?

 

[Gast2]

Kannst du mal nen KSKB zeigen?

 

[Javt]

Hier ein kleiner Ausschnitt:

public int rndValue(int Minimum, int Maximum) {
		Random gen = new Random(System.currentTimeMillis());
		return ((int) (gen.nextDouble() * (Maximum - Minimum) + Minimum));
	}

gruß

 

[SlaterB]

dann hier ein ebenso großer Teil der Lösung/ Hilfe: "es"

Spass beiseite, das Thema ist schwierig genug so dass fraglich ist ob nur mit Java paint überhaupt alles hinzubekommen ist,
aber Voraussetzung zum reinfinden dürte wirklich ein vollständiges Testprogramm mit ablaufenden paint usw. sein

edit:
ach ja, ständig neues Random-Objekt zu erzeugen erscheint schonmal unsinnig,
nur ein Objekt statisch/ als Attribut ablegen!
wenn es wirklich schnell geht, dann könnten bei gleiche System-Zeit tatsächlich auch dieselben Werte rauskommen,
klingt ja doch genau nach deinem Problem, der Parameter für den Konstruktor bestimmt zuverlässig die Zufallswerte,
und System.currentTimeMillis() ändert sich weniger häufig als man denkt, springt insbesondere teils nur alle 15 ms weiter,
mit System.out.println() zur Überprüfung würdest du wohl soviel Zeit verbrauchen, dass es etwas verfälscht,
aber du könntest die 1000x System.currentTimeMillis() in ein Array schreiben und später anschauen

und Variablen unbedingt klein schreiben

 

[Gast2]

Ja, so kann man da wenig zu sagen.
Ein Hinweis allerdings: Wenn rndValue() oft aufgerufen wird (ohne großen zeiltlichen Abstand), dann kommen da oft gleiche Zufallszahlen raus. Erstell dir eine Random Instanz und nutz die für alle Zufallszahlen die du da in der Methode erstellst.

 

[Marco13]

Ja, so kann man da wenig zu sagen.
Ein Hinweis allerdings: Wenn rndValue() oft aufgerufen wird (ohne großen zeiltlichen Abstand), dann kommen da oft gleiche Zufallszahlen raus.

Eigentlich nicht, Random hat intern so einen (Instanz-Anzahl-Basierten "uniquifier")

// Hin
private static Random gen = new Random(System.currentTimeMillis());
public int rndValue(int Minimum, int Maximum) {
        //  Random gen = new Random(System.currentTimeMillis()); WEG
        return ((int) (gen.nextDouble() * (Maximum - Minimum) + Minimum));
    }

 

[Gast2]

Das war mir neu, aber da wird tatsächlich noch was mit dem seed gemacht.
Warum gibt dann aber dieser Code immer die gleiche Zufallszahl aus? Sollte das mit dem initialScramble(seed) nicht verhindert werden?

public static void main(String[] argv) {
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
	System.out.println(rndValue());
}

public static int rndValue() {
    Random gen = new Random(System.currentTimeMillis());
    return gen.nextInt();
}

EDIT:

private static long initialScramble(long seed) {
        return (seed ^ multiplier) & mask;
    }

Die Methode ändert ja nichts daran dass gleiche Seeds gleiche Zufallszahlen erzeugen. Was genau meinst du da mit Instanz-Anzahl-Basierten "uniquifier"?

 

[Javt]

Erstmal Danke für die Antworten. Das Problem ist einfach, dass sich alle erzeugten Objekte oben links in der Ecke zusammensammeln und sich dort bewegen. Sie kommen dort garnicht weg.

 

[hüteüberhüte]

@Javt:

private static Random gen = new Random();

public int rndValue(int min, int max) {
  return gen.nextInt(max - min + 1) + min;
}

Warum machst du schon wieder diese ganzen Cast s?

Wenn es schon nextDouble() sein soll, dann doch bitte so:

(int) (gen.nextDouble() * (max - min + 1)) + min

Wenn du so einfache Sachen wie Zufallszahl generieren nicht hin bekommst, solltest du gar nicht erst irgendwelche zufälligen Dreiecke zeichnen

 

[Javt]

keep cool! Geh mal was kaltes trinken ..

 

[SlaterB]

hast du das zu Random auch gelesen?
sammeln in einer Ecke kann auf schlechten Wertebereich oder Probleme bei Ganzzahldivision (Abrunden!) zurückzuführen sein,

gibt es mit 10 statt 1000 das Problem nicht mehr?
untersuche bei kleiner Anzahl ganz konkret, welche Koordinaten ausgerechnet werden

---------

zum Random

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers. In order to guarantee this property, particular algorithms are specified for the class Random. Java implementations must use all the algorithms shown here for the class Random, for the sake of absolute portability of Java code. However, subclasses of class Random are permitted to use other algorithms, so long as they adhere to the general contracts for all the methods.

Random (Java Platform SE 7 )

 

[Javt]

Ok ich versuchs mal

 

[hüteüberhüte]

keep cool! Geh mal was kaltes trinken ..

Ist doch wahr. An

private static Random r

sollte man schon denken. Sonst hat man doch das gesamte Prinzip nicht verstanden.

Aber back on topic: Wir kennen den Code nicht, der deine Dreiecke zeichnet. Von daher ist alles Weitere einfach nur Raten.

Und ja, werde gleich was kaltes trinken gehen ueh:

 

[Javt]

Ok

 

[Marco13]

Das war mir neu, aber da wird tatsächlich noch was mit dem seed gemacht.
Warum gibt dann aber dieser Code immer die gleiche Zufallszahl aus? Sollte das mit dem initialScramble(seed) nicht verhindert werden?
...
Die Methode ändert ja nichts daran dass gleiche Seeds gleiche Zufallszahlen erzeugen. Was genau meinst du da mit Instanz-Anzahl-Basierten "uniquifier"?

Ahhäähja... das war Unfug das greift natürlich nur wenn man NICHT den Seed angibt (sondern den Default-Constructor verwendet). Wenn er bei gleichem Seed doch unterschiedliche Werte ausgeben würde wäre das ja auch eher schlecht... :autsch:

 

[Blackhole16]

Was haltet ihr denn von System.nanoTime() ? Das liefert definitiv unterschiedliche Werte, selbst nach nur kleinen Befehlen. Damit wäre der Entstehende Random Wert auch unterschiedlich. Muss man nur sehen, ob das entstehende random durch die selben Befehle nicht auch regelmäßigkeiten erzeugt, dann könnte man das aber noch mit Thread.sleep() und einem weiteren Rnadomwert geben.

mfg
BH16

 

[SlaterB]

lohnt doch gar nicht, mit sleep oder nano oder irgendwas unbedingt einen neuen Wert für den nächsten Augenblick zu haben,
einfach ein Random-Objekt und alles läuft bestens,
bzw. ganz verdreht dessen nächsten (relativ) zufälligen Wert als seed für neues Random

wobei dann wirklich eine gewisse Wahrscheinlichkeit besteht,
dass man zufällig ein Wertepaar findet mit
Seed 554958904 -> 35. Zufallswert ist -356908095
Seed -356908095 -> 35. Zufallswert ist 554958904
Seed 554958904 -> 35. Zufallswert ist -356908095
usw. in Endlosschleife

 

[Javt]

Danke für die Vorschläge, aber das Problem ist immer noch nicht gelöst. Die Objekte kommen nicht von der oberen linken Ecke weg. D. h. bisher hab ich es nicht geschafft, sie auf zufälligen Bahnen bewegen zu lassen. Ich weiß nicht wie ich das lösen könnte.

 

[SlaterB]

wenn du auf Tipps wie

gibt es mit 10 statt 1000 das Problem nicht mehr?
untersuche bei kleiner Anzahl ganz konkret, welche Koordinaten ausgerechnet werden

mit keinem Wort eingehst, weder Informationen noch Code postest, dann kann wahrlich niemand helfen,

wobei kompletten Code posten und 'macht mal' auch nicht das Goldene vom Ei wäre

 

[Javt]

Ich kann ja nicht einfach beliebige Werte hernehmen. Ich hab einen bestimmten Wertebereich, auf den ich mich beschränken muss. Die Zeichenfläche hat ja eine feste Größe.

 

[timbeau]

Zeig mal deinen Code. Wie erhältst du die Zeichenflächengröße?

Ich denke aber auch eher, dass deine Schritte so klein sind, dass die sich in einem Rahmen von 10x10 Pixeln immer hin und her bwegen da sich die Bewegungen durch Random aufheben.

 

[Crian]

Du möchtest als zufällige Koordinaten in einer vorgegebenen Fläche erzeugen?

Dann mach erstmal das ohne zu zeichnen. Lass dir 1000 davon ausgeben und schau sie dir an, ob dier die Zahlen zufällig verteilt vorkommen.

 

[SlaterB]

> Ich hab einen bestimmten Wertebereich, auf den ich mich beschränken muss.

vielleicht ist der schlicht falsch gewählt, in Pixeln nicht das was du erhoffst oder durch weitere Berechnung eingeengt,
oder wird ganz anders auf die Zeichenfläche übertragen als gedacht,
ohne Information kann man rein gar nichts dazu erkennen

 

[bone2]

Was haltet ihr denn von System.nanoTime() ?

wenn man einfach parameterlos

new Random()

aufruft, nutzt random, welch überraschung, von sich aus nano
man ruiniert den seed also schon mit millis

wie groß sind die bewegungen bei jedem random? mach mal optisch größere schritte, 100 px oder so

 

[Crian]

So ich hab mal ein Beispiel gebsatelt:

public class GenerateRandomPointsInArea {

    public GenerateRandomPointsInArea() {
        RandomPointGenerator generator = new RandomPointGenerator(100, 1100,
                500, 1500);
        for (int i=0; i<100; ++i) {
            Point point = generator.generate();
            System.out.println(point);
        }
    }

    public static void main(String[] args) {
        new GenerateRandomPointsInArea();
    }

}

import java.util.Random;

public class RandomPointGenerator {
    private static Random random = new Random();
    private int minX;
    private int minY;
    private int maxX;
    private int maxY;

    public RandomPointGenerator(int minX, int minY, int maxX, int maxY) {
        this.minX = minX;
        this.minY = minY;
        this.maxX = maxX;
        this.maxY = maxY;
        if (maxX <= minX || maxY <= minY) {
            throw new IllegalArgumentException("Werte vertauscht");
        }
    }

    public Point generate() {
        int xDiff = maxX - minX;
        int yDiff = maxY - minY;
        int xAdd = random.nextInt(xDiff);
        int yAdd = random.nextInt(yDiff);
        int xNew = minX + xAdd;
        int yNew = minY + yAdd;
        Point point = new Point(xNew, yNew);
        return point;
    }
}

public class Point {

    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point [x=" + x + ", y=" + y + "]";
    }
}

Ausgabe:

Point [x=345, y=1257]
Point [x=337, y=1122]
Point [x=126, y=1274]
Point [x=217, y=1265]
Point [x=156, y=1350]
Point [x=488, y=1298]
Point [x=318, y=1482]
Point [x=307, y=1332]
Point [x=224, y=1207]
Point [x=292, y=1185]
Point [x=383, y=1487]
Point [x=220, y=1215]
Point [x=336, y=1372]
Point [x=216, y=1173]
Point [x=246, y=1373]
Point [x=188, y=1351]
Point [x=103, y=1245]
Point [x=235, y=1217]
Point [x=472, y=1265]
Point [x=473, y=1132]
Point [x=132, y=1198]
Point [x=328, y=1151]
Point [x=300, y=1461]
Point [x=206, y=1125]
Point [x=104, y=1405]
Point [x=168, y=1159]
Point [x=283, y=1227]
Point [x=455, y=1143]
Point [x=213, y=1103]
Point [x=409, y=1432]
Point [x=451, y=1390]
Point [x=483, y=1420]
Point [x=433, y=1400]
Point [x=282, y=1468]
Point [x=191, y=1302]
Point [x=353, y=1310]
Point [x=385, y=1106]
Point [x=108, y=1494]
Point [x=432, y=1410]
Point [x=451, y=1115]
Point [x=350, y=1410]
Point [x=306, y=1156]
Point [x=375, y=1245]
Point [x=381, y=1151]
Point [x=146, y=1400]
Point [x=193, y=1470]
Point [x=247, y=1147]
Point [x=326, y=1359]
Point [x=267, y=1341]
Point [x=384, y=1223]
Point [x=279, y=1483]
Point [x=245, y=1466]
Point [x=327, y=1348]
Point [x=265, y=1385]
Point [x=494, y=1412]
Point [x=436, y=1192]
Point [x=198, y=1483]
Point [x=357, y=1131]
Point [x=197, y=1433]
Point [x=289, y=1388]
Point [x=299, y=1465]
Point [x=484, y=1180]
Point [x=264, y=1335]
Point [x=343, y=1412]
Point [x=347, y=1103]
Point [x=162, y=1142]
Point [x=388, y=1220]
Point [x=265, y=1349]
Point [x=459, y=1433]
Point [x=322, y=1485]
Point [x=234, y=1327]
Point [x=327, y=1345]
Point [x=389, y=1452]
Point [x=215, y=1344]
Point [x=362, y=1396]
Point [x=407, y=1346]
Point [x=371, y=1335]
Point [x=101, y=1444]
Point [x=457, y=1223]
Point [x=205, y=1230]
Point [x=482, y=1476]
Point [x=228, y=1262]
Point [x=139, y=1269]
Point [x=178, y=1123]
Point [x=272, y=1365]
Point [x=301, y=1415]
Point [x=168, y=1192]
Point [x=368, y=1177]
Point [x=462, y=1385]
Point [x=154, y=1351]
Point [x=362, y=1345]
Point [x=323, y=1173]
Point [x=495, y=1206]
Point [x=233, y=1388]
Point [x=173, y=1246]
Point [x=441, y=1138]
Point [x=134, y=1118]
Point [x=186, y=1249]
Point [x=158, y=1379]
Point [x=179, y=1479]

 

[hüteüberhüte]

Was haltet ihr denn von System.nanoTime() ? Das liefert definitiv unterschiedliche Werte, selbst nach nur kleinen Befehlen. Damit wäre der Entstehende Random Wert auch unterschiedlich. Muss man nur sehen, ob das entstehende random durch die selben Befehle nicht auch regelmäßigkeiten erzeugt, dann könnte man das aber noch mit Thread.sleep() und einem weiteren Rnadomwert geben.

mfg
BH16

Murks, ohne weiteren Kommentar