True Random PRO - Real randomness for Unity

True Random

Why use True Random?
“True Random” can generate random numbers for you or your game. They are “truly random”, because they are generated with atmospheric noise, which supersedes the pseudo-random number algorithms typically use in computer programs.

People use True Random for holding drawings, lotteries and sweepstakes, to drive online games, for scientific applications and for art and music.

Here some more information regarding “true” vs. “pseudo-” random:

There are two principal methods used to generate random numbers. The first method measures some physical phenomenon that is expected to be random and then compensates for possible biases in the measurement process. Example sources include measuring atmospheric noise, thermal noise, and other external electromagnetic and quantum phenomena. For example, cosmic background radiation or radioactive decay as measured over short timescales represent sources of natural entropy.


The second method uses computational algorithms that can produce long sequences of apparently random results, which are in fact completely determined by a shorter initial value, known as a seed value or key. As a result, the entire seemingly random sequence can be reproduced if the seed value is known. This type of random number generator is often called a pseudorandom number generator. This type of generator typically does not rely on sources of naturally occurring entropy, though it may be periodically seeded by natural sources. This generator type is non-blocking, so they are not rate-limited by an external event, making large bulk reads a possibility.

https://en.wikipedia.org/wiki/Random_number_generation#.22True.22_vs._pseudo-random_numbers


How does this differ from Unity Random?
Perhaps you have wondered how Unity generates randomness. In reality, random numbers used in Unity are pseudo-random, which means they are generated in a predictable fashion using a mathematical formula.

This is fine for many purposes, but it may not be random in the way you expect it to be when you think of dice rolls and lottery drawings.




Features:
Generate true random

• Following data types can be generated randomly:
  • Integers, Floats & Sequences
  • Strings
  • Vector2, Vector3 & Vector4
• Extension methods for vectors to generate Colors and Quaternions
• Export the generated results as text-file

Documentation & control

• Test all random generators in the editor
• Powerful API for maximum control
• Detailed demo scenes
• Comprehensive documentation and support
• Full C# source code

Compatibility

• Supports all build platforms
• Works with Windows, Mac and Linux editors
• Compatible with Unity 2018.4 – 2021.1
• C# delegates and Unity events
  
• Works with Online Check
• PlayMaker actions

Some impressions:










Video:

AssetStore:
True Random PRO
Essential Tools Bundle
All Tools Bundle

Our other assets


Demo:
WebGL


Changes


Feel free to download and test it.
Any constructive comments are very welcome!


So long,
Stefan

 

Yeah, our asset is on Max's list:


Go there!


Cheers
Stefan

 

Hi there,
Thanks for True Random, Amazing Plugin,
However calling following function returns 2 same int in result in one case, i though this will always return unique int in result.
TRManager.GenerateInteger(1, TOTAL_ITEMS, REQUIRED_RANDOM_CHARACTER);

It returned
2,2,6,5

Please advise.

 

Hi John

The "GenerateInteger"-method generates 1-n numbers in a range.
Imaging dices - it's possible to get the same number twice in two rolls...

What do you want to achive exactly?


So long,
Stefan

 

i want to get unique int to fill a 2d grid with unique characters where each int will represet a unique character.

Can you please add support for getting unique integers so same integer doest appear again?

 

Isn't the "GenerateSequence" the solution?

For more see:
https://www.crosstales.com/media/da...osstales_1_1_true_random_1_1_t_r_manager.html

 

GenerateSequence doesnt seem to take 3rd parameter which is required, for example
GenerateSequence(1,100, 20);
so i have 100 characters and i want to select only 20 random, which means i should get 20 random ints out of 1-100.



Update:
20 random int means one of 20 int may have a value of "99" and other may have 5, so total 20 ints but values from 1-100

 

