Save-Load codes 1.24

[Moderator]

12th Dec 2015
IcemanBo: For long time as NeedsFix. Rejected.

IcemanBo:

TriggerHappy's critiqute is still not solved. Also look for posts by Nestharus in this thread.

TriggerHappy

09:31, 19th Sep 2014
TriggerHappy:

Nestharus' post covered most of it.

The system is almost completely hardcoded and offers almost no customization when it could have easily been the other way.

 

[deathismyfriend]

This should be able to save custom resources as well.

Remove the BJs.

Remove the TriggerAddAction and do everything in the TriggerAddCondition portion of the code.

 

[shadowvzs]

This should be able to save custom resources as well.

Remove the BJs.

Remove the TriggerAddAction and do everything in the TriggerAddCondition portion of the code.

do you copy paste everywhere same?

(i dont say not possible i let BJ, but i dont noticed yet where i left it)

custom resource why?

 

[The General]

I still don't get why these save load codes need to have Long arse codes

 

[Chaosy]

tbh it seems to be a pain to use since you need to add every single item. There should be a boolean that you can set to true if you want every single item to be saved.

 

[shadowvzs]

tbh it seems to be a pain to use since you need to add every single item. There should be a boolean that you can set to true if you want every single item to be saved.

do u mean saved to variable and that pain?
its a copy a copy paste and maybe change the index...
if you readed the map init trigger and the link there then you also understand what u say takes maximum 1 minute if you want different item...

also map include every normal item code at disable trigger so if dont want use my other map for save items and copy here then just copy from that trigger and change index... so what is pain in that?

other side could work without saveing any item to variable ofc, cost of 4 char instead of the 1-2 char length

I still don't get why these save load codes need to have Long arse codes

its dynamic, u can save a simple hero and check then the code length, other side since code saved directly into file i think its a select+copy+paste is fine, are anyone said to you type manually the code? lol

please read the info and triggers 1st

 

[Chaosy]

Still it 'requires' another system which can't be good in this case. (or at least not optimal)

instead of listing items that can be saved, isn't it better and easier to list items you don't want to be saved?

I am not in need of such a system at the moment, I just share how it would have thought if I were in need of one, if you will.

 

[shadowvzs]

Still it 'requires' another system which can't be good in this case. (or at least not optimal)

instead of listing items that can be saved, isn't it better and easier to list items you don't want to be saved?

I am not in need of such a system at the moment, I just share how it would have thought if I were in need of one, if you will.

so if i understand instead store 70-80 item to variable better save 200 what i don't save?
in game have around that much and in this map for example i used 73 item type

other side you don't need other system except if u want do it fastest way (also need use only 1X with that system too, not bigger difference than implent a dd's to your map except this isn't required and have other way also here need copy-paste and not add more trigger), like said above there a disabled trigger what i isn't copied here, where was saved every item with id and raw code and that direct form, what u can simple copy past from that trigger to header and change item index, that isn't pain really.

since to every item on list in disabled trigger also got name u easily select what u want save or what not, really copy pasteing dont make bigger effort like example create variable if at settings was disabled the create unknow variable.


about item saveing:
1 character tell where is the 0-6 item, like 1-slot 1 item filled, 0 if slot1 empty, 2 if slot2 filled and 0 if empty, 4 if slot 3 filled and 0 if empty.... 32 if slot6 filled 0 if empty and add to each other, so if each slot filled it is 63 what is 1 character length in base 73 and from that number we can know each item position because work like 6 boolean in 1 number
if this not 0 then next 1 character tell the item type via give index in item type array, if this is a charged item type and max charge for item not 1 then next char tell the charge amount, next char tell the 2nd item index in array this till 6th item.

so basically if u got no item then in save load code u have 1 charater, if u have 6 normal item then 7 character totally the item part, if u have 6 item with all charged and 2-3 charge then it is 13 character, if u save raw code then it is 4 character each, 6 item became 24 character and 1 who say the slot so 25 then if u add charge to each then 31 character, i hope u got it why i used item array.

(btw if u disable with boolean in map init the item saveing then 0 character )



if someone experienceing the simple save load could be around 3x less than if u enable everything and got high amount from everything, thats why code length dynamic. btw only the crc code is 4 character long to be more sure peoples can touch it too easy

 

[deathismyfriend]

do you copy paste everywhere same?

(i dont say not possible i let BJ, but i dont noticed yet where i left it)

custom resource why?

No it just happens so many make the same mistake although I should make a file so I can copy and paste it. It would be easier for me.

Any of the red text is a BJ function call there are a few in your system that should be removed.

Custom resources should be able to be saved because several maps have them. Why should they use your system if you don't make it work for almost everyone ?

 

[shadowvzs]

No it just happens so many make the same mistake although I should make a file so I can copy and paste it. It would be easier for me.

Any of the red text is a BJ function call there are a few in your system that should be removed.

Custom resources should be able to be saved because several maps have them. Why should they use your system if you don't make it work for almost everyone ?

(about red text, yes have few, like moduloint but since rarly used i let it there, why? because if someone who not expert easier understand the that than if i replace with a math formula what maybe peoples dont understand why i do that) so let that stuff what dosn't do too much system call but alot help to understand why it is there.


but what u mean under custom resource? still isn't clear to me, saveing custom integer?

 

[Nestharus]

Those codes are enormous. What are you using, MD5? Lol


I'll take a look at this later, I'm curious ^)^

 

[deathismyfriend]

(about red text, yes have few, like moduloint but since rarly used i let it there, why? because if someone who not expert easier understand the that than if i replace with a math formula what maybe peoples dont understand why i do that) so let that stuff what dosn't do too much system call but alot help to understand why it is there.


but what u mean under custom resource? still isn't clear to me, saveing custom integer?

You also have this BJ.

GetPlayableMapRect()

Yes custom resources as in something other than gold / wood.

 

[shadowvzs]

updated with custom value saveing, alter if i have time i will do demonstration too

 

[deathismyfriend]

You still did not inline the BJ functions.

 

[shadowvzs]

because don't really change on anything these function since they isnt spammed or something and improve more on understanding for very very minor cost
(GetPlayableMapRect(), moduloint)

i added into map a demonstration about how to use 2 number (each +1char and value each max 63) for handle 6 quest if they are discovered or no, completed or no etc.

so added 6 quest (5 chain and 1 optional)

 

[deathismyfriend]

How is this hard to understand bj_mapInitialPlayableArea compared to this GetPlayableMapRect() ?

 

[shadowvzs]

How is this hard to understand bj_mapInitialPlayableArea compared to this GetPlayableMapRect() ?

changed but to be honest, this have absolute 0 importance if someone use it in gui, do you think its speed up atleast with 0.0000000000001sec? i am not sure

 

[Nestharus]

I looked at it ^)^. It's some of the worst coding I've ever seen : D


1. The hell?

function CodeType takes string t returns string

2. Too much

