WoW:API random - Revision history

Move page script: Move page script moved page API random to WoW:API random without leaving a redirect

2023-08-15T04:47:06Z

Move page script moved page API random to API random without leaving a redirect

← Older revision

Revision as of 04:47, 15 August 2023

Bear at 07:37, 19 September 2013

2013-09-19T07:37:21Z

← Older revision		Revision as of 07:37, 19 September 2013
Line 1:		Line 1:
	{{~~luaapi~~}}		{{wowlua}}
	val = math.random([l [, u]]);		val = math.random([l [, u]]);
	val = random([l [, u]]);		val = random([l [, u]]);

	=== Description ===		=== Description ===
	The functions math.random and math.randomseed are interfaces to the simple random generator functions rand and srand that are provided by ANSI C.		The functions math.random and math.randomseed are interfaces to the simple random generator functions rand and srand that are provided by ANSI C.

	When called without arguments, math.random returns a pseudo-random real number in the range [0,1).		When called without arguments, math.random returns a pseudo-random real number in the range [0,1).

	When called with a number n, math.random returns a pseudo-random integer in the range [1,n].		When called with a number n, math.random returns a pseudo-random integer in the range [1,n].
Line 15:		Line 15:

	=== On random number generator distribution and security ===		=== On random number generator distribution and security ===
	The ANSI C rand() function is a Linear Congruential Pseudo-Random Number Generator (LPCRNG). Statistically speaking, LCPRNGs have a fair distribution. However, from a security standpoint they are very weak.		The ANSI C rand() function is a Linear Congruential Pseudo-Random Number Generator (LPCRNG). Statistically speaking, LCPRNGs have a fair distribution. However, from a security standpoint they are very weak.

	If you depend on random numbers to keep something secret or someone out of something, they only need to see a handful of numbers to be able to guess the next one accurately. In fact, if you output large enough numbers, they only need to see a single number to determine the next one. This is the standard LCPRNG used by Microsoft (written in C):		If you depend on random numbers to keep something secret or someone out of something, they only need to see a handful of numbers to be able to guess the next one accurately. In fact, if you output large enough numbers, they only need to see a single number to determine the next one. This is the standard LCPRNG used by Microsoft (written in C):
Line 43:		Line 43:
	It should be noted that the reason math.random does not allow 1.0 to be returned has to do with code they implemented to avoid issues on SunOS systems. However, they "correct" this issue by using modulus division. This has a side-effect for all non-SunOS systems making 0.0 twice as likely to occur than any other randomly generated number. In other words, when it would normally roll a 1.0, Lua changes that to 0.0 - so both 0.0 and 1.0 return as 0.0.		It should be noted that the reason math.random does not allow 1.0 to be returned has to do with code they implemented to avoid issues on SunOS systems. However, they "correct" this issue by using modulus division. This has a side-effect for all non-SunOS systems making 0.0 twice as likely to occur than any other randomly generated number. In other words, when it would normally roll a 1.0, Lua changes that to 0.0 - so both 0.0 and 1.0 return as 0.0.

	It has been suggested that the game client might seed the RNG when it is started		It has been suggested that the game client might seed the RNG when it is started

	Source: http://forums.worldofwarcraft.com/thread.html?topicId=15443405133&sid=1&pageNo=10		Source: http://forums.worldofwarcraft.com/thread.html?topicId=15443405133&sid=1&pageNo=10

WoWWiki>Starlightblunder: {{luaapi}}

2010-03-25T22:51:05Z

← Older revision		Revision as of 22:51, 25 March 2010
Line 1:		Line 1:
	{{~~:Lua/Libshortcut\|random\|math.random~~}}		{{luaapi}}
	== math.random==		val = math.random([l [, u]]);
			val = random([l [, u]]);
	~~=== Usage ===~~

	val = ~~math.~~random([l, u]);

	=== Description ===		=== Description ===
Line 48:		Line 45:
	It has been suggested that the game client might seed the RNG when it is started		It has been suggested that the game client might seed the RNG when it is started

	Source		Source: http://forums.worldofwarcraft.com/thread.html?topicId=15443405133&sid=1&pageNo=10
	http://forums.worldofwarcraft.com/thread.html?topicId=15443405133&sid=1&pageNo=10

	~~{{LUA}}~~

WoWWiki>Xioyn: Removed Randomseed Sorry don't know how to make the little arrow for the source

2009-04-18T18:43:46Z

Removed Randomseed Sorry don't know how to make the little arrow for the source

← Older revision		Revision as of 18:43, 18 April 2009
Line 1:		Line 1:
	{{:Lua/Libshortcut\|random\|math.random}}		{{:Lua/Libshortcut\|random\|math.random}}
	== math.random ~~and math.randomseed~~ ==		== math.random==

	=== Usage ===		=== Usage ===
	~~math.randomseed(s);~~
	val = math.random([l, u]);		val = math.random([l, u]);

