# Zufällige Bewegung



## Javt (29. Aug 2012)

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 (29. Aug 2012)

Kannst du mal nen KSKB zeigen?


----------



## Javt (29. Aug 2012)

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 (29. Aug 2012)

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 (29. Aug 2012)

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 (29. Aug 2012)

EikeB hat gesagt.:


> 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 (29. Aug 2012)

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 (29. Aug 2012)

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 (29. Aug 2012)

@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 (29. Aug 2012)

keep cool! Geh mal was kaltes trinken ..


----------



## SlaterB (29. Aug 2012)

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 (29. Aug 2012)

Ok ich versuchs mal


----------



## hüteüberhüte (29. Aug 2012)

Javt hat gesagt.:


> 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 (29. Aug 2012)

Ok


----------



## Marco13 (29. Aug 2012)

EikeB hat gesagt.:


> 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 (30. Aug 2012)

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 (30. Aug 2012)

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 (30. Aug 2012)

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 (30. Aug 2012)

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 (30. Aug 2012)

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 (30. Aug 2012)

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 (30. Aug 2012)

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 (30. Aug 2012)

> 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 (30. Aug 2012)

Blackhole16 hat gesagt.:


> 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 (30. Aug 2012)

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 (30. Aug 2012)

Blackhole16 hat gesagt.:


> 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


----------

