Assuming you have a random() function that returns a uniformly-distributed numeric value in the interval [0, 1)...
(I see the edit attempt to "fix" the mismatched bracket above, but this is deliberate and carries specific meaning)
random() - random()
Gives a distribution that peaks at 0 and falls off toward -1 and 1.
abs(random() - random())
Don't roll dice, deal cards.
Take all possible results of your RNG, put them in a list, shuffle it randomly, and return the results in the randomized order. When you are at the end of the list, repeat.
The results will still be uniformly distributed, but individual results won't repeat unless the last of the list also happens to be the first of the next ...
The Soft-coded Probabilities Solution
The hardcoded probability solution has the disadvantage that you need to set the probabilities in your code. You can't determine them at runtime. It is also hard to maintain.
Here is a dynamic version of the same algorithm.
Create an array of pairs of actual items and weight of each item
When you add an item, the ...
Let's say "rand()" gives you a random number between 0 and 1 (inclusive).
will give you an answer between 0 and 1 (inclusive), but the result is more likely to be close to zero, following a quadratic curve.
will give you an answer between 0 and 1 (inclusive), but the result is more likely to be close to one, following a ...
One of the best, and most used, algorithms I've seen out there is generating dungeons using Binary Space Partitioning.
The best general explanation I've read is the one found in The Chronicles of Doryen (attached at the end for backup purposes) because explains the procedure without getting into the code, thus leaving the implementation to the reader.
Note: I created a C# library for this exact problem
The other solutions are fine if you only have a small number of items and your probabilities never change. However, with lots of items or changing probabilities (ex. removing items after selecting them), you'll want something more powerful.
Here are the two most common solutions (both of which are ...
What you could do is randomly generate a Voronoi map like this:
Picking random center points (see the black dots) and randomly decide if they are grass or dirt.
Then for over all tiles, check if it's closest to a center point of dirt or a grass.
If what you did previously is "flip a coin" for each tile (noise), generating a Voronoi diagram will ...
You could use perlin noise, which is normaly used for heightmap generation.
Perlin noise in games
Then you could use the heights as an adviser, how high the chance of grass/dirt occuring in one region of the map is.
Example (Perlin noise values from 0-256):
If the value is over 200 the chance that grass is placed is 80% (dirt 20%).
If the value is between ...
Java's java.util.Random class usually gives you sequences of pseudorandom numbers which are good enough for use in games1. However, that characteristic only applies to a sequence of multiple samples based on a seed. When you reinitialize the RNG with incrementing seed values and only look at the first value of each sequence, the randomness characteristics ...
You don't actually want a random distribution. I point this out explictly, because what we consider "random" for design is usually not true randomness.
Now, with that in mind, let's add some tweaking values -- these are things you'll fiddle with until the design feels "right".
const float WordLetterProbability = 0.5f;
You could weight the probability of all your letters according to the frequency with which they occur in the language your words are in. A good guideline is the scrabble set. The English version, for example, has 12 E's but only one Z and one Q.
A simple way to implement this is by putting all the letters in a consecutive string with each letter appearing ...
The Wheel of Fortune solution
You can use this method when the probabilities in your item pool have a rather large common denominator and you need to draw from it very often.
Create an array of options. But put each element into it multiple times, with the number of duplicates of each element proportional to its chance of appearing. For the example above, ...
Basically, what you're asking for is a "semi-random" event generator that generates events with the following properties:
The average rate at which each event occurs is specified in advance.
The same event is less likely to occur twice in a row than it would be at random.
The events are not fully predictable.
One way to do that is to first implement a non-...
"Procedural" means that some algorithm made the content. This is opposed to content being created manually by a human.
"Dynamic" means that the content changes over time. This is opposed to "static" content that does not change after being created, or only changes in predefined ways e.g. key-framed character animation.
You can also have in-game player-...
You could try a Markov Random Graph. Consider each event that can occur to be a node in a graph. From each event, make a link to each other event that could possibly come after it. Each of these links is weighted by something called the transition probability. Then, you perform a random walk of the graph according to the transition model.
For instance, you ...
Yes, you can. There are already online platforms that are doing exactly that, by providing you the hash of the online secret key that is used as the seed for the random generation. Same seed = same random result. Now when the hand/ game is over, you can reveal the original secret. Players can verify by hashing it themselves and compare it to the previous ...
The coordinates should have the same color everyone you restart the
In that case, you'll want to use a deterministic noise function such as Perlin noise or simplex noise.
(See this question for some more information on Perlin noise with some pretty pictures.)
For the most part, using a built-in random() or similar function will give you ...
The approach you outline is simple and useful, but suffers from terrible artifacts as shown. Avoid it. You need a parallel growth algorithm; for a single-threaded model, a round-robin approach follows:
Randomly place various points in your map space. Normalise their distribution (avoids ugly clustering) using Gaussian distribution or by applying an ...
UnityEngine.Random has a few ease of use advantages:
Static/globally accessible — you don't need to create an instance for each object or system that needs randomness. Most or all of your scripts can share this resource.
Convenience methods — you can use Random.Range(), Random.insideUnitSphere, Random.rotationUniform, Random.ColorHSV() to get nicely-...
As others have pointed out, what you're looking for is effectively a shuffled deck of cards. Every card (in this case, a unique number) is present exactly once, in a randomized order. By drawing cards from the deck one at a time, you create a psuedorandom number string with no repeats.
(Obviously, once you've exhausted the deck, you'll need to either reuse ...
Why not use a system similar to advantage/disadvantage as used in DnD 5e?
It boils down to:
disadvantage: roll 2 (or any number of) dice and keep the lowest.
advantage: roll 2 (or any number of) dice and keep the highest.
for 1 out of 2 dice this gives a linear chance decreasing as you get higher:
for one out of ...
here is my version of the cellular automata method
start by filling the grid with random
then run these cullular automata rules on it a couple times
If a living cell has less than two living neighbours, it dies.
If a living cell has two or three ...
You will need to learn how the terms Octave, Persistence, Frequency, and Lacunarity are used. What you have is a good first step, it looks just like noise should.
The basic idea is that you need to combine multiple noise sources into one result to achieve the final look. This combination can be something simple like addition, but you can take many ...
Let's see what you are doing exactly:
You loop through all pixels one by one
For each pixel, you use the concatenation of its coordinates as a seed
You then start a new random from the given seed and take out 3 numbers
All this sounds alright, but you are receiving a pattern because:
Pixel at 1,11 and pixel at 11,1 are both seeded the number 111 so they ...
If you do know the distribution you want, you can use rejection sampling.
Simplest way: In the graph above, pick points at random until you find one is below the curve. Then just use the x-coordinate.
For the actual distribution, there are various plausible approaches. For example, for planet number i at location p, and some strength parameter k (e.g. 0.5),...
An alternatve would be to not place the power-ups near the players but at positions which involve taking some risks to get there. This way you would encourage players to stop hiding which can increase the fun-factor and would reward them for their "courage". On top of that no one could complain that someone was just lucky to pick up a powerful power-up ...
As it has been previously remarked in the comments, and as you seem to think as well, random generation is a just another possible form of procedural generation.
Procedural content generation implies that content is being generated by an algorithm rather than manually crafted by a human being. That said, the frontier is very blurry. On one hand, we have ...