okay, now we are getting somewhere,
I could automate the process of creating new ODS based of the top player’s value then divide and multiply it by the numbers of digits if that makes sense so
if the number 1 player has 7 figures I could use 1000000 as x, the divider and multiplier
now the hard part is automation and scalability
my idea of how the code should be is set there once and never touched again, I don’t have time to maintenance it.
Just carry the overflowing bits into another OrderedDataStore.
what how?
please explain your genuineness
I should go to sleep it’s mid night, I’ll be back
For example if you divide the number 10 by x
then when you the value is returned you multiply it by x again
the value should be scaled to what you want.But for higher numbers you can increase the value x, to be multiplied with all values , so the resulting value should be same.An increment in the value x to be multiplied with v must be considered when your number gets increasingly larger, so basically just set your value to be multiplied with a huge number depending on how high you values can go.
And also a script that uses tostring like :
local num = 1e19
local str = tostring(num)
dataStore:SetAsync(key, num)
--Loading:
local num = 0
local result = dataStore:GetAsync(key)
if result then
num = tonumber(result)
end
or num x from the divided value ,or you could serialize this lua code for your game
and to save the string
game.Players.PlayerAdded:Connect(function(plyr)
local a=Instance.new("StringValue")
a.Parent=plyr
a.Name="Characters"
for i=1,#stats do
local stat=Instance.new("StringValue")
stat.Parent=a
stat.Value = "None"
stat.Name=stats[i]
end
for i , v in pairs(plyr.Characters:GetChildren()) do
local success , value = pcall(function ()
return ds:GetAsync(plyr.userId..v.Name)
end)
if success then
if value then
v.Value = value
else
end
end
end
end)
Multiple methods exist for what you’re trying to achieve,as aforementioned
and implementation of BigNum,for instance
function decr( bnum1 )
local temp = {} ;
temp = BigNum.new( "1" ) ;
BigNum.sub( bnum1 , temp , bnum1 ) ;
return 0 ;
end--this one's just a part of the whole module needed to be serialized
sorry, I don’t think BigNum is compatible with OrderedDataStore as it only accepts Integers not Tables nor Strings;
not sure if I fully understand what you are suggesting but I am not using regular DataStore
I’m using OrderdDataStore NOT DataStore, they are not the same @XxELECTROFUSIONxX
but why would you want people to have numbers or values that aren’t integers?
or does your game require such precision in saving certain values to keys in a table for example?
edit–or values like 9.2223 quintillion
from another post -
just for instance,when youve got too large of a string
and in OrderedDatastores your value must be an integer
You should only use an Ordered DataStore for ranking systems as they are inefficient because they only store integers which will require a lot of requests to get each piece of data.
I’m not sure how many players you’re showing in the top leaderboard, but I’m going to assume 100 (because it’s simple).
Here’s what I’m thinking: When a player has the number updated, it will be saved in the ODS. If this player is the top player, the server should fetch all top 100 entries. With these entries, it should check if any of them are closing up to the max-number. If they are closing up, it should divide all the entries by a set number, and update them. Now, you’ve fixed the problem of dividing it.
But, what if someone else gets their number increased? (I will be talking about the number as money from this point…). If you were to insert someone in the “top ODS”, you don’t know what to divide their money on? There’s a simple fix for this. Whenever you divide the top players’ money, you should save the number to divide it with in the database.
Moving on to how this works:
Let’s say you have 3 players in your leaderboard, which will look something like this
They are now approaching the max number, which is 10,000,000. The server should now divide all numbers with a number, for example 1,000,000. This would result in the players getting the following money:
But wow, they just lost all their money! No, because if you save the number you divided the money on, you know what to multiply the numbers with in order to display them.
Now, let’s say we still have the 3 same players in our table, with the money divided:
And, let’s assume Joanna just got 8,300,000,000 money. The server will then divide the money by the number saved in the database. This will make the number become 8300. Now, she’s #3 in the leaderboard and it’s easy.
EDIT: Yes, there is an issue with this method. Stupid decimals. But one step at a time.
The best solution for you, would be to simply use an external database service where you can easily sort the top values!
What I did was use a bit of math to get around it.
local value = 9.99e50
local storedValue = value ~= 0 and math.floor(math.log(value) / math.log(1.0000001)) or 0
print(storedValue) -> -- 1174308450
local value = ...
local retrievedValue = value ~= 0 and (1.0000001^value) or 0
print(retrievedValue) -- 9.9899995470475e+50
The idea is that you shrink the number and stretch it again afterwards, this WILL cause a loss in precision. But with huge numbers that are most likely rounded for leaderboards anyways that’s not an issue. The larger the number you’re trying to store the less precise it’ll be. So for smaller numbers it’ll be accurate.
You perform the first math operation and save the value to the DataStore, then when you load the value you perform the second math operation. Sorting will still work for this because the numbers still represent the original value correctly.
Also make sure not to pass 0 into the equation, or you’ll get a “division by 0” error. Hence why I used a ternary operator to make sure it’s not 0. Since 0 can just be stored and loaded as 0.
or as @1TheNoobestNoob has illustrated my point, but not noticed that
but as @Dysche mentioned , larger numbers for higher-level players rounded on the leaderboard shouldn’t have to matter either.
Just a thought, would you be able to use 0x numbers and binary?
I’m not certain if it’ll be ordered but it’s something you could try.
Wouldn’t work, theres no real way to get around it without either losing the sorting ability, precision or hitting the max value.
Interesting what kind of black magic is this?!
so you are certain that it can be used with OrderedDataStore?
ps (couldn’t careless about precision)
Yes, I use it for my games. Works perfectly. You can try it yourself by just putting in random numbers and manually sorting them to get an idea of how it works.
I figured out this answer with the help of some clever people in the Hidden Developers Discord server. I ran into the same issue a few weeks ago.
Thank you!
sounds very promising!
sadly I don’t know how to use an external database service
the method is also complex but seems like fun to work on but I’ll try Dysche’s method
But that’s what we want,we’ll have to lose precision of the values,but that precision could be taken back with dividing/scaling numbers with a very large value before it is sent as a string, unless he’s not doing that in which case I don’t see a work around for the precision/sorting/cap problem
OrderedDataStore only accepts integer values, so the whole string idea wouldn’t work really. I’m assuming OP is trying to create a global leaderboard system so using normal DataStores wouldn’t work.
So something like this?
Can you explain how math.log and math.log10 works for future reference?
Thank you, you are a saint!
Where have you been an hour ago?! 
You could also store the integers in a similar format to floating points. Use the first 7 digits for the exponent, and the last 10 digits for the first 10 digits of the number being stored.
For example, the number
000000501234567890
Would represent the value
1,234,567,890 x 10^50
This is sorted correctly, as the exponent is listed first. Any number with a higher exponent will be greater than a number with a smaller one, and if the exponents are the same, the digits of the number are compared.
The advantage over Dysche’s method here is that it’s clear how many digits we have to work with (10,000,010), and we get exact precision for the displayed digits, though either system will work.
Edit: Thinking about it more, this option will also allow you to store the largest numbers for any given level of precision.
While Dysche’s representation provides more than enough digits for any reasonable situation (several million digit long numbers), it stores more information than is necessary (partially accurate information about unused placevalues). The floating point representation has exactly one representation for every value (within the given precision), and all possible representations correspond to a value, giving the maximum possible number of values for a given length representation.
For the level of precision he used (accurately storing the first 6~ digits), he could store 10,000,000x fewer digits than a floating point representation.
This is all useless trivia, but perhaps someone will want to store a value with 15 quintillion digits in an ordered datastore one day.
Yeah, that’d work as far as I can tell.
The log function is basically an inverse exponent, so you’re getting the original exponent back from the value. For example: 2^6 = 64, log2(64) = 6
Log10 is basically the log function for base 10. Like log(10, n) or 10^n inversed.
The number following log in lua basically stands for the base. You could also do log(x, y) in lua.
(This might seem like a too-simple explanation to the real mathheads reading this but this is a simplification.)
You save my life xD
I can finally have a leaderboard for my sim