I would do it like this (GetRange does the trick):

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3. using System.Collections.Generic;
4. using Crosstales.TrueRandom;
5.  
6. public class GetRange : MonoBehaviour {
7.     public void Start () {
8.         TRManager.GenerateSequence(1, 100);
9.     }
10.  
11.     public void OnEnable()
12.     {
13.         TRManager.OnGenerateSequenceFinished += onGenerateSequenceFinished;
14.     }
15.  
16.     public void OnDisable()
17.     {
18.         TRManager.OnGenerateSequenceFinished -= onGenerateSequenceFinished;
19.     }
20.  
21.     private void onGenerateSequenceFinished(List<int> e)
22.     {
23.         List<int> relevant = e.GetRange(0, 20);
24.    
25.         Debug.Log(relevant.Count);
26.         Debug.Log(relevant.CTDump());
27.     }
28. }
29.  

Isn't that good enough?

 

Will it Return True Randomness? like other functions?

 

Yes!

 

Thanks, i'll let you know in case some issue come up.

 

You're welcome!

If you like our product/support and have some spare time left, please rate us at the store. Or even better, write a review - it's very much appreciated.
In case you've got any further questions, just let me know.


Cheers
Stefan

 

Hi John

Just to let you know, we added a third parameter "number" for "GenerateSequence".
If you like to get the new version, send me an email with the invoice.


Cheers
Stefan

 

Hi Stefan,

There is a problem with TrueRandom as it start getting old random results in new reqeusts.

Here is my case.

I make few sequence calls in a fixed order like below, let me call it SequenceOrder
SequenceOrder[
get 4 random numbers,
get 6
get 3
get 2
]
with different min max etc.

i use all these values to construct a character. and so far it worked fine.

now i wanted to see that character in different variations, so what i did is make a list of SequenceOrder like 10 times, and then make those requests 10 times, however this time i see 80% of the character appearing same, when i inspected the results they were 80% same.

Can you please take a look.
Thanks

 

Hi John

TrueRandom needs to get the random numbers from the Internet, therefor, every request needs time, let's say 500ms...
If you call "GenerateSequence" without waiting for the results via callback, TR is in fact not finished processing your previous requests and delivers the latest result available. This can result in "the same random results".
You have to use co-routines and wait, like in this example I made for you:

Code (CSharp):

1.  
2. using UnityEngine;
3. using System.Collections;
4. using System.Collections.Generic;
5.  
6. namespace Crosstales.TrueRandom.Requests
7. {
8.     /// <summary>Tests the generation of multiple sequences.</summary>
9.     public class SequenceTester : MonoBehaviour
10.     {
11.         #region Variables
12.  
13.         public Vector2 RangeA = new Vector2(1, 10);
14.         public Vector2 RangeB = new Vector2(10, 20);
15.         public Vector2 RangeC = new Vector2(20, 30);
16.         public Vector2 RangeD = new Vector2(30, 40);
17.  
18.         public int NumberA = 4;
19.         public int NumberB = 6;
20.         public int NumberC = 3;
21.         public int NumberD = 2;
22.  
23.         public int NumberOfRuns = 10;
24.  
25.         private List<int> valuesA;
26.         private List<int> valuesB;
27.         private List<int> valuesC;
28.         private List<int> valuesD;
29.  
30.         private bool valueGenerated = false;
31.  
32.         private int index = 0;
33.  
34.         #endregion
35.  
36.  
37.         #region MonoBehaviour methods
38.  
39.         public void Start()
40.         {
41.             StartCoroutine(generateSequences());
42.         }
43.  
44.         public void OnEnable()
45.         {
46.             TRManager.OnGenerateSequenceFinished += onGenerateSequenceFinished;
47.         }
48.  
49.         public void OnDisable()
50.         {
51.             TRManager.OnGenerateSequenceFinished -= onGenerateSequenceFinished;
52.         }
53.  
54.         #endregion
55.  
56.  
57.         #region Private methods
58.  
59.         private IEnumerator generateSequences()
60.         {
61.             for (int ii = 0; ii < NumberOfRuns; ii++)
62.             {
63.                 valueGenerated = false;
64.                 index = 0;
65.  
66.                 //values A
67.                 yield return generateSequence((int)RangeA.x, (int)RangeA.y, NumberA);
68.  
69.                 //values B
70.                 yield return generateSequence((int)RangeB.x, (int)RangeB.y, NumberB);
71.  
72.                 //values C
73.                 yield return generateSequence((int)RangeC.x, (int)RangeC.y, NumberC);
74.  
75.                 //values D
76.                 yield return generateSequence((int)RangeD.x, (int)RangeD.y, NumberD);
77.  
78.                 Debug.Log("+++ Generating character " + NumberOfRuns + " +++");
79.  
80.                 Debug.Log("ValuesA: " + System.Environment.NewLine + valuesA.CTDump());
81.                 Debug.Log("ValuesB: " + System.Environment.NewLine + valuesB.CTDump());
82.                 Debug.Log("ValuesC: " + System.Environment.NewLine + valuesC.CTDump());
83.                 Debug.Log("ValuesD: " + System.Environment.NewLine + valuesD.CTDump());
84.             }
85.         }
86.  
87.         private IEnumerator generateSequence(int min, int max, int number)
88.         {
89.             TRManager.GenerateSequence(min, max, number);
90.  
91.             while (!valueGenerated)
92.             {
93.                 yield return null;
94.             }
95.  
96.             valueGenerated = false;
97.             index++;
98.         }
99.  
100.         private void onGenerateSequenceFinished(List<int> e)
101.         {
102.             if (index == 0)
103.             {
104.                 valuesA = e;
105.             }
106.             else if (index == 1)
107.             {
108.                 valuesB = e;
109.             }
110.             else if (index == 2)
111.             {
112.                 valuesC = e;
113.             }
114.             else if (index == 3)
115.             {
116.                 valuesD = e;
117.             }
118.             else
119.             {
120.                 Debug.Log("index out of range!");
121.             }
122.  
123.             valueGenerated = true;
124.         }
125.  
126.         #endregion
127.     }
128. }
129.  