function ColorCodeString takes string s, string numColor, string lowerColor, string upperColor, string specColor, integer start returns string

You can make it so much simpler

3. With the names of the variables and the convoluted process, I can barely even tell what this does

4.

function ItoS takes integer i, integer len, string t returns string

It appears to just convert each integer into the base of the alphabet, which is really, really bad, lol. TriggerHappy's does it better.

It also has a bunch of extra stuff. The function is way too heavy weight. You need to represent your data as a number, it'll make everything so much easier. Either that, or you need to convert a number into a string and return it given an alphabet or something. This just does way too much. You need to split it up a lot.

5.
function SPos takes string s, string t returns integer

No idea what this does from the function name and don't care. I'm assuming that it is a string search function that returns the index of the first instance of the character/string.

6. There's this thing called the hashtable. O(n) loops over strings are so damn old school, lmao.

function StoI takes string c, string t returns integer

7. Why is this in your save/load system?!

function GetItemMaxCharges takes integer id returns integer

8. And this..

function HeroDatabase takes integer id, integer index returns integer

9. This too ...

function DeclareItems takes nothing returns nothing

10. -.-

function ItemDatabase takes integer id, integer index returns integer

11. All of the if-statements in this... jeezes, and it does so much extra crap that it shouldn't be doing... what if they don't have a hero, or don't care about stats, etc? You ganna save that stuff anyways?

function MakeSaveLoadCode takes player p returns nothing



Conclusion:

I can see why this produces hellishly long codes now compared to other systems. It isn't flexible, it isn't scalable, it isn't modular, it's extremely difficult to maintain and is very difficult to read, and it's a very heavy weight resource. It essentially fails to meet any of the requirements of MEDA, which defines what good quality software is ^)^. Even the usability is negative because this can't really be configured unless you modify the actual code. If you have to modify the system to use it, that's bad = P.

Considering all of this, I would honestly trash it and start over. You need to break the problem up into pieces. How are you going to handle the data? Make a resource for that. You can either do bits or arbitrary bases, both are legit. You also need to consider save/load techniques. Rather than include a bunch of stuff in your system to make it super heavy weight, rip them out and make them standalone resources. Someone may want your database thing, but they may not want to use your actual encoding algorithm, etc.

There is a lot, but I think this is a good learning experience ; ).

This is an all in one package, and that isn't good at all. The bigger something is, the more likely it is to fail and the more likely that it is going to suck. It's difficult to maintain the quality of something enormous. That's why things are broken down into small pieces and put together like a puzzle.

Right now, i'd give it a 1/10, but nice effort ; ). I can tell this is your first attempt.

I'm a harsh reviewer, I get that, but I'm also honest and upfront. I really recommend you just start over from scratch and use what you learned in the previous attempt to make something better. When I code something that bad, I just start over =). Some things may be able to be salvaged, this line of code or that, but yea.


Think more generic. It's not about what you are going to save, it's about what you might save and what you might not save. Save/load systems are all about producing small codes. The smaller the code, the better. You don't want to pack a user's code up with a bunch of extra fluff that they are never going to use, do you?

Go away from options and configurables and go more to making your system adapt to anything. It's not about including 1001 things and 1001 booleans to enable/disable those things, it's about making a skeleton that people can plug things into.

When I first started out, I was just like you. It took many, many years to get to where I am now, so don't be demoralized by this ; ).

Also, when you use JASS, you need to consider encapsulation. You should prefix your variables with like LIBRARYNAME_.

Fix your variable names. Your code is practically impossible to read because they give no insight as to what they do.

Comment your code. If you have a huge block of code that does something, put a little note at the top of it that says what it does, this way someone doesn't have to trace your algorithm to figure out what it's purpose is. You don't need to comment every single little line (unless there is a good reason too, like an operation that might seem strange), but you should definitely comment algorithms and explain why you are doing them. Keep them short and simple, don't get carried away like some people and write huge novels, lol. It's faster to read the code than to read a huge 1000-line novel : P.



Those are my tips. To anyone thinking of using this, just use TriggerHappy's ; ). It's very GUI friendly and is much better.

Also, about the only way you are going to bring something new to the table with save/load is to do a good GUI save/load system, meaning arbitrary bases. There are some out there, like Neostorm's, that use bits. Pipedream's uses arbitrary bases and has GUI support (go go), but it has a few ... errors. You can actually start from his code and fix the errors if you want ; ), but I warn you, the errors are not so easily fixed =).



Nice attempt, but this is definitely not useful at the moment. It probably wasn't the right time to submit it ^)^. We do have a place called The Lab.


I'll rate this 1/5 for now to let people know to stay away. I'll update the rating to reflect your changes in the future.


Keep in mind, this isn't about you. This isn't about stroking your ego or being nice to you and approving it. This is about the users. Do we really want to mislead the userbase into using this when there are much better systems out there? Take this opportunity to improve yourself ^_^.

I'm also about the harshest review on the site, so this is about as bad as it's ganna get ; P.

edit
Here is a bit manipulation library that is practically raw JASS.

https://github.com/nestharus/JASS/blob/master/jass/Systems/BitManip/script.j

You can remove the module initializer and initialize the system yourself and remove the library wrappers and you'll have plain JASS. You can also change the single global to a udg_.

That will drastically reduce the size of your codes. The system isn't difficult to use either ^)^.

Test it out a bit to see how the functions work.


If that is too much, there are bitwise operator libraries in the JASS section.

 

[shadowvzs]

i check later atm got only time to write a reply

i agree with my jass style is kinda chaotic, and few place maybe needed few label but one reason was i dont wrote label because if someone use in gui dont need touch there.

my english also not the best like my creativity with names, thats why there CodeTypes[/s] what for me a function where have more randomized numericalphabet with syntax so string what i use for encode.

during time few function i dont used anymore but still not removed like ColorCodeString,GetMaxItemCharge - i not was sure if remove definitly or no

There's this thing called the hashtable. O(n) loops over strings are so damn old school, lmao.

i tryed make the system with if posible the low amount of variables also if posible avoid the hashtable if not needed, since saveing not periodic thing i am well with old stuff methode

BTW. Spos coming from string position what often used in php, basic etc
in every language similiar methode, a function where have a big string, a string what we search, starting place

11. All of the if-statements in this... jeezes, and it does so much extra crap that it shouldn't be doing... what if they don't have a hero, or don't care about stats, etc? You ganna save that stuff anyways?
.....................................
It isn't flexible, it isn't scalable, it isn't modular, it's extremely difficult to maintain and is very difficult to read, and it's a very heavy weight resource

why flexible?
u set in gui if want save the hero stat[3stat],resource[gold,lumber],coordinate, items and all with boolean in init and you can add your own custom value (0-2kkk) in save trigger, you set the verification code size and the player name binding to code also boolean[yes or no], the custom value amount what want save

yes that point right it's allways save the hero exp and class type.


