Differences

This shows you the differences between two versions of the page.

--- cw4:4rpl_tools [2025/06/23 18:45] – [Request Viable Move-Cell] kalli
+++ cw4:4rpl_tools [2025/08/29 21:04] (current) – [Pseudo RNG based on Linear congruential generator (LCG)] kalli
@@ Line 3551: / Line 3551: @@
-===== Request Viable Move-Cell =====
+===== Request Viable Build- or Move-Cell =====
 <hidden click here for source code>
-This script allows for other scripts to SEND A MESSAGE TO REQUEST A VIABLE MOVE-CELL. It can also be used to request a viable build cell, but with limitations: not suited for nullifiers, miners, beacons, or other special units.
+This script allows for other scripts to SEND A MESSAGE TO REQUEST A VIABLE BUILD- OR MOVE-CELL.
+The script is a compromise between high performance and high fidelity. The reason that it's setup to run as a separate script and not as a function, is so that it can take move/build requests from multiple sources into account: by default it won't recheck cells that were recently rejected + new searches will continue where recent previous queries stopped after finding a solution. A very high performance version exists for 3x3 units in my SQUADS map.
-The script is a compromise between high performance and high fidelity. The reason that it's setup to run as a separate script and not as a function, is so that it can take move/build requests from multiple sources into account: it won't recheck cells that were recently rejected + new searches will continue where recent previous queries stopped after finding a solution. A very high performance version exists for 3x3 units in my SQUADS map.
@@ Line 3565: / Line 3564: @@
-If the units are special custom units (build in void/anywhere or build as miner/nullifier, then their GUID needs to be added to the relevant lists inside the script.
+Use example for building miners:
-INPUT:
+<code 4rpl example.4rpl>500 0 do
-<code 4rpl MultiObjective.4rpl>"requestWxWviableCell" <-UID <-cellV2 <-searchRange <-maxCreeperDepth <-noMesh <-unitWidth <-ignoreCooldown 7 listN sendmsg</code>
+	"requestWxWviableCell" 0 5 3 128 128 v2 256 0 0 0 0 1 0 1 1 0 14 listN sendmsg # Length > width = x direction.
-OUTPUT: 2 global variables, see example:
+	<-*WxWviableCellFound if
-<code 4rpl MultiObjective.4rpl><-*WxWviableCellFound if
+		"miner" <-*WxWviableCell ev2 0 createunitonterrain dup 1 SetUnitOccupiesLand 999 constructunit
-<-UID <-*WxWviableCell ev2 setunitmovecell
+		# Unlike existing units that move, newly build units do not instantly occupy the cells that they were created on, so we force a refresh of that with SetUnitOccupiesLand.
-endif</code>
+	endif
+loop
+0 do
+	"requestWxWviableCell" 0 3 5 128 128 v2 256 0 0 0 0 1 0 1 1 0 14 listN sendmsg # Length > width = z direction. With Z-direction we also need to change the orientation below.
+	<-*WxWviableCellFound if
+		"miner" <-*WxWviableCell ev2 0 createunitonterrain dup dup 1 setunitorientation 1 SetUnitOccupiesLand 999 constructunit
+	endif
+loop</code>
 INPUT variables explained:
-<-UID: The UID of the unit. Can be left 0, needs a UID to determine the unit type.
+<-moveUID: can be left 0, but it's needed if you want to allow a unit to check if it's current location is viable.
+<-unitLength: footprint length in X direction.
+<-unitWidth: footprint length in Z direction.
 <-cellV2: V2 vector. The cell where your requesting script wants to build/move the unit.
-<-searchRange: the cell distance around the requested cell location, where the function will look for a suitable build/move cell.
+<-searchRange: the cell distance around the requested cell location, where the function will look for a viable build/move cell.
 <-maxCreeperDepth: this will check the average creeper depth in a circle with range 4.
@@ Line 3587: / Line 3598: @@
 <-noMesh: set to 1 to not allow solutions with ACTIVE mesh.
-<-unitWidth: the footprint witdth=length of the unit. This assumes square units.
+<-likePlatform: the unit can be placed in the void.
-<-ignoreCooldown: set to 1 to ignore the computation optimizations.
+<-likeBeacon: the unit can be placed in the void and on uneven terrain.
+<-likeMiner: the unit can only be placed on resource special terrain that covers atleast 75% of the unit footprint.
-<code 4rpl MultiObjective.4rpl>
+<-likeNullifier: the unit has to be placed within nullification range of an enemy creeper. The creeper enemey has to be known to a list inside the function script.
-# --WxW-FindViableCell-NRP-Pre--
-# INPUTS: "requestWxWviableCell" <-UID <-cellV2 <-searchRange <-maxCreeperDepth <-noMesh <-unitWidth <-ignoreCooldown 7 listN sendmsg
+<-ignoreCooldown: set to 1 to ignore time based computation optimizations. Best left at 0 when the function is called by an AI script (more optimized) and set to 1 when it's initiated by the player (feels more responsive).
+<-noSkip: set to 1 for max placement coverage, but slower computations. If left at 0, then the script will not check cells that are likely to not have a proper solution, but it will also mistakenly not check some cells that do have a proper solution. For spamming 3x3 units, "1" tends to be 40% slower, while only placing about 10% more units.
+<-resetSearch: if set to 1, then all previous search history will be forgotten.
+<code 4rpl LxW-FindViableCell-NRP-Pre.4rpl>
+# --LxW-FindViableCell-NRP-Pre--
+# INPUTS: "requestWxWviableCell" <-moveUID <-unitLength <-unitWidth <-cellV2 <-searchRange <-maxCreeperDepth <-noMesh <-likePlatform <-likeBeacon <-likeMiner <-likeNullifier <-ignoreCooldown <-noSkip <-resetSearch 14 listN
 # OUTPUT: global varialbles named <-*WxWviableCellFound <-*WxWviableCell
@@ Line 3601: / Line 3623: @@
 # BASED ON SNAPPING TOOL CODE, but without the Indicator unit or the Mouse commands, and only for SQUARE units.
-$radiusLandingSpot:4 # The creeper threshhold will be checked as an average over more than the unit landing location.
+$radiusLandingSpot:4 # INTEGER. The creeper threshhold will be checked as an average over more than the unit landing location.
-$cellsWithinLandingRange:69 # The creeper threshhold will be checked as an average over more than the unit landing location.
+$cellsWithinLandingRange:69 # INTEGER, see previous radius. The creeper threshhold will be checked as an average over more than the unit landing location.
+$$defaultSearchRange:20 # INTEGER. The floodfill distance. If no searchRange is send in the message, this is the range that will be used.
-$$defaultSearchRange:20 # If no searchRange is send in the message, this is the range that will be used.
+$groupDist:7 # Integer or float distance. Requests that are closer together than this distance, will be grouped together, so that later searches can continue on from previous searches.
+$blockCellTimer:90 # INTEGER. Amount of frames under which queries will be grouped together & searches around cells that were found to be blocked, will not be done again.
+$clearCellTimer:270 # INTEGER. Amount of frames after which the blocked cells will be forgotten. In between these 2 values, searches will only be done again if there are less units around than when the cell was last found to be blocked.
-$$contSlot:8 # Units cannot be placed on this terrain slot. 8 is the default contaminant slot.
+$$contSlot:8 # VALUE EDITOR SETTING. Units cannot be placed on this terrain slot. 8 is the default contaminant slot.
-$$resoSlot:1 # Miners can only be placed on resource terrain. 1 is the default resource slot.
+$$resoSlot:1 # VALUE EDITOR SETTING. Miners can only be placed on resource terrain. 1 is the default resource slot.
-$$meshSlot:6 # Units that can be placed in the void, cannot be placed on mesh inside the void. 6 is the default mesh slot.
+$$meshSlot:6 # VALUE EDITOR SETTING. Units that can be placed in the void, cannot be placed on mesh inside the void. 6 is the default mesh slot.
-$$unitBuildTypes:"	"
-# $$footprintWidth:"	"
-# $$footprintLength:" "
-$$voidUnitTypes:"	Platform; platform"
-$$anywhereTypes:"	Chronat; beacon"
-$$resourceTypes:"	Reactor; miner"
-$$nullifyTypes:"	Nullifier; nullifier"
 $$nullifyUnits:"	emitter; airsaccauldron; blobnest; darktower; skimmerfactory; sporelauncher" # Enemy units that would be suppressed by building a nullifier near them.
 :requestWxWviableCellFunction
-	<-_DATA[0] 0 setunitoccupiesland
+	<-_DATA[0] 0 setunitoccupiesland # With this line, an existing unit's current cell will be a possible result from the search for a viable cell.
-	<-_DATA[2] dup not if pop <-defaultSearchRange endif ->searchRange
+	<-_DATA ListToStack @searchWxWviableCell ->*WxWviableCellFound ->*WxWviableCell
-	<-_DATA[0] getunittype <-_DATA[1] <-_DATA[3] <-_DATA[4] <-_DATA[5] @searchWxWviableCell ->*WxWviableCellFound ->*WxWviableCell
-	<-_DATA[6] ->ignoreCooldown
 	<-_DATA[0] 1 setunitoccupiesland
@@ Line 3629: / Line 3646: @@
 # listening channels:
 	"requestWxWviableCell" "requestWxWviableCellFunction" registerformsg
-->resetSnapIndex
+->resetSearch
+->ignoreCooldown
-	# When the loop was ran through fully without finding a resolution, remember that cell for 150 frames before trying the same cell again.
+	# When the loop was ran through fully without finding a resolution, remember that cell for 90 frames before trying the same cell again.
 	list ->blockedCellV2List
 	list ->blockedCellTimeList
 	list ->nearbyUnitsCountList
-# the ONCE code from the snapping tool script
-	# <-unitBuildTypes removewhitespace ";" split ->buildList
-	# <-footprintWidth removewhitespace ";" split ->widthList
-		# <-widthList 0 do <-widthList[i] 1 add 2.0 div asint ->widthList[i] loop
-	# <-footprintLength removewhitespace ";" split ->lengthList
-		# <-widthList 0 do <-lengthList[i] 1 add 2.0 div asint ->lengthList[i] loop
-	<-voidUnitTypes removewhitespace ";" split ->voidList
-	<-anywhereTypes removewhitespace ";" split ->anywhereList
-	<-resourceTypes removewhitespace ";" split ->resourceList
-	<-nullifyTypes removewhitespace ";" split ->nullifierList
 	<-nullifyUnits removewhitespace ";" split ->suppressList
-	# unitType and prevType must be different at the start of the map.
-	<-unitType not ->prevType
-	# <-searchRange 1 sub dup dup mul swap add 2 mul 1 add ->floodRange
 :searchWxWviableCell # Output: viableCell as v2 + true/false
 # See vanilla snapping tool cpack for full commments.
-->width
+->resetSearch
+->noSkip
+->ignoreCooldown
+->checkN
+->checkR
+->placeA
+->placeV
 ->noMesh
 ->creDepth
+->searchRange
 ->cell
-->unitType
+->width
+->length
-	<-unitType <-prevType neq if
+pop # The UID has no further use.
-		# <-buildList <-unitType getlistindex ->typeIndex
-		# <-widthList[<-typeIndex] ->rangeX
+	# The following switch checks if the search should start from scratch (=1), or if it should continue (=0) on from a previous search.
-		# <-lengthList[<-typeIndex] ->rangeZ
+	switch
-		<-resourceList <-unitType listcontains if 1 else 0 endif ->checkR
+		<-resetSearch case 1 endcase
-		<-nullifierList <-unitType listcontains if 1 else 0 endif ->checkN
+		<-length <-prevLength neq case 1 endcase
+		<-width <-prevWidth neq case 1 endcase
+		<-checkN <-prevCheckN neq case 1 endcase
+		<-checkR <-prevCheckR neq case 1 endcase
+		<-placeA <-prevPlaceA neq case 1 endcase
+		<-placeV <-prevPlaceV neq case 1 endcase
+		<-cell ev2 <-prevSearchCell ev2 distancecell <-groupDist gt if 1 else
+			<-prevSearchCell ->cell # Group the search query together with previous closeby queries.
+			<-ignoreCooldown if getgametickcount else getgameupdatecount endif dup <-prevSearchUpdateCount gt if
+				->prevSearchUpdateCount
+
+			else
+				pop
+
+			endif
+		endif
+	endswitch if # If the search starts from scratch, then the new settings have to be remembered for the next function call.
+		# Adjust the footprint array depending on the requested width in the function call.
+		<-width dup <-prevWidth neq if
+			dup ->prevWidth
+add 2.0 div asint dup ->rHz 1 sub ->rLz # For the footprint loop.
+		else pop endif
+		<-length dup <-prevLength neq if
+			dup ->prevLength
+ add 2.0 div asint dup ->rHx 1 sub ->rLx # For the footprint loop.
+		else pop endif
-		<-anywhereList <-unitType listcontains if
+		<-checkN ->prevCheckN
- ->resetSnapIndex
+		<-checkR ->prevCheckR
-else 0 endif ->placeA
+		<-placeA ->prevPlaceA
+		<-placeV ->prevPlaceV
+		<-cell ->prevSearchCell
-		<-voidList <-unitType listcontains if
+		# Recreate the area to search:
- ->resetSnapIndex
+		<-searchRange 1 sub dup dup mul swap add 2 mul 1 add ->floodRange
-else 0 endif ->placeV
+		<-cell ev2 0 21 <-floodRange floodfillterrain dup getlistcount ->potentialCellCount ->potentialCells
+ ->startLoop
+->skip
-		# 0 ->orientation
+		# If the search is being reset, then clear the blocked lists.
-	endif
+		<-resetSearch If
-	<-unitType ->prevType
+ ->ignoreCooldown
+			<-blockedCellV2List clearlist
-	<-cell ev2 <-prevSearchCell ev2 distancecell 6 gt if
+			<-blockedCellTimeList clearlist
-		<-cell ->prevSearchCell
+			<-nearbyUnitsCountList clearlist
-->resetSnapIndex
+		endif
 	else
-		<-prevSearchCell ->cell
+		# If the search continues on from before, but the search range was changed, then the potential cells will need to be adjusted, without adjusting the start of the loop.
-		getgameupdatecount dup 29 sub <-prevSearchUpdateCount gt if
+		<-searchRange dup <-prevSearchRange neq if
-			->prevSearchUpdateCount
+			dup ->prevSearchRange 1 sub dup dup mul swap add 2 mul 1 add ->floodRange
- ->resetSnapIndex
+			<-cell ev2 0 21 <-floodRange floodfillterrain dup getlistcount ->potentialCellCount ->potentialCells
 		else pop endif
 	endif
-	# If the new searchRange is larger than the old one, then do not check if the cell was blocked.
+	# If the new searchRange is larger than the old one, then do not check if the cell was recently found to be blocked.
-	<-searchRange <-prevSearchRange gt not if
+	<-searchRange <-prevSearchRange gt <-ignoreCooldown OR not if
 		# Check if the cell is not on the list of blocked cells.
-		<-blockedCellV2List <-cell getlistindex dup -1 neq if
+		<-blockedCellV2List <-cell getlistindex dup -1 eq if pop else
 			->index
@@ Line 3698: / Line 3739: @@
 			# Try to purge a few old blocked cells from the lists, otherwise the list bloats.
 			-1 <-index 1 sub do
-				<-blockedCellTimeList[i] 270 add <-updateCount lt if
+				<-blockedCellTimeList[i] <-clearCellTimer add <-updateCount lt if
 					<-blockedCellV2List i removelistelement
 					<-blockedCellTimeList i removelistelement
@@ Line 3708: / Line 3749: @@
 			switch
 				# The last check on this spot was less than 3 seconds ago, so we're not checking it again now.
-				<-blockedCellTimeList[<-index] 90 add <-updateCount gt case
+				<-blockedCellTimeList[<-index] <-blockCellTimer add <-updateCount gt case
 					-1 -1 v2 false return
 				endcase
 				# The last check on this spot was longer than 9 seconds ago, so we can check it again now.
-				<-blockedCellTimeList[<-index] 270 add <-updateCount lt case
+				<-blockedCellTimeList[<-index] <-clearCellTimer add <-updateCount lt case
 					<-blockedCellV2List <-index removelistelement
 					<-blockedCellTimeList <-index removelistelement
 					<-nearbyUnitsCountList <-index removelistelement
 				endcase
-				# Check the cell again if there are now less enemies nearby than when it was blocked.
+				# Check the cell again if there are now less units nearby than when it was blocked.
 				<-cell ev2 fromcell 13 0 0 0 0 0 0 getunitsinrange getlistcount <-nearbyUnitsCountList[<-index] lt case
 					<-blockedCellV2List <-index removelistelement
@@ Line 3726: / Line 3767: @@
 				-1 -1 v2 false return
 			endswitch
-		else pop endif
+		endif
-	endif
-	<-ignoreCooldown <-resetSnapIndex OR if
-		<-searchRange 1 sub dup dup mul swap add 2 mul 1 add ->floodRange
-		<-cell ev2 0 21 <-floodRange floodfillterrain dup getlistcount ->potentialCellCount ->potentialCells
-->startLoop
-->resetSnapIndex
-	else
-		# If the search range was changed, then the potentialcells will need to be adjusted, without adjusting the start of the loop.
-		<-searchRange dup <-prevSearchRange neq if
-			dup ->prevSearchRange 1 sub dup dup mul swap add 2 mul 1 add ->floodRange
-			<-cell ev2 0 21 <-floodRange floodfillterrain dup getlistcount ->potentialCellCount ->potentialCells
-		else pop endif
 	endif
@@ Line 3748: / Line 3776: @@
 			<-potentialCells[i] ev2 @checkCenterCell if
 				@checkFootPrint if
-					i <-width 2 div asint add ->startLoop # Optimization for mass placement. When placing the next unit, skip the next 4 potential cells by increasing the index with 3.
+					i <-noSkip if 1 else <-width endif add ->startLoop # Optimization for mass placement. When placing the next unit, skip the next few potential cells.
 					<-potentialCells[i] true return # LEFT ON STACK.
 				endif
 			else
-				<-width 3 div asint ->skip # If the center cell was blocked, then also skip the next X potential cells.
+				<-noSkip if 0 else <-width 3 div asint 1 add endif ->skip # If the center cell was blocked, then also skip the next X potential cells.
 			endif
 		endif
@@ Line 3782: / Line 3810: @@
 		<-special <-meshSlot eq <-height 0 eq AND case pop pop false return endcase # Units cannot be placed on mesh in the void.
 		->cZ ->cX # Used in checkFootPrint.
-		<-checkR if <-special <-resourceSlot eq if <-minePot 1 add ->minePot endif endif
+		<-checkR if <-special <-resoSlot eq if
+			<-minePot 1 add ->minePot
+		else
+			pop pop false return
+		endif endif
+		<-checkO if
+			"platform" <-cX 0 <-cZ v3 2.9 0 0 0 2 1 0 getunits 0 getlistelement
+			getunitcell <-cX <-cZ distancecell 2.828427 approximately not if pop pop false return endif
+		endif
+		<-checkN if
+			<-suppressList <-cX 0 <-cZ v3 9 0 0 0 1 0 1 getunitsinrange 0 getlistelement getunittype listcontains not if pop pop false return endif
+		endif
 	endswitch
 	true
-	# Adjust the footprint array depending on the requested width in the function call.
-	<-width dup <-prevWidth neq if
-		dup ->prevWidth
-add 2.0 div asint dup ->rH 1 sub ->rL
-	else pop endif
 :checkFootPrint
 # See vanilla snapping tool cpack for full commments.
-	<-cZ <-rH add <-cZ <-rL sub do
+	<-cZ <-rHz add <-cZ <-rLz sub do
-		<-cX <-rH add <-cX <-rL sub do
+		<-cX <-rHx add <-cX <-rLx sub do
 			switch
 				i j
@@ Line 3809: / Line 3843: @@
 				<-placeA case pop pop endcase
 				pop pop
+				<-checkR if <-special <-resoSlot eq if <-minePot 1 add ->minePot endif endif
 			endswitch
-			<-checkR if <-special <-resourceSlot eq if <-minePot 1 add ->minePot endif endif
 		loop
 	loop
-	<-checkN if <-suppressList <-cX 0 <-cZ v3 9 0 0 0 1 0 1 getunitsinrange 0 getlistelement getunittype listcontains not if false return endif endif
+	<-checkR if <-minePot <-length <-width mul 0.75 mul lt if false return endif endif
-	<-checkR if <-minePot <-rangeX 2 mul 1 sub <-rangeZ 2 mul 1 sub mul 0.75 mul lt if false return endif endif
-	# <-checkO if
-		# "platform" <-cX 0 <-cZ v3 2.9 0 0 0 2 1 0 getunits 0 getlistelement
-		# getunitcell <-cX <-cZ distancecell 2.828427 approximately not if false return endif
-	# endif
 	true
+</code>
+</hidden>
+----
+===== Pseudo Random Number Generator, based on sinus =====
+<hidden click here for source code>
+Several basic functions based on Grabz' rng lite function of "<-seed sinus 10000 mul dup floor sub".
+Copy the functions directly into your script or run the below script in your cpack and have other scripts send messages to request a randfloat or randint.
+Difference between the functions:
+  * "seeded": provide a seed to the generator. The generated number will always be the same for the same seed.
+  * "index": these seeds are sequenced. In the same map for the same index, the generated number 1,2,3,... will be the same after map restart.
+  * "spiked": the generator is seeded with the elapsedtime of the gaming session, making the outcome uncontrollable.
+  * No prefix: these are sequenced seeds and they use index 0.
+Example code with messages:
+<code example.4rpl>
+->int
+->index
+->first
+->last # The last integer itself will be excluded.
+"sinRandInt" <-first <-last 2 listN sendmsg
+<-*sinRandInt trace
+"sinRand01" 0 sendmsg
+<-*sinRand01 trace
+"indexSinRandInt" <-index <-first <-last 3 listN sendmsg
+<-*sinRandInt trace
+"indexSinRand01" <-index sendmsg
+<-*sinRand01 trace
+"spikedSinRandInt" <-first <-last 2 listN sendmsg
+<-*sinRandInt trace
+"spikedSinRand01" 0 sendmsg
+<-*sinRand01 trace
+"seededSinRandInt" <-seed <-first <-last 3 listN sendmsg
+<-*sinRandInt trace
+"seededSinRand01" <-seed sendmsg
+<-*sinRand01 trace
+</code>
+----
+<code SinusRNG.4rpl>
+:once
+	# Creating lists and a starting mapconstant for the seed sequences.
+	createlist ->prevSeedList
+	createlist ->seedCountList
+	getmapsize 2 div swap 2 div swap dup2 getterrain 1 add dup 99999 floodfillterrain getlistcount ->mapConstant
+	# Setting up the messages so that other scripts can request a random seed.
+	"sinRandInt" "sinRandInt_CALL" registerformsg
+	"sinRand01" "sinRand01_CALL" registerformsg
+	"indexSinRandInt" "indexSinRandInt_CALL" registerformsg
+	"indexSinRand01" "indexSinRand01_CALL" registerformsg
+	"spikedSinRandInt" "spikedSinRandInt_CALL" registerformsg
+	"spikedSinRand01" "spikedSinRand01_CALL" registerformsg
+	"seededSinRandInt" "seededSinRandInt_CALL" registerformsg
+	"seededSinRand01" "seededSinRand01_CALL" registerformsg
+:sinRandInt_CALL
+	<-_DATA listtostack @sinRandInt ->*sinRandInt
+:sinRand01_CALL
+	@sinRand01 ->*sinRand01
+:indexSinRandInt_CALL
+	<-_DATA listtostack @indexSinRandInt ->*sinRandInt
+:indexSinRand01_CALL
+	<-_DATA @indexSinRand01 ->*sinRand01
+:spikedSinRandInt_CALL
+	<-_DATA listtostack @spikedSinRandInt ->*sinRandInt
+:spikedSinRand01_CALL
+	@spikedSinRand01 ->*sinRand01
+:seededSinRandInt_CALL
+	<-_DATA listtostack @seededSinRandInt ->*sinRandInt
+:seededSinRand01_CALL
+	<-_DATA @seededSinRand01 ->*sinRand01
+:sinRandInt # INPUT: integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+@indexSinRand01 <-last <-first sub mul <-first add asint
+:sinRand01 # INPUT: none.
+@indexSinRand01
+:indexSinRandInt # INPUT: the index of the seed sequence + integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+	@indexSinRand01 <-last <-first sub mul <-first add asint
+:indexSinRand01 # INPUT: the "index" of the seed sequence. OUTPUT: the next seed from that sequence.
+# The random numbers will be generated with the previous seed that is stored under that index.
+->i
+	<-prevSeedList[<-i] eq0 if
+		<-i <-mapConstant add 2357 mul @seededSinRand01 dup 10000000 mul 1 add asint ->prevSeedList[<-i]
+->seedCountList[<-i]
+	else
+		<-prevSeedList[<-i] @seededSinRand01 dup 10000000 mul <-seedCountList[<-i] 1 add dup ->seedCountList[<-i] add asint ->prevSeedList[<-i]
+	endif
+:spikedSinRandInt # INPUT: integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+	elapsedtime asint @seededSinRand01 <-last <-first sub mul <-first add asint
+:spikedSinRand01
+	elapsedtime asint @seededSinRand01
+:seededSinRandInt # INPUT: integer seed + integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+	@seededSinRand01 <-last <-first sub mul <-first add asint
+:seededSinRand01
+	# abs <-power pow <-add add sin <-sinMul mul dup floor sub
+.05 pow 99419 sub sin 619 mul dup floor sub
+</code>
+</hidden>
+----
+===== Pseudo RNG based on Linear congruential generator (LCG) =====
+The downside of the above sinus based functions, is that they have few resulting digits. They are more than adequate to pick a random cell on a map (max 512 possibilities), but unsuited for generating random numbers larger than a few thousand.
+The below LCG functions should work for up to 6 digits = 10^6, but I've only done a test up to 10^5. Rolling 1 million random integers between 0 and 10^5 with @lcgRandInt, missed only 8 possible results. The same test with @sinRandInt missed 42458 possible results.
+<hidden click here for source code>
+<code LinearCongruentialGenerator.4rpl>
+# Quick Example.
+10000 @lcgRandInt
+:lcgRandInt # INPUT: integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+@indexLcgRand01 <-last <-first sub mul <-first add asint
+:lcgRand01 # INPUT: none.
+@indexLcgRand01
+:indexLcgRandInt # INPUT: the index of the seed sequence + integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+	@indexLcgRand01 <-last <-first sub mul <-first add asint
+:indexLcgRand01 # INPUT: the "index" of the seed sequence. OUTPUT: the next seed from that sequence.
+# The random numbers will be generated with the previous seed that is stored under that index.
+->i
+	<-prevSeedList[<-i] eq0 if
+		<-i <-mapConstant add 13 mul @seededLcgRand01 dup 10000000 mul 1 add asint ->prevSeedList[<-i]
+->seedCountList[<-i]
+	else
+		<-prevSeedList[<-i] @seededLcgRand01 dup 10000000 mul <-seedCountList[<-i] 1 add dup ->seedCountList[<-i] add asint ->prevSeedList[<-i]
+	endif
+:clearIndexSinLcgRand
+	<-seedCountList clearlist
+	<-prevSeedList clearlist
+:spikedLcgRandInt # INPUT: integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+	elapsedtime dup 10 log ceil 7 sub neg 10 swap pow mul asint <-spikedLcgAdd 1 add dup ->spikedLcgAdd mul @seededLcgRand01 <-last <-first sub mul <-first add asint
+:spikedLcgRand01
+	elapsedtime dup 10 log ceil 7 sub neg 10 swap pow mul asint <-spikedLcgAdd 1 add dup ->spikedLcgAdd mul @seededLcgRand01
+:seededLcgRandInt # INPUT: integer seed + integer first randInt + integer last randInt. OUTPUT: an integer in between the first and last randInt, excluding the last randInt.
+->last
+->first
+	@seededLcgRand01 <-last <-first sub mul <-first add asint
+:seededLcgRand01
+	asint 1103515245 mul 12345 add abs asfloat 2147483647 div 10 mul dup floor sub
+:once
+# Creating lists and a starting mapconstant for the seed sequences.
+	createlist ->prevSeedList
+	createlist ->seedCountList
+	getmapsize 2 div swap 2 div swap dup2 getterrain 1 add dup 99999 floodfillterrain getlistcount ->mapConstant
+	# <-SEED ->mapconstant # Alternative for map constant.
 </code>

Knuckle Cracker Wiki

User Tools

Site Tools

Differences

Page Tools