Line 24:		Line 24:
	rng = rng * 214013 + 2531011		rng = rng * 214013 + 2531011
	return (rng>>16)&0x7fff;		return (rng>>16)&0x7fff;

	~~'''So, how do I get numbers that are harder to guess?'''~~

	~~The easiest way is to reseed the generator as often as possible with ever-changing data that third parties cannot see.~~

	If you are not generating dozens of numbers at once, hooking an event that occurs fairly often (OnUpdate, CHAT_MSG_* events, etc) and doing something like the following to introduce entropy to your generator should work:

	~~math.randomseed(math.random(0,2147483647)+(GetTime()*1000));~~

	=== Example ===		=== Example ===
Line 47:		Line 39:

	=== Notes ===		=== Notes ===
	~~math.randomseed takes any kind of positive number, between 0 and 2^31-1.~~

	The range [0,1) of math.random is exclusive, meaning that you can '''never''' get 1.0 exactly. Note that the returned number is not an integer, except the special (very rare) case of 0.		The range [0,1) of math.random is exclusive, meaning that you can '''never''' get 1.0 exactly. Note that the returned number is not an integer, except the special (very rare) case of 0.
Line 54:		Line 45:

	It should be noted that the reason math.random does not allow 1.0 to be returned has to do with code they implemented to avoid issues on SunOS systems. However, they "correct" this issue by using modulus division. This has a side-effect for all non-SunOS systems making 0.0 twice as likely to occur than any other randomly generated number. In other words, when it would normally roll a 1.0, Lua changes that to 0.0 - so both 0.0 and 1.0 return as 0.0.		It should be noted that the reason math.random does not allow 1.0 to be returned has to do with code they implemented to avoid issues on SunOS systems. However, they "correct" this issue by using modulus division. This has a side-effect for all non-SunOS systems making 0.0 twice as likely to occur than any other randomly generated number. In other words, when it would normally roll a 1.0, Lua changes that to 0.0 - so both 0.0 and 1.0 return as 0.0.

			It has been suggested that the game client might seed the RNG when it is started

			Source
			http://forums.worldofwarcraft.com/thread.html?topicId=15443405133&sid=1&pageNo=10

	{{LUA}}		{{LUA}}

WoWWiki>X87bliss: /* Notes */

2009-04-02T23:39:11Z

Notes

← Older revision		Revision as of 23:39, 2 April 2009
Line 52:		Line 52:

	The other ranges of the functions are inclusive, and will always return integers.		The other ranges of the functions are inclusive, and will always return integers.

			It should be noted that the reason math.random does not allow 1.0 to be returned has to do with code they implemented to avoid issues on SunOS systems. However, they "correct" this issue by using modulus division. This has a side-effect for all non-SunOS systems making 0.0 twice as likely to occur than any other randomly generated number. In other words, when it would normally roll a 1.0, Lua changes that to 0.0 - so both 0.0 and 1.0 return as 0.0.

	{{LUA}}		{{LUA}}

WoWWiki>VoidvectorBot: Robot: converting/fixing HTML

2007-01-20T09:37:57Z

Robot: converting/fixing HTML

← Older revision		Revision as of 09:37, 20 January 2007
Line 25:		Line 25:
	return (rng>>16)&0x7fff;		return (rng>>16)&0x7fff;

	~~<b>~~So, how do I get numbers that are harder to guess?~~</b>~~		'''So, how do I get numbers that are harder to guess?'''

	The easiest way is to reseed the generator as often as possible with ever-changing data that third parties cannot see.		The easiest way is to reseed the generator as often as possible with ever-changing data that third parties cannot see.

WoWWiki>Hobinbot: demoted headings

2007-01-07T20:53:02Z

demoted headings

← Older revision		Revision as of 20:53, 7 January 2007
Line 1:		Line 1:
	{{:Lua/Libshortcut\|random\|math.random}}		{{:Lua/Libshortcut\|random\|math.random}}
	=math.random and math.randomseed=		== math.random and math.randomseed ==

	==Usage==		=== Usage ===
	math.randomseed(s);		math.randomseed(s);
	val = math.random([l, u]);		val = math.random([l, u]);

	==Description==		=== Description ===
	The functions math.random and math.randomseed are interfaces to the simple random generator functions rand and srand that are provided by ANSI C.		The functions math.random and math.randomseed are interfaces to the simple random generator functions rand and srand that are provided by ANSI C.

Line 17:		Line 17:
	The math.randomseed function sets a "seed" for the pseudo-random generator: Equal seeds produce equal sequences of numbers.		The math.randomseed function sets a "seed" for the pseudo-random generator: Equal seeds produce equal sequences of numbers.

	==On random number generator distribution and security==		=== On random number generator distribution and security ===
	The ANSI C rand() function is a Linear Congruential Pseudo-Random Number Generator (LPCRNG). Statistically speaking, LCPRNGs have a fair distribution. However, from a security standpoint they are very weak.		The ANSI C rand() function is a Linear Congruential Pseudo-Random Number Generator (LPCRNG). Statistically speaking, LCPRNGs have a fair distribution. However, from a security standpoint they are very weak.