I hope this helps you further.

Cheers
Stefan


Edit:
Script updated

 

I'm using Events and i wait for answer to come.
OnGenerateSequenceFinished

I'd appreciate if you can take a look because it clearly doesnt work with a complex case where you want to create a truly randomize characcter creater.

 

My example is exactly doing what you wanted...
Or what isn't correct with this?

 

I don’t think this example solves the problem,

I’m doing similar and it works for 2-3 series.

What I’m doing is





Make a request.
+= OnGenerateSequenceFinished
When I get response, I make next request
If no next request I call the final function which draws the character


This is working fine. No issues here. As you can see above strategy wait for the response to come.






Previously [which is working]
Get Ear Graphic from available graphics
Get Nose graphic from available graphics
Get Eye Graphic so on.
Once all got, draw character.



Now when it worked, I felt pressing button and wait for results to come and then see another random result was feeling slow, so I decided to get 10 combinations first and then let user switch to these 10 combinations which means I saved the configuration in loop


loop(10){

Ear Graphic from available graphics
Nose graphic from available graphics
Eye Graphic so on.

}

Now get 1 request one by one using += OnGenerateSequenceFinished
Once all got, draw character from first series of configuraition (which is unique)
Press left and right button to cycle between configurations, and 80% of them are same.


I started to see similar results (which means I’m waiting and getting response, but response is 80% redundant) when I call the above block 10 times.

 

Hi John

I would like to verify your claim with statistics
Can you please send me all your character attributes and their exact number of variations?
Probably it's better do it by email.

So long,
Stefan

 

Hi Stefan,
Let me replace my code with your and see if that issue persist. if it persist then we both can see the same code, if not, then ill know mistake was on my end
Just one more try, and if issue still persisst, ill email you with.
Thanks

 

I used your code and as you can see last 3 iterations.
49 appears three times, and 5 two times conseqetively.
Thats the issue i want to avoid so it gives a unique look (every series is unique instead of repeating the old)

 

Hi John

Stupid me, I found a problem in the code. Let me fix it.

 

(phew) thanks, cant wait to test the fixed build.

 

The fix is ready