after that still why flexible? you can change the "encrypting" string (add or decrease the length), system save a 50000 level hero,200mil str/agi, 2kkk exp hero without touching/changing anything to gui users, basically with custom values can save any other thing aswell, and that also could be 0-2kkk, could be used for save other stuff like in demonstartion i save 6 quest stuff.

how flexible more?
the code included the version number, what if someone want edit the jass core loading part then just make example a if VERSION == 2 then and organise how he want anything and still old codes useable too because they are loaded with VERSION==1 way...

i know wouold be change the how organised the function, i will do it, but i can't call this trash only because maybe this way for save load code outdated (its my 2nd try, 1st was make Aceheart save load code in ~2004 from thehelper in jass around alot year ago )

btw i know about percentage stuff and compress int function but both inaccurate, lets say if someone want make a rpg where hereo could be high level and need alot exp for level but exp gaining slow then annoying that also i dont save level just exp and if i same percentage than need save level too, what in result same in length.

later if have time check ur link

[update]
i made that, i puted function to header and map init the array, but honestly no ideea what it must do or what it do?
i thougth it compress the number, but only read bits give shorter result rest of stuff what i tryed did a 2 based string

  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (1234567890,0,10)) ) //588
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitNumber(ReadBits (1234567890,0,10))) ) //0
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitSize(ReadBits (1234567890,0,10))) ) //588
  call DisplayTextToForce( GetPlayersAll(), Bits2String (1234567890) ) //1001001100101100000001011010010
  call DisplayTextToForce( GetPlayersAll(), Bits2String (ReadBits (1234567890,0,10)) ) //1001001100
  call DisplayTextToForce( GetPlayersAll(), Bits2String32 (1234567890) ) //01001001100101100000001011010010

i check

Those are my tips. To anyone thinking of using this, just use TriggerHappy's ; ). It's very GUI friendly and is much better.

to be honest what you talk about?
- don't save the item position and item charge
- save the level only and no exp, if i was at 98% close to next level still lower level
- don't save to file, i really don't want anymore typeing codes, atleast this can copy under sec without bluring my eyes
- with same save option[no coord, lumber save, less crc code length] that generate similiar and sometimes his longer length without the "-"'s (except if we don't count 2 char in mine what both could be removed - version number, encodeing string identifier)

only pro is in functions and not in output, and that is he wrote organised the save load and workk without hero

 

[Nestharus]

1234567890 would be the number in base 10

01001001100101100000001011010010 would be the number in binary (base 2)


If you work with bits instead of your huge characters, you have a lot less space in between your information, which makes your codes much smaller.

If you wanted to save a 1 in base 63, that would take up a full base 63 digit. 63 happens to be 6 bits. That value, 1, could be saved using only 1 bit. That's 5 bits of empty space.

You end up with this

000001

Instead of

1

So what if you wanted to save two 1's? Now you get this.

000001000001

Instead of

11

Do you see where I'm going with this?

Binary still has empty space between values. Unless a value is a power of 2, there is going to be empty space. This space is in fractions of digits.

For example, something may be able to be stored with a max value of 5

101

That would be your max value in binary. Notice how you aren't utilizing all of the bits? If you were, your max value would be

111

With arbitrary bases, any given value takes up a single digit in a target base, that base being 1 higher than the value.

Want to have a max value of 9? Use base 10

9999999

0 space in between the values

Want a max value of 2? Use base 3

222222

Want a max value of 5, then 3, then 9?

5, 3, 9 (not base 10, 3 numbers in base 6, 4, and 10)

In base 10, the above would be

239 (a bit smaller than 539, this is because there is 0 space in between the values)


Binary would have much less space in between your values and has nice/easy math that goes with it. If you want to reduce your code sizes w/o a ton of overhead, binary is the way to go. If your final output base is a power of 2, converting between binary and it is trivial.

For example, base 16 is a group of 4 binary digits

f = 1111 (f is 15)

0xf = 0b1111

Your ideal base would be base 64.


Now let's analyze your output

Bits2String (ReadBits (1234567890,0,10)) = 1001001100

Here is the complete 32 bit binary representation of 1234567890

01001001100101100000001011010010

Can you spot 1001001100?

[01001001100]101100000001011010010

Think of the above as an array

array[0] = 0
array[1] = 1
array[2] = 0
array[3] = 0
array[4] = 1
array[5] = 0
array[6] = 0
array[7] = 1
array[8] = 1
array[9] = 0
array[10] = 0

It goes from 0 to 31.

In this regard, using this system, an integer is a 32 slot array. Each slot holds either a 0 or a 1. You can combine these slots together to form bigger values.

If you want to store up to 5, you can take 3 array slots, similarly to how you would take several characters in your code to store a number.

Feel free to use these functions to pack your data more tightly ^)^.


ReadBits - reads values in the array from a start position to an end position, similarly to SubString. Returns everything as 1 value.
GetBitNumber - 2^n, where n is your input. If you give it 0, it'll give you 1. If you give it 31, it'll give you 2^31.

There is also WriteBits, which writes to the end of your array. You just tell it how many slots to take up and then what to plug into those slots. It'll return the number with the written bits. There isn't a function that'll write at an arbitrary position atm.

PopBits will remove either the first bits or the last bits from the array. I don't remember which, you can test it.


These functions transform an integer into an array of size 32, where each slot can hold either a 0 or a 1. Use it how you will ^)^.

 

[shadowvzs]

i undersand the binary, hexadecimal numbers but no ideea this how to help on me, i mean i got the 74 in base 73 is waste in ur binary view point but no ideea how its became string or and from binary functions i understanded only few, the storeing 5 to 3 slot i understand because used it, i know 1st char have 0/1 next 2 or 0 then 4 or 0 etc so 2^position or 0 depend it is 1 or 0.
bit2string is okey, its convert decimal to binary, readbit i understand read/calculate a part of the string but i dont see where its became needed, same the shift and rotate or pop bits, it is only just tool? because if i converted my decimal to binary i dont know why would swap 2 index in array.
read bit i noticed give back the input value

  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (1234567890,0,31)) ) //1234567890
  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (1234567890,0,10)) ) //588
  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (4,0,31)) ) //4
  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (4,28,31)) ) //4
  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (4,0,31)) ) //10
//i guess the bits counted from right to left and read bits work from left to right thats why need to be 31 the value

  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitNumber(1) )) //1
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitNumber(2) )) //2
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitNumber(3) )) //4
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitNumber(8) )) //128
//so this simple like u wrote put 2^(input integer-1)

  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitSize(3) )) //2 because in binary 11
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitSize(8) )) //4 because in binary 1000
  call DisplayTextToForce( GetPlayersAll(), I2S(GetBitSize(9) )) //4 because in binary 1001
