How To Draw Random Circles In Java

Random

One of the nearly powerful aspects of creating things through code is that of randomness. As humans, it can be pretty exhausting to come up with something unlike each time you are asked - a different drawing, a unique game-level map, or a new set of quiz questions, for example. Computers never tire of doing this, and it's pretty easy to tell them how. In Processing, you will use the `random()` office to have a new random number given to you. Here's a unproblematic loop that draws a hundred white circles on a black background at random locations:

          void setup() { 	size( 600, 600 ); 	noLoop(); 	noStroke(); }  void draw() { 	background( 0 ); 	for ( int north = 0; n < 100; north++ ) { 		float x = random( width ); 		float y = random( tiptop ); 		ellipse( x, y, 100, 100 ); 	} }        

Y'all'll notice that the `random()` function equally used in the above sketch merely uses one parameter - this specifies the upper limit of the number generated. Each fourth dimension yous call `random()` information technology will give yous a `float` (not an `int`) number from zero up to (but not including) the upper limit. You can also utilise `random()` to give you lot a random color - hither's the aforementioned code as in a higher place, but at present each circle will be a dissimilar colour:

                      for ( int due north = 0; northward < 100; northward++ ) { 		float x = random( width ); 		float y = random( height ); 		fill( random(255), random(255), random(255) ); 		ellipse( x, y, 100, 100 ); 	}        

Now, permit's say you wanted to draw a random number of randomly colored circles. Yous could do something like this:

                      for ( int n = 0; due north < random(100); northward++ ) {        

Merely - do you see any potential problems? Hint: when does `due north < random(100)` in the `for` loop get evaluated? Right - it gets evaluated every single pass through the loop - then, information technology would exist more efficient to do this:

                      int count = random( 100 ); 	for ( int n = 0; n < count; n++ ) {        

This will only telephone call `random()` one time to decide the number of circles to draw (`count`). However, if you try to run this as-is you volition get an error: `cannot convert from bladder to int`. This is considering `random()` returns a `float` and the `count` variable is an `int`. It'south like shooting fish in a barrel to fix - just tell Processing to treat the `float` as an `int` like this:

                      int count = (int) random( 100 );        

Using `random()` to make decisions

Another nice thing y'all can do with the `random()` role is have it make decisions for you. This is especially helpful if y'all desire to roll some virtual dice, or flip a virtual coin. To practice this, yous would call `random()` and employ the result to determine which lawmaking to run. For instance, if we randomly set the fill up color before drawing our circumvolve in the above sketch, it is like we are flipping 100 red/white coins:

                      if ( random(ii) < 1 ) { 			fill( 255 ); 		} 		else { 			fill( 255, 0, 0 ); 		} 		ellipse( x, y, 100, 100 );        

Taking a more than detailed wait at this, `random(2)` volition return a `bladder` ≥ 0 and < 2. Half of the time information technology volition exist less than 1. And so, 50% of the time the `if` expression `random(ii) < 1` will be true, and the fill colour will be white. The other l% of the time, the fill colour will be red.

Pedantic random integers

Sometimes you'll want a random `int` instead of a `float` - like the number of times to describe a circle, as used in a higher place - and yous may need to be careful how you convert from a `float` to an `int`. But casting it like nosotros did above performs what is called a truncate - everything past the decimal point is just dropped. So even if `random(100)` returned `99.999`, the `count` variable would be `99` (the mathematical term for this is flooring, which is an actual function yous can use in Processing). You might recollect that y'all could just round-off the random number, and that would piece of work, just you would only become half equally many 0'due south or 100's every bit the numbers i through 99. Only the values 0 up to .v volition round down to 0, just the values .five up to 1.5 will circular to 1. The easiest, but maybe a picayune counterintuitive solution is to just add one to the random range, and bandage information technology to an int. And then, if we want numbers from 0 through 100, nosotros would utilize:

          int count = (int) random( 101 );        

Anything greater than 100 will get truncated to 100. This technique will get especially useful when you lot starting time to utilise `switch` statements for choosing between more than than two things.

Source: https://thinkspacestudio.com/tutorials/randomness_in_java

Posted by: gallawaynoter1965.blogspot.com

Share this post