I also updated the first script and created a new one which is much faster:

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3. using System.Collections.Generic;
4.  
5. namespace Crosstales.TrueRandom.Requests
6. {
7.     /// <summary>Tests the generation of multiple sequences (V2).</summary>
8.     public class SequenceTesterV2 : MonoBehaviour
9.     {
10.         #region Variables
11.  
12.         public Vector2 RangeA = new Vector2(1, 10);
13.         public Vector2 RangeB = new Vector2(10, 20);
14.         public Vector2 RangeC = new Vector2(20, 30);
15.         public Vector2 RangeD = new Vector2(30, 40);
16.  
17.         public int NumberA = 4;
18.         public int NumberB = 6;
19.         public int NumberC = 3;
20.         public int NumberD = 2;
21.  
22.         public int NumberOfRuns = 10;
23.  
24.         private List<int> valuesA;
25.         private List<int> valuesB;
26.         private List<int> valuesC;
27.         private List<int> valuesD;
28.  
29.         private bool valueGenerated = false;
30.         private bool allValuesGenerated = false;
31.         private bool charactersGenerated = false;
32.  
33.         private int index = 0;
34.  
35.         #endregion
36.  
37.  
38.         #region MonoBehaviour methods
39.  
40.         public void Start()
41.         {
42.             StartCoroutine(generateSequences()); //get the initial randomized sequences at startup (just once!)
43.         }
44.  
45.         public void Update()
46.         {
47.             //This code is just as example! You would call it from the UI
48.             if (allValuesGenerated && !charactersGenerated)
49.             {
50.                 charactersGenerated = true;
51.  
52.                 for (int ii = 0; ii < NumberOfRuns; ii++)
53.                 {
54.                     GenerateCharacter(); //create characters!
55.                 }
56.             }
57.         }
58.  
59.         public void OnEnable()
60.         {
61.             TRManager.OnGenerateSequenceFinished += onGenerateSequenceFinished;
62.         }
63.  
64.         public void OnDisable()
65.         {
66.             TRManager.OnGenerateSequenceFinished -= onGenerateSequenceFinished;
67.         }
68.  
69.         #endregion
70.  
71.  
72.         #region Public methods
73.  
74.         /// <summary>Call this from the UI.</summary>
75.         public void GenerateCharacter()
76.         {
77.             Debug.Log("+++ Generating character +++");
78.  
79.             valuesA.CTShuffle();
80.             valuesB.CTShuffle();
81.             valuesC.CTShuffle();
82.             valuesD.CTShuffle();
83.  
84.             List<int> charValuesA = valuesA.GetRange(0, NumberA);
85.             List<int> charValuesB = valuesB.GetRange(0, NumberB);
86.             List<int> charValuesC = valuesC.GetRange(0, NumberC);
87.             List<int> charValuesD = valuesD.GetRange(0, NumberD);
88.  
89.             Debug.Log("Character Values A: " + charValuesA.CTDump());
90.             Debug.Log("Character Values B: " + charValuesB.CTDump());
91.             Debug.Log("Character Values C: " + charValuesC.CTDump());
92.             Debug.Log("Character Values D: " + charValuesD.CTDump());
93.         }
94.  
95.         #endregion
96.  
97.  
98.         #region Private methods
99.  
100.         private IEnumerator generateSequences()
101.         {
102.             index = 0;
103.  
104.             //values A
105.             yield return generateSequence((int)RangeA.x, (int)RangeA.y);
106.  
107.             //values B
108.             yield return generateSequence((int)RangeB.x, (int)RangeB.y);
109.  
110.             //values C
111.             yield return generateSequence((int)RangeC.x, (int)RangeC.y);
112.  
113.             //values D
114.             yield return generateSequence((int)RangeD.x, (int)RangeD.y);
115.  
116.             Debug.Log("ValuesA: " + System.Environment.NewLine + valuesA.CTDump());
117.             Debug.Log("ValuesB: " + System.Environment.NewLine + valuesB.CTDump());
118.             Debug.Log("ValuesC: " + System.Environment.NewLine + valuesC.CTDump());
119.             Debug.Log("ValuesD: " + System.Environment.NewLine + valuesD.CTDump());
120.  
121.             allValuesGenerated = true;
122.         }
123.  
124.         private IEnumerator generateSequence(int min, int max)
125.         {
126.             TRManager.GenerateSequence(min, max);
127.  
128.             while (!valueGenerated)
129.             {
130.                 yield return null;
131.             }
132.  
133.             valueGenerated = false;
134.             index++;
135.         }
136.  
137.         private void onGenerateSequenceFinished(List<int> e)
138.         {
139.             if (index == 0)
140.             {
141.                 valuesA = e;
142.             }
143.             else if (index == 1)
144.             {
145.                 valuesB = e;
146.             }
147.             else if (index == 2)
148.             {
149.                 valuesC = e;
150.             }
151.             else if (index == 3)
152.             {
153.                 valuesD = e;
154.             }
155.             else
156.             {
157.                 Debug.Log("index out of range!");
158.             }
159.  
160.             valueGenerated = true;
161.         }
162.  
163.         #endregion
164.     }
165. }
166.  