//so its like if binary would be string then this give the StringLength of binary string i guess GetFreeBits=32-GetBitSize(n)
  call DisplayTextToForce( GetPlayersAll(), I2S(GetFreeBits(GetBitSize(9)) )) //29 no ideea how not 28 if 32-4 could be 28
  call DisplayTextToForce( GetPlayersAll(), I2S(GetFreeBits(GetBitSize(1)) )) //31 that i got, 32-1

  call DisplayTextToForce( GetPlayersAll(), I2S(PopBitsFront (64,3) )) //8
  call DisplayTextToForce( GetPlayersAll(), I2S(PopBitsFront (64,2) )) //16
//no ideea what/why this do that but look like if 1st input is 2^x then its give back the 2^(x-2nd input number[what was 3,2]) so 64 is 2^6 and 2nd input 3 => 2^(6-3)=8, 64 is 2^6 => 2^(6-2) = 16

//for be look like work same way the back and front too

set n = 64
  call DisplayTextToForce( GetPlayersAll(), I2S(ReadBits (n,31-GetBitSize(n),31)) ) //64
//i just tested :)

would be nice see how u convert example 45 to string step by step?
btw what u do if u have 2 number? like 8 and 8? u put this 10001000 like string then code this string somehow and compress? then how to make difference between where its start and end?(i mean how much space takes) since i guess u dont save delimiter or character (like me) what tell the next number length in code? about arbitrate there is no enough alphabet or syntax for use it, i was able to use only ~80ish string so i am a bit confused how became binary at end a short string

 

[Nestharus]

Let's take two values

gold
hero level

Let's suppose that the max gold a player can have is 75,000. This max value is important**

Let's suppose that the max level a hero can be is 60.

Let's also take a third value, some custom arbitrary value, and we'll say that the maximum value it can be is 95.

We now have 3 values with the following maximums in this order

75000
60
95

The first step is to figure out how many bits a given number occupies

GetBitSize(75000) = 17
GetBitSize(60) = 6
GetBitSize(95) = 7

Now our data will be mapped like this (in binary)

00000000000000000 000000 0000000

The next step is to take a set of integers. We'll slowly build upon this set of integers. It can be a linked list.

Each integer can store a total of 32 bits. In this case, we only have 30 bits, but if we had more, we'd have to add more bits as we ran out of room.

So, first you take your number

75000

next you get bits it requires

17

now you make room for 17 bits in your code

(if no room in current integer, add another)

now you write to your integers (1-2). If you are writing to two, you'll write a portion of the bits to the first integer, and the rest to the second. In this case, it's just one.

code = WriteBits(code, gold, 17)

Now for the next number, 60 and 6 bits. There is enough room in your integer to store it.

code = WriteBits(code, heroLevel, 6)

last one

code = WriteBits(code, customValue, 7)

Now we have the integer formed.

When checking to see if you have room in the 32-bit integer, you will use GetFreeBits(code)

Assume that we have base 64, so a 64-character string to output data in. Each character can hold 6 bits. This means you will take 6 bits at a time and turn it into a character.

Taking our original data

00000000000000000 000000 0000000

We now partition it like this using PopBits (this gets from the back!)

[000000][000000][00000 0][00000 0][000000]

just have an array like array[value] = character. The values are the things between the [ ]. That will be 5 characters.

Let's assume that they are

aaaaa

To go back, just convert the characters into values and you will have your data back.

LoadInteger(table, StringHash("a")) -> value

Keep in mind that you want to read from the last character to the first. PopBits or w/e will give you the last thing you wrote first.

[000000][000000][00000 0][00000 0][000000]
1---------2---------3----------4----------5

code = 54321

so you want to read your code in reverse to put everything back into the correct order.


How do you know how your data is split up? You know the max values, so you know exactly how many bits each thing occupies.

For you, the data looks like this

00000000000000000 000000 0000000

No need for delimiters when you know how big each space in the code is.

What about writing across 2 integers?

Suppose we wanted to add another value to our 32-bit integer. Our 32-bit integer only has 2 bits left. The value is 6 bits.

code1 = WriteBits(code1, ReadBits(value, 0, 1), 2)
code2 = WriteBits(code2, ReadBits(value, 2, 5), 4)

ReadBits is a very inefficient function. You want to convert this into pops (front pops).

Front pops will take off of the end and return the front. Back pops will take off of the front and return the end... I named them wrong ; p, was naming by how the operation/numbers actually work, not how the function seems to behave : ).

In reality, a number is a stack.

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

You always write to the right and it goes left. Pop front would pop the stuff at the front of the array (the right) and shift everything down to fill it up. It returns the remaining bits. This is why PopFront(64, 2) gives you 16, because it takes off the 0's. It's the same as 64/2/2, which is 16.

This gives 29 because you are using it wrong -> GetFreeBits(GetBitSize(9))

It should be GetFreeBits(9), which is 28. You were doing GetFreeBits(4), because GetBitSize(9) gives 4. GetFreeBits(4) is indeed 29.



You keep saying that this is compression. This is not compression.

edit
I would just allocate a chunk of 24 integers and then use what you use. That's the number of integers you need to display any amount of data in wc3. If you are doing codeless, then there is no limit, but still, I'd prob cap it at 500 for codeless.

 

[shadowvzs]

the 3rd value could be anything or u added only for show save 3 value, or it make something and its value important? or could swap it to exp?

this is currently and //the displayed result after the displaytext

local integer MaxGold = 75000
local integer MaxLv = 60
local integer MaxAr = 95
local integer Gold = 72000 //current gold
local integer Lv = 55      //current level
local integer Ar = 80      //curent idk what :D
local integer LGold = GetBitSize(MaxGold)   //max gold space in binary
local integer LLv = GetBitSize(MaxLv)    //max level space in binary
local integer LAr = GetBitSize(MaxAr)    //max ar. space in binary
local integer code1 = WriteBits(2, Gold, LGold)
local integer code2 = WriteBits(2, Lv, LLv)
local integer code3 = WriteBits(2, Ar, LAr)
local integer rc1 = ReadBits (code1,31-LGold,31)
local integer rc2 = ReadBits (code2,31-LLv,31)
local integer rc3 = ReadBits (code3,31-LAr,31)
local string rs1 = ItoS (code1, -1)
local string rs2 = ItoS (code2, -1)
local string rs3 = ItoS (code3, -1)  //converted to string, based on 64 length string

curious how to compress it because till now the code longer than with normal methode
oh and how to merge the numbers (gold,lv and ar merge into 1 number? in save load tutorial was something stack and 3 number into 1 but that became huge)

it was good till now?




[topic off] same time i check ur interactive save load and there at 48 where save unit and get 2 string piece (exk) when i load multiple time sometimes it is full hp and 0 mana instead 50-50% hp and mp

in 53 if i use twice the load same code give several item only and have bounds error

 

[Nestharus]

So first, some function updates and 2 new functions. I did this to drastically increase performance and add some new functionality ^)^.

Functions