Line 33:		Line 33:
	math.randomseed(math.random(0,2147483647)+(GetTime()*1000));		math.randomseed(math.random(0,2147483647)+(GetTime()*1000));

	==Example==		=== Example ===
	> local x = math.random();		> local x = math.random();
	> = x		> = x
Line 46:		Line 46:
	51 [50 - 52]		51 [50 - 52]

	==Notes==		=== Notes ===
	math.randomseed takes any kind of positive number, between 0 and 2^31-1.		math.randomseed takes any kind of positive number, between 0 and 2^31-1.

WoWWiki>Mikk: "randseed" -> "randomseed". My bad.

2006-05-26T12:26:31Z

"randseed" -> "randomseed". My bad.

← Older revision		Revision as of 12:26, 26 May 2006
Line 1:		Line 1:
			{{:Lua/Libshortcut\|random\|math.random}}
	=math.random and math.randomseed=		=math.random and math.randomseed=

Line 6:		Line 7:

	==Description==		==Description==
	The functions math.random and math.randomseed are interfaces to the simple random generator functions rand and srand that are provided by ANSI C. ~~(No guarantees can be given for their statistical properties.)~~		The functions math.random and math.randomseed are interfaces to the simple random generator functions rand and srand that are provided by ANSI C.

	When called without arguments, math.random returns a pseudo-random real number in the range [0,1).		When called without arguments, math.random returns a pseudo-random real number in the range [0,1).
Line 15:		Line 16:

	The math.randomseed function sets a "seed" for the pseudo-random generator: Equal seeds produce equal sequences of numbers.		The math.randomseed function sets a "seed" for the pseudo-random generator: Equal seeds produce equal sequences of numbers.

			==On random number generator distribution and security==
			The ANSI C rand() function is a Linear Congruential Pseudo-Random Number Generator (LPCRNG). Statistically speaking, LCPRNGs have a fair distribution. However, from a security standpoint they are very weak.

			If you depend on random numbers to keep something secret or someone out of something, they only need to see a handful of numbers to be able to guess the next one accurately. In fact, if you output large enough numbers, they only need to see a single number to determine the next one. This is the standard LCPRNG used by Microsoft (written in C):

			rng = rng * 214013 + 2531011
			return (rng>>16)&0x7fff;

			<b>So, how do I get numbers that are harder to guess?</b>

			The easiest way is to reseed the generator as often as possible with ever-changing data that third parties cannot see.

			If you are not generating dozens of numbers at once, hooking an event that occurs fairly often (OnUpdate, CHAT_MSG_* events, etc) and doing something like the following to introduce entropy to your generator should work:

			math.randomseed(math.random(0,2147483647)+(GetTime()*1000));

	==Example==		==Example==
Line 36:		Line 53:
	The other ranges of the functions are inclusive, and will always return integers.		The other ranges of the functions are inclusive, and will always return integers.

	{{~~Template:WoW API~~}}		{{LUA}}

WoWWiki>WoWWiki-Raloth: fixed bracket

2006-02-18T16:45:30Z

fixed bracket

← Older revision		Revision as of 16:45, 18 February 2006
Line 19:		Line 19:
	> local x = math.random();		> local x = math.random();
	> = x		> = x
	0.34534 [0 - 1[		0.34534 [0 - 1]

	> local x = math.random(100);		> local x = math.random(100);

WoWWiki>WoWWiki-Pixel: /* Example */

2006-01-06T04:59:31Z

Example

← Older revision		Revision as of 04:59, 6 January 2006
Line 2:		Line 2:

	==Usage==		==Usage==
	math.randomseed = (~~int~~);		math.randomseed(s);
	val = math.random([l, u]);		val = math.random([l, u]);

Line 19:		Line 19:
	> local x = math.random();		> local x = math.random();
	> = x		> = x
	0.34534 (0 - 1)		0.34534 [0 - 1[

	> local x = math.random(100);		> local x = math.random(100);
	> = x		> = x
	53 (1 - 100)		53 [1 - 100]

	> local x = math.random(50, 52);		> local x = math.random(50, 52);
	51 (50 - 52)		> = x
			51 [50 - 52]

	==Notes==		==Notes==
	~~At this stage~~, ~~I don~~'~~t know if~~ the ~~range~~ is ~~inclusive or exclusive~~. ~~[[User:Zingfharn\|Zingfharn]]~~		math.randomseed takes any kind of positive number, between 0 and 2^31-1.

			The range [0,1) of math.random is exclusive, meaning that you can '''never''' get 1.0 exactly. Note that the returned number is not an integer, except the special (very rare) case of 0.

	~~One would suppose through deduction that, since random 1 3 will indeed give you numbers~~ other ~~than 2, that~~ the ~~other types of "random" would also give you~~ inclusive ~~results. This is not guaranteed of course~~, ~~but it seems like the developers would be consistent in their coding~~. ~~[[User:Disco\|Disco]]~~		The other ranges of the functions are inclusive, and will always return integers.

	{{Template:WoW API}}		{{Template:WoW API}}