The main difference is this: it gets the random sequence for every attribute (A-D) at startup.
Afterwards, those initial randomized sets will be shuffled every time you call "GenerateCharacter".
This leads to great random variations with no performance overhead.
But it's not as "true random" as the first script, but I think it's probably "good enough"...


So long,
Stefan

 

Hi Stefan,

Performance is not an issue for me, because i can wait. But it has to be True Random so if i get first 10 (in final version i might load 50 series of variations) so user can see 50 different character looks.

So my question is, if i still use your old script but fixed version of TrueRandom, would it work now?

 

Yes, it will work now ;-)

 

We've created a new promo video:

Enjoy

 

Allright!!! PlayMaker actions! I just bought the DLL version. Can't wait to try it out... maybe even going to make a video.

 

Thanks for buying TR - I hope you will enjoy it.
Please let us know if you made a video

Cheers
Stefan


P.S: all our assets have PlayMaker actions

 

Is it possible to add a new id variable to the callback for finished events?
I am trying to use this to generate multiple sets, but when the list come back I have no way to identify who called it.

ie:

Code (csharp):

1.  
2. TRManager.GenerateInteger (0, max, 300, "List1");
3.  
4. TRManager.OnGenerateIntegerFinished += TRManager_OnGenerateIntegerFinished;
5.  
6. void TRManager_OnGenerateIntegerFinished (List<int> result, string key) {
7.   if (key == "List1") {
8.     LIST1UPDATE();
9.   } else if (key == "List2") {
10.     LIST2UPDATE();
11.   }
12. }
13.  

 

Hi

I think this is easy and possible - I will add it soon.
Do you own the PRO or standard version?


Cheers
Stefan

 

Ok, it's implemented.
Just send me an email with your invoice.

 

What does "Atmospheric noise" actually mean? Does this require PCs to have a microphone? Does this require microphone permissions on mobile devices? What happens when a loud noise causes clipping? What happens if a dangling microphone cable gets unplugged on PC platform and the active mic changes and it takes the OS a moment to process the changing of the microphone source? If there's no microphone, or the microphone is broken, in what manner does your product fail?

Answers to questions like these need to be in the first post, because right now I have no idea what your product is or how it works. All your post contains is a bunch of industry buzzwords like "atmospheric noise" and your assurances that it's somehow "superior."

 

Hi

"Atmospheric noise" are things like lightning discharges in thunderstorms. You don't need anything on your side, no mic etc.
You only need our tool and an Internet connection to obtain the numbers from an online service.

The main difference is that all generate numbers are non deterministic, compared to pseudo-random number generators like in every "normal" device. E.g. "Random.Range" is deterministic, that means, you could know all numbers which will be generated in advance. Sounds not like real random to me
Please read the Wikipedia article for more insight:
https://en.wikipedia.org/wiki/Random_number_generation#.22True.22_vs._pseudo-random_numbers

Cheers
Stefan

 

What? That makes absolutely no sense.

There are three basic use cases for random numbers in video game development: Generating content (I.E. random terrain, building characters from collections of body parts, etc.) making arbitrary decisions at runtime (I.E. rolling dice,) and encryption.