function Bits2String32 takes integer num returns string
	local string str0 = "00000000000000000000000000000000"
	local string str = ""
	local integer bit0 = 0
	
	if (num < 0) then
		set bit0 = 1
		set num = -2147483648 + num
	endif
	
	loop
		exitwhen 0 == num
		
		set str = I2S(num - num/2*2) + str
		set num = num/2
	endloop
	
	return I2S(bit0) + SubString(str0, 0, 31 - StringLength(str)) + str
endfunction

function Bits2String takes integer num returns string
	local string str0 = "00000000000000000000000000000000"
	local string str = ""
	local integer bit0 = 0
	
	if (num < 0) then
		set bit0 = 1
		set num = -2147483648 + num
	endif
	
	loop
		exitwhen 0 == num
		
		set str = I2S(num - num/2*2) + str
		set num = num/2
	endloop
	
	if (0 == bit0) then
		return str
	endif
	
	return I2S(bit0) + SubString(str0, 0, 31 - StringLength(str)) + str
endfunction

function GetBitSize takes integer bits returns integer
	local integer low = 0
	local integer high = 31
	local integer mid = 15
	
	if (0 == bits) then
		return 0
	elseif (0 > bits) then
		return 32
	endif
	
	loop
		if (bits < udg_powArr[mid - 1]) then
			set high = mid - 1
		else
			set low = mid + 1
		endif
		
		set mid = (high + low)/2
		
		exitwhen high < low
	endloop
	
	return mid
endfunction

function GetFreeBits takes integer bits returns integer
	return 32 - GetBitSize(bits)
endfunction

function WriteBits takes integer bits, integer bitsToWrite, integer bitsToOccupy returns integer
	return bits*udg_powArr[bitsToOccupy] + bitsToWrite
endfunction

function ReadBitsBack takes integer bits, integer bitCount returns integer
	if (bits < 0) then
		return (bits - 2147483648)/udg_powArr[32 - bitCount] + udg_powArr[bitCount - 1]
	else
		return bits/udg_powArr[32 - bitCount]
	endif
endfunction

function ReadBitsFront takes integer bits, integer bitCount returns integer
	if (bits < 0) then
		if (bitCount == 32) then
			return bits
		endif
		
		set bits = bits - 2147483648
	endif
	
	return bits - bits/udg_powArr[bitCount]*udg_powArr[bitCount]
endfunction

function PopBitsFront takes integer bits, integer bitsToPop returns integer
	if (bits < 0) then
		return (bits - 2147483648)/udg_powArr[bitsToPop] + udg_powArr[31 - bitsToPop]
	else
		return bits/udg_powArr[bitsToPop]
	endif
endfunction

function PopBitsBack takes integer bits, integer bitsToPop returns integer
	if (bits < 0) then
		if (bitsToPop == 0) then
			return bits
		endif
		
		set bits = bits - 2147483648
		
		return bits - bits/udg_powArr[32 - bitsToPop]*udg_powArr[32 - bitsToPop]
	else
		return bits - bits/udg_powArr[31 - bitsToPop]*udg_powArr[31 - bitsToPop]
	endif
endfunction

function ReadBits takes integer bits, integer bitStart, integer bitEnd returns integer
	return ReadBitsFront(PopBitsFront(bits, bitStart), bitEnd - bitStart + 1)
endfunction

function GetBitNumber takes integer bits returns integer
	return udg_powArr[bits - 1]
endfunction

function ShiftLeft takes integer bits, integer shift returns integer
	return bits*udg_powArr[shift]
endfunction

function ShiftRight takes integer bits, integer shift returns integer
	return PopBitsFront(bits, shift)
endfunction

function RotateLeft takes integer bits, integer shift returns integer
	return ShiftLeft(bits, shift) + ReadBits(bits, 0, shift - 1)
endfunction

function RotateRight takes integer bits, integer shift returns integer
	return ShiftRight(bits, shift) + ReadBits(bits, 32 - shift, 31)*udg_powArr[32 - shift]
endfunction

Init

function InitTrig_Bitmanip_library takes nothing returns nothing
	local integer i = 1
	
	set udg_powArr[0] = 1
	
	loop
		set udg_powArr[i] = udg_powArr[i - 1]*2
		
		set i = i + 1
		exitwhen i == 32
	endloop
			
	set udg_powArr[32] = -2147483648
endfunction

I also changed a couple of functions around. The front is always the right side of the number. The back is always the left side. You read it from right to left, always.

The new functions are

function ReadBitsFront takes integer bits, integer bitCount returns integer
function ReadBitsBack takes integer bits, integer bitCount returns integer

The fast functions are

function WriteBits takes integer bits, integer bitsToWrite, integer bitsToOccupy returns integer
function ReadBitsBack takes integer bits, integer bitCount returns integer
function PopBitsFront takes integer bits, integer bitsToPop returns integer

ReadBitsFront just reads the front x bits. ReadBitsBack reads the back x bits.


Here is a fully working example that supports a single 32-bit integer.

If you want something that's really usable, you're going to have to have an array of 32-bit integers that you write to. If you only have 2 bits left or something and want to write a value that takes 6 bits, write 2 bits to your first integer, then get a new integer and write the remaining 4 bits to it. When you read back, read out the 4 bits and then read out the next 2 bits and put them together.

function Trig_Untitled_Trigger_001_Actions takes nothing returns nothing
	local integer maxGold = GetBitSize(75000)
	local integer maxLevel = GetBitSize(60)
	local integer maxAr = GetBitSize(95)
	
	local integer currentGold = 72000
	local integer currentLevel = 55
	local integer currentAr = 80
	
	local integer data = 0
	
	local integer v1
	local integer v2
	local integer v3
	
	local string ALPHABET = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-+="
	local string array char
	local string s
	local hashtable table = InitHashtable()
	local string encoded
	
	local integer i
	local integer i2
	local integer stringHash
	
	call DestroyTimer(GetExpiredTimer())
	
	/*
	*	initialize alphabet
	*/
	set i = StringLength(ALPHABET)
	loop
		set i = i - 1
		
		set s = SubString(ALPHABET, i, i + 1)
		set char[i] = s
		
		set stringHash = StringHash(s)
		set i2 = 0
		
		loop
			exitwhen not HaveSavedInteger(table, stringHash, i2)
			set i2 = i2 + 1
		endloop
		
		call SaveInteger(table, stringHash, i2, i)
	
		exitwhen 0 == i
	endloop
	
	/*
	*	write values to 32-bit integer
	*/
	set data = WriteBits(data, currentGold, maxGold)
	set data = WriteBits(data, currentLevel, maxLevel)
	set data = WriteBits(data, currentAr, maxAr)
	
	/*
	*	display raw data
	*/
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, "Raw: " + Bits2String32(data))
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, "Data: " + I2S(data))
	
	/*
	*	store bits into characters, 6 bits per character
	*/
	set encoded = ""
	loop
		exitwhen 0 == data
		
		set encoded = encoded + char[ReadBitsFront(data, 6)]
		set data = PopBitsFront(data, 6)
	endloop
	
	/*
	*	output characters holding bits
	*/
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, "Code: " + encoded)
	
	/*
	*	put bits back into 32-bit integer
	*/
	set i = StringLength(encoded)
	loop
		exitwhen 0 == i
		set i = i - 1
		
		set s = SubString(encoded, i, i + 1)
		set stringHash = StringHash(s)
		set i2 = 0
		
		loop
			exitwhen char[LoadInteger(table, stringHash, i2)] == s
			set i2 = i2 + 1
		endloop
		
		set data = WriteBits(data, LoadInteger(table, stringHash, i2), 6)
	endloop
	
	/*
	*	output data
	*/
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, "Raw: " + Bits2String32(data))
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, "Data: " + I2S(data))
	
	set v3 = ReadBitsFront(data, maxAr)
	set data = PopBitsFront(data, maxAr)
	
	set v2 = ReadBitsFront(data, maxLevel)
	set data = PopBitsFront(data, maxLevel)
	
	set v1 = ReadBitsFront(data, maxGold)
	set data = PopBitsFront(data, maxGold)
	
	/*
	*	output written values
	*/
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, I2S(v1) + " == " + I2S(currentGold))
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, I2S(v2) + " == " + I2S(currentLevel))
	call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 60000, I2S(v3) + " == " + I2S(currentAr))