For generating content, the deterministic nature of seedable PRNGs are a feature, not a bug. For making arbitrary decisions at runtime, it usually doesn't matter whether a decision "is random," or merely seems random. (In fact, sometimes you specifically want high periods or good distribution rather than "true" randomness.) For encryption, "true" randomness might have a place, in some implementations and depending on what you're trying to do, but the absolute LAST thing you want to do is use a "black box" or trust a third party service.

Requiring an internet connection for the game to work is basically exactly the same as requiring a microphone for the game to work, in terms of unnecessary burden for us, the game developers and unnecessary barriers to a user purchasing our game. In fact, it introduces even more points of failure. RNG that needs a microphone fails if the user's computer lacks a microphone, but RNG that needs an internet connection fails for any number of reasons from the capabilities of the user's machine to the network to the freakin' weather to whether or not your servers are online. Why would anybody choose to make their game dependent upon a third party's website for something as simple as RNG?

As for trust, we don't even have any proof that your method of generating numbers is what you say it is. For all we know you could be calling Random.Range on your end! (More likely it's PHP or something, but the point is it could be ANYTHING. If your pitch about the "real randomness" of the product was dishonest, we'd have no way of knowing it.)

This has no reason to exist, guys. Don't pay money for it.

 

Uh, it has every reason to exist. Just because you don't have a use for it doesn't mean it doesn't have a use. Think about casino/gambling apps. Knowing the pseudo-random number generation is not a feature if you're the person managing it. You'd need truly (or as close to true) random numbers, which could then be manipulated to increase or decrease odds. If I remember correctly, Unity is actually used a lot for these things. I personally haven't used this product, but I trust that it works because the use of atmospheric noise is fairly widespread and have no doubt that at least one person has an implementation that they have packaged and put up on the Asset Store. I do not wish to prolong this argument, but as a word of advice to anyone reading this and thinking about picking up this package, if you wish to generate numbers without a seed, and therefore without predictability, this asset may help you.

 

Yes, it is useful in certain cases. But I have a question, I have found in the documentation that this asset uses the Random.org API. Does that mean this asset talks to the Random.org directly or does it talk to the Crosstales server?
Because it is not clear. And it's especially important, because Random.org is working on a pricing, after May the 31, you can expect some kind of fee for your quota. https://api.random.org/pricing
How does it come to play in the Unity Application - Crosstales - Random.org triangle?

 

We use their API directly and are aware of this upcoming change.
The pricing and tiers are unclear right now, so we have to wait.
If the new model doesn't fit our product anymore, we will provide an alternative, like an other service or our own server with dedicated TRNG hardware.

No worries, True Random will exist and work for many years to come.


Cheers
Stefan

 

You don't have to buy the product, especially if you don't know what TRNG is.

Defaming a product you don't even now is very unprofessional!