endfunction

//===========================================================================
function InitTrig_Test takes nothing returns nothing
    call TimerStart(CreateTimer(), 0, false, function Trig_Untitled_Trigger_001_Actions)
endfunction

Reading values back out of the number may seem confusing to you. Let me explain what's going on.

Imagine that this is a 32 bit number

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0]

When we write something, like 1001 to it, it does it like this

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1]

If we were to write 111 to the above

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1] [1] [1] [1]

etc, it's a stack (if you know what that is)

The actual array indices are the following

31-30--29-28-27--26-25--24-23-22--21-20--19-18-17--16-15-14-13--12--11-10-09--08-07-06--05-04--03-02-01--00
[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0]

When you write to the array, it pushes all of the elements currently in it over to the left to make room for what you're writing, then it puts in the new data.

Writing 111 again

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1]
[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1] [0] [0] [0] <-
[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1] [1] [1] [1]

This means that when you read your values out, you have to read it in reverse order from how you wrote it.

If you wrote 1, 2, 3, then you must read 3, 2, 1.

When you shift something too far left or too far right, it gets dropped (these are the pops)

Let's say that we want to read the 111 and 1001 back

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1] [1] [1] [1]

Well, 111 is at the front of the array, so that's easy

Now we shift right

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1] | 1 1 1

Notice that the 1 1 1 fell off the edge. It gets dropped. This is all that's left.

[0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [1] [0] [0] [1]

The BitManip functions let you read the last x bits and pop the last x bits too. If you were to have this

[1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1]

If you popped the left 3 bits

[0] [0] [0] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1]

This is different from a left shift. A left shift would do this

[1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [1] [0] [0] [0]

The top 3 bits were dropped like before, but everything moved to the left 3. In the pop version, the last 3 bits were just dropped.

The pop function in BitManip pushes everything as right as it can go. If you pop at the right, it does right shift. If you pop at the left, it does nothing.

Integers in warcaft 3 are signed, meaning that reading from left to write is much more expensive than from right to left. You want that last bit to be filled with a 0 as much as possible. When it's filled with a 1, it's hell to get the one out. Here's what happens in a right shift with the following assuming that the highest bit (leftmost) is signed.

[1] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0]

Let's shift right 3

[1] [1] [1] [1] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0] [0]

That's right, it fills the entire number up with 1's. The only way to get rid of the dern'd thing is to specifically remove it.


Anyways, hopefully you understand a bit more about numbers ^)^. This is true for all bases btw, not just binary. However, a change of base is some pretty ugly math. When you have several digits in your number from several different bases, you have to do that ugly math. As long as you only work in one base, the math is simple. Binary is the smallest base that exists, so you'll minimize the fluff in your code by using it. Now, of course, you can go with a set of arbitrary bases, but then we get into ugly math ^)^.

One cool thing I did in the past was a library called Scrambler. It just changed the base of a number over and over again, mixing up the digits each time. Resulted in seemingly random numbers that varied in even their lengths o-o. The reason numbers can vary in lengths as a result of this is of course the fractions.

Remember values like 1001? They are stored in fractions of bits.

Suppose you have 10011001

If you rearrange them just right, you can get

00001111

Which is just 1111. That is half the size of the original.

That is the number 153 turned into 15

If you keep changing bases, going from like base 2 to base 3 to base 5, etc, you can end up with some really interesting results.

1111 is 120 in ternary. Let's rearrange again to give us 012. This gives us 101 in binary, rearranged to 011 we get 10 in ternary, and so forth. We can eventually go down to just 1.

As we change between bases, we get more and more fractions. It's possible to reduce a number from 153 to 1. However, we should never drop the leading place, or we lose information (the placeholders). Just showing that it's possible.

This is more of a reality

10011001 -> 10000111 -> 12000 -> 10002 -> 1010011 -> 1000111 -> 2122 -> 241 (base 5) -> 214 -> 111011 -> 101111 -> 1202 -> 1022 -> 35

That is as packed as the number can get while losing 0 information. If we know our sequence to get back, we can then unscramble it and get all of our information back.

Once again, 153 -> 35.

Of course, numbers can also get bigger. If we scramble in the other direction to maximize the size of the number, we can figure out the range that 153, when scrambled, can become.

In binary, our number is 100011

Compare

10011001
100011

Cut off 2 full bits. This is still still has fractions of a bit in it, but notice that the fraction is very, very small. We know this because it is extremely close to a power of 2

100011
100000

The fraction is higher in ternay

1022

But there's nothing we can do to eliminate it. The number is too small to go to a larger prime base like 5, 7, or 11 to try and find more stuff that can be dropped out. The bigger the number, the bigger the range it has.

Oh well, that's just Scrambler ^)^.


If you want to see the fractions for yourself

ln(number - 1)/ln(base)

This will give you how many digits the number in base 10 will take up in a target base.

If we look back at 153, it takes up 7.257 digits in binary. 0b10000111 takes up 7.077 digits.

The closer you are to a whole number (not rounding down, rounding up), the better. If you are at like 7.99, you've practically maxed out capacity.

Now, this of course refers to bases. For example, 8 returns 3, but it actually takes up 4 binary digits. What this actually means is that a base 8 digit in binary will take up exactly 3 digits. Recall that base 8 goes from 0 to 7.

You can use this to determine how well your max values fit into binary (max value + 1), or any base for that matter. For example, a max value of 75,000 (75,001) will take up 16.19 binary digits, which is pretty bad. In base 84 (you were using this earlier right?), it would take up 2.53 digits.That seems like less wasted space, but let's convert that .47 in base 84 to binary to see how much extra space is wasted. .47*ln(84)/ln(2) = 3.004389 digits, which is way more than .81 digits from binary. Now keep in mind that a binary digit is small, these digits add up and generate a lot of code bloat. Certainly, fractions will still add up, but you may only be adding 3-5 binary digits over all instead of 20-40.

Let's see what would happen with arbitrary bases now.

75000
300
200
100

let's assume all at max

This gives us a value of 458301185600 when all packed together. In base 84, this is 6.06 digits.

Now using only binary, we get 1258301056100

458301185600
1258301056100

already we can see a bit of bloat as compared to the arbitrary base method. In base 84, it's 6.28795656 digits

6.06
6.29

So our code won't have gone up at all, but we do have some more empty space in there. Now for the final method, the method you were using.

75000 = 2.533 digits = 3 digits (must round up)
300 = 1.288 = 2 digits
200 = 1.1969 = 2 digits
100 = 1.04 = 2 digits

3 + 2 + 2 + 2 = 9 digits

So

Arbitrary = 6.06 = 7 digits
Binary = 6.29 = 7 digits
Naive = 9.00

So the naive method made the code 2 characters longer.

I hope you can see why it might be worth it to go for, at the bare minimum, binary ; P. Binary also normally outputs in base 64, so the reality is...

Binary = 6.699 = 7 digits

Binary will probably be 1-2 characters higher than arbitrary as the code grows in size. Naive will be way higher than both of them.


The formula, once again, is Ln(max value + 1)/Ln(base), or Ln(base1)/Ln(base2). You can use this equation to calculate the efficiency of your codes. There is an Ln function in the JASS section.

Also, if using arbitrary bases has 0 space in between the values, why was it 6.06 instead of 6? The space is at the very end of the number, when converting to base 84. Arbitrary bases won't necessarily fit nicely into the output base. That's where your space comes from. Arbitrary will never go above 1 extra character. They have the capability of going 0 extra characters, but that's terribly rare. It'll pretty much always be 1 extra character that has mostly space in it.

The space in binary and naive are spread between each of the values. This space grows as you add more values. Arbitrary has 0 space between the values, so the space won't grow, the space is only a result of the final output not being a power of the target base. This is why I personally use arbitrary. However, binary does have minimal space, so if you are going to stick with only 1 base, go with binary for sure.

Btw, base 128 will only drop binary to 5.74 digits. The benefit of increasing the size of your base goes down as the base grows in size. Base 256 is 5.02 digits. Base 1024 is 4.02 digits. Arbitrary in base 1024 is 3.87 digits. Naive in base 1024 is 5 digits, most of which is empty space. Why did the gap between naive and arbitrary lower?

In base 301

Arbitrary = 4.71 digits = 5 digits
Binary = 4.88 digits = 5 digits
Naive = 6 digits

The naive approach with this particular set of values is pretty much maximized at base 301. As it goes farther away from base 301, it will diverge from the other methods. Let's say that the base is now 75,001.

Arbitrary = 2.39 digits = 3 digits
Binary = 2.48 digits = 3 digits
Naive = 4 digits

The very best naive is ever going to get to is 4 digits. The others will continue to drop.

There is another form of naive that tries to pack as much data as possible into a single value (Acehart's does 1,000,000) and then converts that value into a character. This reduces space a bit, but is still way worse than binary.

what about base 1,000,000?

Arbitrary = 1.94 digits = 2 digits
Binary = 2.01 digits = 3 digits
Naive = 4 digits

If you would like to use the arbitrary base method instead of binary, lemme know ;D.

 

[shadowvzs]

i am not in home but i will check if i going back till that a question about in fucntion, why do u use stringhas like key1? its made if someone use hastable for something then never overwrite the user data in hashtable because stringhash is ~unique?

to be honest, this function description was really nice and understandable, its like a nice tutorial.

a easy example to Arbitrary math stuff?

btw have something trick about storeing set (i mean like agi/str/int what have same max value) or need write each with function like any 3 number like was gold,lv,ar?

 

[Nestharus]

For here stats, look at save/load with snipets at save stats or something. That map has a lot of resources in it. You can look at them to see how to do things well.

StringHash is just a hash function that takes a string. There are collisions. Wc3 is also not case sensitive.

Lots of examples for arbitrary bases in the interactive save/load tutorial. The bad part is that you need to represent all of yout data as one number and then do the math operations on that. Do you know how to do division one digit at a time?

 

[shadowvzs]

For here stats, look at save/load with snipets at save stats or something. That map has a lot of resources in it. You can look at them to see how to do things well.

StringHash is just a hash function that takes a string. There are collisions. Wc3 is also not case sensitive.

Lots of examples for arbitrary bases in the interactive save/load tutorial. The bad part is that you need to represent all of yout data as one number and then do the math operations on that. Do you know how to do division one digit at a time?

a question, if current gold is 1 but max is 75k, then here the ReadBitsFront(data, maxGold) is same 5 char long than 72k so if i save a minimum value and max value is high then isnt waste of space, like example when example if i use in my own map allways 2 char length for stat so '0Z' if less than stringth len, and '11' if higher by 1,if this put to each other then 2+2+2char for the 3 stat where max value is 5300 what takes 13 bit what is after 3 value its 39 reserved space in 32 digit long binary what is 7 char not 6 if i divide 39/6. i missunderstanded something?

btw i asked about hastable because was created locally and lost the reference out of that function and table isnt destroyed or moved to global (or u just dont stored because was non important)?
also why call DestroyTimer(GetExpiredTimer())?

 

[Nestharus]

a question, if current gold is 1 but max is 75k, then here the ReadBitsFront(data, maxGold) is same 5 char long than 72k so if i save a minimum value and max value is high then isnt waste of space

It's 3 characters, not 5 characters, but yea, it'll always take up that space regardless of the value. There are ways to actually make it take up less space, but then the worst case scenario is worse.

You can reduce the max value with tricks. For example, level 17 hero of type warrior has 173 strength with no modifications, when you save strength, you can subtract 173 from that hero's strength and max strength. The max strength would be the culmination of possible bonuses that hero can have at that level. If your normal max strength is 1024, but at level 17 with a warrior, it's only 218, then your actual max for your code is 218 - 173.

if this put to each other then 2+2+2char for the 3 stat where max value is 5300 what takes 13 bit what is after 3 value its 39 reserved space in 32 digit long binary what is 7 char not 6 if i divide 39/6. i missunderstanded something?

You are correct, that would take up 7 characters.

btw i asked about hastable because was created locally and lost the reference out of that function and table isnt destroyed or moved to global (or u just dont stored because was non important)?

I made it a local variable etc because this was an example. Normally, it would be a global.

also why call DestroyTimer(GetExpiredTimer())?

In this example, I created a timer in the trigger function thingie at the bottom. Look at the last few lines of code ; P.

 

[shadowvzs]

It's 3 characters, not 5 characters, but yea, it'll always take up that space regardless of the value. There are ways to actually make it take up less space, but then the worst case scenario is worse.

You can reduce the max value with tricks. For example, level 17 hero of type warrior has 173 strength with no modifications, when you save strength, you can subtract 173 from that hero's strength and max strength. The max strength would be the culmination of possible bonuses that hero can have at that level. If your normal max strength is 1024, but at level 17 with a warrior, it's only 218, then your actual max for your code is 218 - 173.



You are correct, that would take up 7 characters.

basically, then where better to store in binary compared with my map except the 1-2 char less maybe because don't need to store the length of the gold (well this case depend because my code shorter in minimum case and maximum case a bit longer until ur is same length, because i think the difference is when we work in normal numbers)

don't missunderstand me, i love ur help because ~learned this too, this way is another view point about save load code mechanism and i like to learn new stuff

 

[Nestharus]

Ahem, 1-2 characters less *per* value. Why do you think your current codes are abnormally large? Try doing the math on your current data to see how much bloat there is in just your example code. Do minimum to maximum to find a range.

Also keep in mind that there are GUI save/load systems that use binary or arbitrary bases, so how, i ask, can yours currently compete with them. Why should a user use your system when there are several vastly superior systems out there? This, and your attitude about it, can be the basis for rejection. There is no need for a resource that only lowers the quality of a map compared to other resources that do the same exact thing. Do you not agree?

 

[shadowvzs]

Ahem, 1-2 characters less *per* value. Why do you think your current codes are abnormally large? Try doing the math on your current data to see how much bloat there is in just your example code. Do minimum to maximum to find a range.

Also keep in mind that there are GUI save/load systems that use binary or arbitrary bases, so how, i ask, can yours currently compete with them. Why should a user use your system when there are several vastly superior systems out there? This, and your attitude about it, can be the basis for rejection. There is no need for a resource that only lowers the quality of a map compared to other resources that do the same exact thing. Do you not agree?

i dont said per value, i said overall few character difference but i got different ideea, i just noticed what u adviced gui saveload code generate long or same length code in same situation (if save same thing) but not less length code, atleast that one what i checked so thats why dont uinderstand that "lower" quality thing, well ofc chaos in names in stuff ofc understandable, but like i said mine did few character less in minimal case and 1-2 more compared with binary trying (i not regreted trying same with binary system too )

atm i think on something i will upgrade later

btw have conflict if i save StringHash("string letters/syntax/numbers 1by1") and GetUnitTypeId() and Getitemtypeid? any of them can be same than another?

 

[shadowvzs]

BUMP... updated, check the screenshot and if u want count the code length vs other save-load stuff


9pm 29.09.2014 - reuploaded the map coz forget remove a -1 for shorter custom value code so updated it

 

[Nestharus]

This belongs as a separate resource

It would be better to take a string, a character set as a table, and the color.

function Colorized_Code takes string s, string numColor, string lowerColor, string upperColor, string specColor, integer start returns string

This needs to be rewritten entirely. You have a bundle of extra useless variables.

function SL_IntegerToCode takes integer i, integer len returns string

Converting to a string is as simple as this

loop
    set myString = myString + characterSet[(i - i/base*base)]
    set i = i/base
    set length = length + 1
    exitwhen i == 0
endloop
set myString = myString + characterSet[length]

Your algorithm is just way too convoluted. Also, you are going to have code bloat because you convert each integer independently rather than together. I've mentioned this before. If you want to store them as compactly as possible using your current algorithm, which has a much worse worst case scenario, you want to store them in binary (won't be exact space, so will still have code bloat) and then store the number of bits that it takes up in front of it. If you want to take up the minimal space possible, then you want to have maximum values and you don't want to store lengths in your code. TriggerHappy's resource has the same issues.