Here is something to eat: ><(((°>

 

Just take a moment to think about it. Can you predict the exact pattern of lightning strikes in a storm? True random number generation is done by using a system that is simply impossible to predict with our existing knowledge and relatively limited resources. With only a little searching you can find many examples of this.

Silicon Graphics designed a system that used the floating material in a lava lamp to generate random numbers.

https://en.wikipedia.org/wiki/Lavarand

The Department of Physics at Humboldt University of Berlin uses the quantum randomness of photon arrival times.

http://qrng.physik.hu-berlin.de/

There are evaluation suites designed for testing if a number generator is strong enough for a task.

https://nvlpubs.nist.gov/nistpubs/legacy/sp/nistspecialpublication800-22r1a.pdf

 

Yeah, this is what I don't really understand. Let's say I buy this product, then I release an application before May. Then in May Random.org says they want $1 per 100 bits or something, does not matter. If this asset use the Random.org directly, how my application will work after May?

And more importantly, why you don't talk about any of this on the front page of your asset? You rely on a 3rd-party service and you don't make it clear that you do, and on the top of that, this 3rd-party will be a paid service VERY soon (in software development time 3 months are nothing).
Will this asset be forced to update? Are you forcing our applications to be updated? What if someone released an app, which does not update? They lose the functionality they paid for.
Don't get me wrong, I think it's a viable asset and there is room for it. But I really think you should work on your communication a bit, because it's confusing and it looks like you're intentionally hiding this pricing-May issue. Which does not seem good. It may or may not be true, I'm talking about the impression.

 

First of all, Random.org is talking about this "pricing" along time (since 2015 at least) but they never really implemented it. The chances are imho very high that they still provide the 1'000'000 bits for free per IP as the did since ever.
However, your app will still work if they decide to close the "free tier" - it simply will use the fallback to PRNG (the same applies if you don't have an Internet connection).
To answer your first question: your app will still work, but not in TRNG-mode.

We already work on our own TRNG-server and will provide it as the main server in the future. If someone decides not to update to our latest version, it will work like above.

 

Oh.... Right. I didn't think about gambling apps! My bad. I thought I was talking to a community that makes video games. You guys have fun chasing that Live Services gold rush. Let me know how that works out for you when your games come out and 100% of the Whales are already locked into their casinos of choice. I'll just be over here making actual video games where you just pay once and then you get all of the content. It's not glamorous, and I don't have the luxury of spending more on my marketing budget than I do on making the damn game, but if I'm lucky I might be able to at least reach Ramen Profitability while I wait for the Long Tail to develop. At least I'll have the comfort of knowing that nobody's trying to legislate my business model out of existence four different ways simultaneously.

 

Whatever... Don't lose precious time trolling around instead of building your awesome game.

 

Oh, I wouldn't dream of it when Captains of Industry like yourself making Video Games what they are today.

 

Picked this up (Pro), looks very well documented and researched, didn’t take long
to go through the code, I’m satisfied. Very Professional, well done sir.

Without my doing hours of testing I was wondering about the timing/delay of getting a number from a network though.
Any thoughts?

 

Hi

Thank you for investing into TR!

Unfortunately, the delay is inevitable through the underlying service we use. It needs time to process the request and return the numbers.
We are currently testing some alternatives (like our own server) and it looks like we will gain a performance boost in the future. BUT: there will always be a small delay since we can't create TRNG numbers on the device and have to use a connection to the Internet. This is the reason for the implemented callbacks.

Have a nice weekend!


Cheers
Stefan

 

okay, that's what I figured, which is fine.
A simple fix for my plans would be just a small FIFO cache of numbers, just grab a whole set once and while.
Just trying to prevent random encounters from happening in the same order all the time.
Thanks.

 

Important notice for all "standard" customers:

We constantly try to push our assets to the next level by adding new features and deliver the best support for our customers. In the past we've kept updating the asset in a 2-month cycle. However, after careful consideration, we feel like this needs to happen at a faster pace. We've received numerous input from the community that a faster pace would help out a lot. Because Unity is ever evolving and we want to keep our assets relevant we need to be able to keep up the fast pace that is Unity's second nature. Packaging and maintaining a separate DLL-version poses a problem in regards to this goal.

With this in mind, we decided to phase out the DLL-version by the end of August 2018.
Besides being able to update the asset more often, we are convinced that phasing out the DLL-version in favor of the PRO version will also bring these improvements for our customers:

1. More functionalities and supported platforms due the source code (e.g. Linux)
   
2. Less frictions with different Unity versions within the same company
3. Fast hotfixes and high priority support

We understand that this may impact you negatively. However we hope with the upgrade-path we offer to you - our loyal DLL-customers - can alleviate your concerns and win you over once more:
PRO edition

Please rest assured we will continue to support and improve the PRO version over the years to come.

I hope you understand our decision.


Cheers
Stefan

 

Update regarding the deprecation of the standard package:

The standard package is planned to be available (but no longer maintained) until December 2018. This will allow the transition to PRO with a 50% reduced upgrade-price for our existing customers.
Afterwards, the package will vanish from the store and the upgrade path will become inaccessible.


Edit:
We managed to create an upgrade path for the standard version which will last forever.
Therefore, customers of the DLL version can still upgrade to PRO for 50% of the full price.