The loop here isn't necessary

function SL_CodeToInteger takes string c returns integer
    local integer l = StringLength(c)
    local integer m = StringLength(udg_SL_STRING)
    local integer i = 0
    local integer char
    local string s 
    local integer int = 0
    if l > 0 then
        loop
            exitwhen i == l
            set s = SubString(c, i, i + 1)
            if s != StringCase(s, true) then
              set char = LoadInteger(udg_SL_HASHTABLE, StringHash(s), 2)
            else
              set char = LoadInteger(udg_SL_HASHTABLE, StringHash(s), 1) 
            endif
            if char !=0 or i > 0 then
                set int = int + R2I(Pow(m, l - i - 1)) * char
            endif
            set i = i + 1
        endloop
    endif
    set s = null
    return int
endfunction

This isn't required...

function SL_GetIntegerSize takes integer a returns integer
local integer base = StringLength(udg_SL_STRING)
local integer max = 4
local integer i = 0
if base < 64 then
   set max = 6
elseif base < 74 then
   set max = 5
endif

loop
set i = i + 1
exitwhen i > max
if a < R2I(Pow(base,i)) then
  return i
endif
endloop
endfunction

Your checksum is not as good as Knuth.

function SL_CodeCheckSum takes string c, player p returns string
    local string EC = udg_SL_STRING
    local integer MaxV = R2I(Pow(StringLength(EC), udg_SL_CRC_LEN))
    local integer i
    
    if udg_SL_BIND_TO_PLAYER then
        set i = StringHash(c + StringCase(GetPlayerName(p), false))
    else
        set i = StringHash(c)
    endif

    if i < 0 then
        set i = i * - 1
    endif

    if i > MaxV then
        set i = ModuloInteger(i, MaxV)
    endif

    return SL_IntegerToCode(i, udg_SL_CRC_LEN)
endfunction

You are still hard coding what will be saved and loaded while just using a bunch of flags. This is no good. You need to be able to save or load anything.

    local integer l = StringLength(udg_SL_STRING) //get the string length of the alphabet string
    local integer i = 0
    local integer i2
    local integer MinExp
    local integer array Pow2
    local integer CLASS // the hero unit type index in SL_HERO_TYPE array
    local integer LV // hero level
    local integer EXP // hero exp
    local integer STR // hero strength
    local integer AGI // hero agility
    local integer INT // hero intelligence
    local integer GOLD // player gold
    local integer LUMBER // player lumber
    local integer ITEM_SLOT
    local integer MAX_X = R2I(GetRectMaxX(bj_mapInitialPlayableArea)) //highest X coordinate on map
    local integer MAX_Y = R2I(GetRectMaxY(bj_mapInitialPlayableArea)) //highest Y coordinate on map
    local integer COORD_LEN_X = SL_GetIntegerSize(MAX_X * 2) // how much character needed for save hero location
    local integer COORD_LEN_Y = SL_GetIntegerSize(MAX_Y * 2) // how much character needed for save hero location
    local integer X // hero x coordinate
    local integer Y // hero y coordinate
    local item itm
    local integer a1
    local integer a2
    local integer a3
    local integer a4
    local integer c
    local string Key
    local string s
    local location loc
    local unit u

The problems still stand.