System Encoder

Nestharus

o-o
Reaction score
84
This and all save/load systems are Deprecated, do not use!

Quickstart Guide to Installing Lua Scripts (easy)

Saving and Loading Tutorial
Encoder Demo Map 2, a framework for Encoder

The best save/load system ever created for Warcraft 3. No other save/load system even compares to this.

Statistics
min code size in demo: 21
kM6c-ypaF-UbKi-RWbb-nOqc-Z​

average code size in demo: 60
4YMX-sYnp-Uiij-15vg-YcVv-Y4vz-fiZb-A0Ks-3w38-jZJm-zW3B-eJ3L-jcb3-VV0P-QmwU​

max code size in demo: 63
JZae-DdjD-dWsQ-NKgU-sZCM-JLmt-XNmW-yMsA-eoND-aPor-qn8I-c4fO-tEjq-olO9-P3fW-eec​

Security
1 bit value changes (from demo) (a bit is the tiniest change possible, like 0 to 1)

GCq3-4nVh-qtJc-AaJe-oFdh-N4
GTH2-JP2M-Vdc0-bU77-i6P1-rW
FoD8-kFq1-EO1B-3WSh-mGGf-jK6
xTEa-gBt2-4wPQ-wMuI-7jJK-V3
YDb6-LXrR-p1Ht-DnIZ-I6Mr-zia

Security Used in demo (prevents code tampering): 148194
Security Size (how big it is in the code): 3 chars (Ddy) (not too big ^^)

Where is the security? It's scrambled into the code at many different levels. This means that every single character in the code has a bit of every single security value in it + every single other value in the code. Changing 1 character in the code changes every single digit in the code by a fractional value. It's pretty much impossible to crack.

Compression
Encoder uses rather standard compression. It simply makes one gigantic number.

If there was this collection of numbers
5,10,15​

For these ranges
[0,6), [0,11), [0,16)​

It'd just merge them together
(5*11+10)*16+15 = 1055​

And then it would convert the base
h1​

Going back
Code:
	h1->1055

	1055%16=	15; 	1055/16=65
	65%11=		10; 	65/11=5
	5%6=		5

	5,10,15

Structure
Most save/load systems have a very simple data structure. Recall the ranges from before
[0,6), [0,11), [0,16)​

They would be stored in a simple list for older save/load systems
  • [0,6)
  • [0,11)
  • [0,16)

For Encoder, they are stored in what I call a QueueQUeue, which is a tree structure formed
by a queues of queues.

  • Head: (0,0)
    • Link: (0,0)
      • Value 1: [0,6)
    • Link: (0,0)
      • Value 2: [0,11)
    • Link: (0,0)
      • Value 3: [0,16)

Each link is a node specific to the tree and each non link is a node that may be in any
number of trees. The head represents the tree, in this case the Encoder.

Links are only entered if the value fits. For example, the head value is always going to be
nothing (0,0), so the links will always be entered. Values of nothing can fit into any link.
This is the basis that allows Encoder to serialize objects into a code rather than just
a collection of values.

Let's say that are were 200 items in a map. Items 1 through 100 have max item charges
of 0 and items 101 through 200 have max item charges of 16. Let's say that we want to
build a code that can store 6 of these items.

With a regular save/load system using a Queue, the struct would have to be this
  • Item id: [0,201)
  • Item charge: [0,17)
  • Item id: [0,201)
  • Item charge: [0,17)
  • Item id: [0,201)
  • Item charge: [0,17)
  • Item id: [0,201)
  • Item charge: [0,17)
  • Item id: [0,201)
  • Item charge: [0,17)
  • Item id: [0,201)
  • Item charge: [0,17)
That will result in a max number of:
Code:
	((((((((((200*17+16)*		1
		201+200)*17+16)*	2
		201+200)*17+16)*	3
		201+200)*17+16)*	4
		201+200)*17+16)*	5
		201+200)*17+16 		6
		
		= 1591731726658570620368
		= uAv2c69GEgMu
A mid number of:
Code:
	((((((((((100*17+16)*		1
		201+100)*17+16)*	2
		201+100)*17+16)*	3
		201+100)*17+16)*	4
		201+100)*17+16)*	5
		201+100)*17+16 		6
		
		= 799593572291014983768
		= fmGT2JMqrYGU
A min number of: 0

For Encoder
  • Head: (0,0)
    • Link (0,0)
      • Item id: [0,201)
        • Link: [101, 200]

          • Item charge: [0,17)
    • Link (0,0)
      • Item id: [0,201)
        • Link: [101, 200]

          • Item charge: [0,17)
    • Link (0,0)
      • Item id: [0,201)
        • Link: [101, 200]

          • Item charge: [0,17)
    • Link (0,0)
      • Item id: [0,201)
        • Link: [101, 200]

          • Item charge: [0,17)
    • Link (0,0)
      • Item id: [0,201)
        • Link: [101, 200]

          • Item charge: [0,17)
    • Link (0,0)
      • Item id: [0,201)
        • Link: [101, 200]

          • Item charge: [0,17)

With that, only items fitting between 101 and 200 gets an item charge slot.

Max number: same as max for regular
Mid number:
Code:
		((((100		1
		*201+100)*	2
		201+100)*	3
		201+100)*	4
		201+100)*	5
		201+100		6

		= 32972080300600
		= 9muv6KXS
Min number: 0

Comparisons

Max 1: uAv2c69GEgMu
Max 2: uAv2c69GEgMu

Mid 1: fmGT2JMqrYGU
Mid 2: 9muv6KXS

Min 1: 0
Min 2: 0

And again, this is assuming that the save/load system in question is using the same
compression technique as Encoder. Only 1 save/load system uses the same compression
technique, and that is Pipedream's save/load at wc3c.net. The others use a horrible
one that more than doubles the code size (7 chars -> 16+ chars).

Now, keep in mind that not every slot may be used in a tree. What if there were two
types of heroes, one with 4 abilities that had max levels of 3,3,3,1 and the other
with 5 abilities that had max levels of 4,4,4,2,4 (actual wc3 data). What this would mean
is that the first style of save/load would have to save 4,4,4,2,4 and the second style
could save 3,3,3,1 or 4,4,4,2,4. In practical use, the data structures can get very
complicated, which can result in some drastic differences.

Queue method:
  • Hero id: [1,3)
  • Ability Level: [0,5)
  • Ability Level: [0,5)
  • Ability Level: [0,5)
  • Ability Level: [0,3)
  • Ability Level: [0,5)

Encoder method:
  • Head: (0,0)
    • Link: (0,0)
      • Hero id: [1,3)
        • Link: [1,1]
          • Ability Level: [0,4)
          • Ability Level: [0,4)
          • Ability Level: [0,4)
          • Ability Level: [0,2)
        • Link: [2,2]
          • Ability Level: [0,5)
          • Ability Level: [0,5)
          • Ability Level: [0,5)
          • Ability Level: [0,3)
          • Ability Level: [0,5)

JASS:

library Encoder /* v3.0.1.2
*************************************************************************************
*
*   Save/Load system
*
*************************************************************************************
*   */uses/*
*
*       */ BigInt /*        hiveworkshop.com/forums/jass-functions-413/system-bigint-188973/
*       */ QueueQueue /*    hiveworkshop.com/forums/submissions-414/snippet-queuequeue-190890/
*
*       These two can be changed (*Advanced*)
*       */ KnuthChecksum /* hiveworkshop.com/forums/1846246-post343.html
*       */ Scrambler /*     hiveworkshop.com/forums/submissions-414/snippet-salt-189766/
*
*               Used in settings functions:
*                   private function Checksum takes BigInt k, integer m returns integer
*                   private function ApplyScramble takes BigInt k, integer pid returns nothing
*                   private function UnapplyScramble takes BigInt k, integer pid returns nothing
*
************************************************************************************
*
*   SETTINGS
*/
    private keyword b10         //base 10
    globals
    /*************************************************************************************
    *
    *   I suggest permutation of the following base for encoders
    *
    *       0123456789ABCDEFGHKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@#$%&?
    *
    *************************************************************************************/

    /*************************************************************************************
    *
    *   VER_BASE refers to the base used with encoder.toString()
    *
    *************************************************************************************/
        private constant string VER_BASE="0123456789"

    /*************************************************************************************
    *
    *   Coloring Settings
    *
    *************************************************************************************/
        private constant string NUM_COLOR="|cff40e0d0"    //what to color numbers
        private constant string LOWER_COLOR="|cffff69b4"  //what to color lowercase characters
        private constant string UPPER_COLOR="|cff00AA00"  //what to color uppercase characters
        private constant string SPEC_COLOR="|cffffff00"   //what to color special characters
        private constant string DELIMITER_COLOR="|cffffffff"  //what to color DELIMITER characters

    /*************************************************************************************
    *
    *   Spacing Settings
    *
    *************************************************************************************/
        private constant string DELIMITER="-"                 //DELIMITER to make code easier to read
        private constant integer DELIMITER_COUNT=4            //how many characters per DELIMITER

    /*************************************************************************************
    *
    *   Encryption Settings
    *
    *************************************************************************************/
        /*************************************************************************************
        *
        *   SHUFFLES
        *
        *   How many shuffles to perform in encoder
        *
        *   Nust be greater than 0
        *
        *************************************************************************************/
        private constant integer SHUFFLES=3


        /*************************************************************************************
        *
        *   CHECKSUM_VARIANCE
        *
        *   Balanced value: .85
        *
        *   The larger the variance value, the smaller the range of active checksums. A small range
        *   means that it is more likely for two players to have the same checksums.
        *
        *   Smaller variance increases the range of active checksums, however it also increases the
        *   range of cehcksum strengths. This means that some checksums may be much weaker than others, 
        *   which increases the chances for those players with weaker checksums to tamper with their
        *   code.
        *
        *   Checksum strength should be about the same for each checksum and there should be enough
        *   active checksums that it is unlikely that two players will have te same checksum.
        *
        *   .85 is a rather balanced value, but it can be increased for generally stronger checksums
        *   with smaller ranges or decreased for weaker checksums with wider ranges.
        *
        *   Ex:
        *       .85 for a checksum of 238,609,294
        *
        *       min: 202,817,899
        *       range: 35,791,395
        *
        *       1 in 35,791,395 checksums will work for a player and checksums will all be around same
        *       strength.
        *
        *       .99 for a checksum of 238,609,294
        *
        *       min: 236,223,201
        *       range: 2,386,093
        *
        *       1 in 2,386,093 checksums will work for a player and checksums will all be around same
        *       strength.
        *
        *       .01 for a checksum of 238,609,294
        *
        *       min: 2,386,092
        *       range: 236,223,202
        *
        *       1 in 236,223,202 will work for a player and checksums will have a wide range of strengths
        *       from weak to strong.
        *
        *************************************************************************************/
        private constant real CHECKSUM_VARIANCE=.85

    /*************************************************************************************
    *
    *   PLAYER_CHECKSUM_SALT
    * 
    *   Player checksum salt refers to a value that is appended to a player's name when
    *   generating player hashes. A player's checksum salt helps determine the player's
    *   checksum for encoders.
    *
    *   This value can be any string
    *
    *       example: "29a\\~alf1!m~..."
    *
    *************************************************************************************/
    private constant string PLAYER_CHECKSUM_SALT=""
    endglobals

    /*************************************************************************************
    *
    *   Checksum
    *
    *       This is the Checksum used for code security (makes modifications
    *       difficult). By default, this uses the Knuth Checksum, but
    *       that can be changed.
    *
    *       BigInt k:               number to get the checksum for
    *       integer m:              dividend for modulos
    *
    *       returns:                nothing
    *
    *************************************************************************************/
    private function Checksum takes BigInt k, integer m returns integer
        return GetKnuthChecksum(k, m)
    endfunction

    /*************************************************************************************
    *
    *   ApplyScramble
    *
    *       This is essentially for scrambling the code given a player id.
    *       By default this uses my own scrambling algorithm.
    *       Because a player hash based on the player's username is used in my
    *       scrambling algorithm, this will make it so that a player can't load
    *       up the code of another player with 0 increase to the code size.
    *       This security alone is not enough to 100% guarantee the player unique
    *       codes.
    *   
    *       BigInt k:               number to be scrambled
    *       integer pid:            player id to scramble for
    *
    *       returns:                nothing
    *
    *************************************************************************************/
    private function ApplyScramble takes BigInt k, integer pid returns nothing
        call Shuffle(k, pid, SHUFFLES)
    endfunction

    /*************************************************************************************
    *
    *   UnapplyScramble
    *
    *       This is used to undo the scrambling on a number. This should
    *       revert the number back to what it was before it was scrambled.
    *   
    *       BigInt k:               number to be unscrambled
    *       integer pid:            player id to unscramble the number for
    *
    *       returns:                nothing
    *
    *************************************************************************************/
    private function UnapplyScramble takes BigInt k, integer pid returns nothing
        call Unshuffle(k, pid, SHUFFLES)
    endfunction
/*
*******************************************************************
*
*   struct CodeRange extends array
*
*       -   A slot that can store a value. These slots have a range of values they can store. The
*       -   range is from a low bound value to a high bound value. Slots are added to Encoder objects.
*       -   Specific ranges of slots can link to other slots (an item with 25 charges for example). Not
*       -   all slots can store values: some are purely pointers (an inventory slot for example which simply
*       -   points to 6 items).
*
*       static method create takes integer lowBound, integer highBound returns CodeRange
*           -   Creates a new CodeRange that can be added to an Encoder and linked to. CodeRange objects
*           -   can be linked to multiple times and can link to as many other CodeRange objects as needed.
*           -   If the lowBound is equal to the highBound, then the CodeRange object returned is a pointer
*           -   object that can't store values. This can be useful for things like an inventory that simply
*           -   points to 6 item slots.
*
*           -   integer lowBound                The minimum value that can be stored in the slot.
*           -   integer highBound               The maximum value that can be stored in the slot.
*       method link takes integer lowBound, integer highBound, CodeRange linkTo, integer customLinkId returns nothing
*           -   Links a CodeRange to another CodeRange. The link is only applied if the value that ends
*           -   up going into the CodeRange fits the link range. For example, if only heroes from 1 to 5 had
*           -   an inventory of 6, then the lowBound would be 1 and the highBound would be 5 for that link.
*           -   Passing in the minimal value and maximal values for a given slot does a link for all possible
*           -   values that can go into that slot.
*
*           -   integer lowBound                The minimal value that can be in the slot to go into the link
*           -   integer highBound               The maximal value that can be in the slot to go into the link
*           -   CodeRange linkTo                The slot that is to be linked to
*           -   integer customLinkId            A link id that can be used to infer current slot for save/load
*       method linka takes CodeRange linkTo returns nothing
*           -   Links all possible values to a slot. Essentially just calls link with the minimum possible
*           -   value, maximum possible value, and a custom id of 0.
*
*           -   CodeRange linkTo                The slot that is to be linked to
*
************************************************************************************
*
*   struct DataBuffer extends array
*
*       -   The DataBuffer is used for reading and writing values.
*       -   When opening an Encoder, it is loaded into the DataBuffer
*       -   and then values can be read/written. An Encoder may be
*       -   opened for decompressing a code or for compressing a
*       -   collection of numbers into a code.
*
*       readonly integer id
*           -   Returns the current custom link id (remember link and linka in CodeRange)
*           -   As slots inside of links may or may not exist (does value fit?), this is
*           -   a necessity so that a user can easily determine whether they are in a
*           -   questionable slot or not.
*           -   Can be used in read and write mode.
*       readonly string code
*           -   Returns all of the values in the DataBuffer as a save/load code.
*           -   Can only be used when the DataBuffer is finalized.
*           -   Can be used in write mode.
*
*       method write takes integer value returns nothing
*           -   Writes a value to the DataBuffer. Order of values is determined by the
*           -   loaded Encoder. For example, if a Hero, gold, and lumber slots were
*           -   added to the Encoder in that order, then the DataBuffer would expect
*           -   values fitting those ranges in that order. When all values are written,
*           -   the DataBuffer is finalized (meaning can't be written to) and the code
*           -   can be read.
*           -   Can be used in write mode.
*
*           -   integer value                   The value to write to the DataBuffer.
*       method read takes nothing returns integer
*           -   Reads a value out of the DataBuffer. Value read order is determined by
*           -   the loaded Encoder.
*           -   Can be used in read mode.
*
************************************************************************************
*
*   struct Encoder extends array
*
*       -   An Encoder is like a frame for compacting values. It is used
*       -   for storing base, checksum, player checksum, and CodeRange information.
*       -   the Encoder determines the order of values in a code for the DataBuffer
*       -   as well. DataBuffers can only be opened through an Encoder.
*
*       static method create takes string base, integer minCodeLength, integer maxCodeLength, integer maxChecksum, integer encoderVersion returns Encoder
*           -   Creates a new Encoder.
*
*           -   string base                     The collection of possible characters that the Encoder can
*           -                                   use for its save/load codes. Bigger collection means smaller
*           -                                   codes.
*           -   integer minCodeLength           Minimum length a code has to be to be loaded. Useful for blocking
*           -                                   small values like 1 or 5. Keeps load codes in bounds.
*           -   integer maxCodeLength           Maximal length a code can be to be loaded. Useful for blocking
*           -                                   off random large values. Keeps load codes in bounds.
*           -   integer maxChecksum             The maximum checksum value that can be put into the Encoder.
*           -                                   Checksums are used to validate codes (ensure they weren't
*           -                                   tampered with and that there are no typos in it). The bigger
*           -                                   the checksum value, the more secure the code is, but the longer
*           -                                   the code will be. I typically use a 6 digit number like 148292
*           -                                   or 559321.
*           -                                   Maximum checksum- 238609294
*           -                                       
*           -   integer encoderVersion          Used for version control on encoders. toString returns this value and
*           -                                   convertString takes the toString value and converts it back into the encoder
*           -                                   toString() -> encoderVersion
*           -                                   convertString(encoderVersion)
*       method toString takes nothing returns string
*           -   Converts the Encoder into a string that represents it. This can
*           -   be outputted to players to show the Encoder version that their
*           -   code was saved for. Players can then possibly type in the Encoder
*           -   version of older codes so that older codes can be loaded.
*       static method convertString takes string encoderId returns Encoder
*           -   Converts an Encoder string into an Encoder. Used primarily for
*           -   older save/load codes (player might have inputted Encoder id
*           -   for their save/load code).
*
*           -   string encoderId                The string that represents the Encoder (toString).
*       method add takes CodeRange valueSlot returns nothing
*           -   Adds a new slot to the Encoder. Value order doesn't matter.
*
*           -   CodeRange valueSlot             The CodeRange to be added to the Encoder.
*       method read takes string codeString, integer loadingPlayerId returns DataBuffer
*           -   Opens a DataBuffer for reading and returns the opened DataBuffer. Loads
*           -   a code string into the DataBuffer. If this returns 0, the code was invalid.
*
*           -   string codeString               The code to load into the DataBuffer
*           -   integer loadingPlayerId         The player id to load the code for (must
*           -                                   be a valid human playing player).
*       method write takes integer savingPlayerId returns DataBuffer
*           -   Opens a DataBuffer for writing and returns the opened DataBuffer. If
*           -   this returns 0, the Encoder or player id were invalid.
*
*           -   integer savingPlayerId          The player id to save the code for (must
*           -                                   be a valid human playing player).
*
************************************************************************************/

/*************************************************************************************
*
*   Code
*
*************************************************************************************/
    globals
    private keyword Link
    /*************************************************************************************
    *
    *   Encoder Variables
    *
    *************************************************************************************/
        private Table array eb                      //encoder base
        private string array er                     //encoder code string
        private Table array eh                      //encoder max hash value
        private Base es                             //encoder base for code string
        private Link array el                       //last range added to encoder
        private integer array ec                    //encoder ver to encoder
        private integer array ml                    //minimum code length
        private integer array mx                    //maximum code length

    /*************************************************************************************
    *
    *   Range Variables
    *
    *************************************************************************************/
        private integer array rl                    //low bound
        private integer array rh                    //high bound
        private integer array rsh                   //shifted high bound
        private integer array rf                    //flag

        private constant integer AP=1             //always positive
        private constant integer SN=2             //sometimes negative
        private constant integer AN=3             //always negative

    /*************************************************************************************
    *
    *   Link Variables
    *
    *************************************************************************************/
        private integer array li                    //link id
        private boolean array lb                    //is link

    /*************************************************************************************
    *
    *   Player Variables
    *
    *************************************************************************************/
        private integer array ph                    //hash of player name + salt
        private integer array pn                    //next player

    /*************************************************************************************
    *
    *   Data Buffer Variables
    *
    *************************************************************************************/
        //Base
        private Base b10=0                        //use for writing
                                                    //use encoder base for reading
        private Link array dm                       //data buffer looper
        private integer dc=0                      //data buffer count
        private integer array dn                    //data buffer next, recycler
        private integer array dl                    //data buffer previous
        private integer array dv                    //data buffer value
        private Link array di                       //data buffer link node id
        private integer array dd                    //data buffer node
        private integer array dz                    //data buffer link id
        
        private integer array de                    //data buffer encoder
        private boolean array df                    //is data buffer finalized?
        private boolean array dw                    //data buffer open for writing?
        private integer array dp                    //data buffer player
    endglobals

    /*************************************************************************************
    *
    *   Link
    *
    *       Links values together to form dynamic objects.
    *
    *************************************************************************************/
    private struct Link extends array
        implement QueueQueue
        implement QueueQueueLoop
    endstruct

    /*************************************************************************************
    *
    *   CodeRange : Link
    *
    *       Used for manipulating value slots in Encoders and CodeRanges.
    *
    *   Methods
    *       static method create takes integer l, integer h returns CodeRange
    *       method link takes integer l, integer h, CodeRange p, integer i returns nothing
    *       method linka takes CodeRange p returns nothing
    *
    *************************************************************************************/
    struct CodeRange extends array
        /*************************************************************************************
        *
        *   create
        *       Creates a code range given a maximum value and a minimum value. Ranges are slots
        *       that can be added to encoders and other Ranges.
        *
        *       integer l:          low bound
        *       integer h:          high bound
        *
        *       returns:            CodeRange
        *
        *************************************************************************************/
        static method create takes integer l,integer h returns CodeRange
            local Link t

            if (h>l) then
                //first ensure that the high bound is greater than the low bound
                //  if the high bound is greater, then it is a valid range for
                //  storing actual values

                //instantiate
                set t=Link.allocate()
                set t.skips=false

                //store the low bound and the high bound into the properties
                set rl[t]=l       //low bound
                set rh[t]=h       //high bound

                //now have to determine how to store the value
                //the value could be negative, it could always be negative,
                //or it could always be positive
                if (0>h) then
                    /**********************************
                    *
                    *   Flag:               AN
                    *   Shifted Low Bound:  High Bound
                    *   Shifted High Bound: -Low Bound + High Bound
                    *
                    **********************************/

                    set rf[t]=AN     //flag to always negative

                    //the shifhted high bound is the low bound minus
                    //the high bound
                    set rsh[t]=-l+h+1
                elseif (0>l) then
                    /**********************************
                    *
                    *   Flag: SN
                    *   Shifted Low Bound:  low bound
                    *   Shifted High Bound: high bound - low bound
                    *
                    **********************************/

                    set rf[t]=SN     //flag to sometimes negative

                    set rsh[t]=h-l+1
                else
                    /**********************************
                    *
                    *   Flag: AP
                    *   Shifted Low Bound:  lowBound
                    *   Shifted High Bound: highBound-lowBound
                    *
                    **********************************/

                    set rf[t]=AP
                    set rsh[t]=h-l+1
                endif

                return t
            elseif (h==l) then
                //if they are equal, then it is a valid pointer range.
                //  pointer ranges are used to just point to values. They don't go into the actual code,
                //  but values they point to do.

                /**********************************
                *
                *   Flag: 0
                *
                **********************************/

                //simple instiate it as it is meant only for pointing
                return Link.allocate()
            debug else
                //if the high bound is lower than the low bound, then the range isn't valid
                //  throw an error

                debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"CODE RANGE CREATE ERROR: HIGH BOUND LOWER THAN LOW BOUND")

                debug return 0
            endif

            return 0
        endmethod

        /*************************************************************************************
        *
        *   link
        *       Links a CodeRange to another CodeRange by adding the later range to the
        *       first range by a pointer.
        *
        *       integer l:          low bound
        *       integer h:          high bound
        *       integer p:          CodeRange to add to CodeRange this
        *       integer i:          a user id for identifying the link
        *
        *       returns:            nothing         
        *
        *************************************************************************************/
        method link takes integer l,integer h,CodeRange p,integer i returns nothing
            local Link t
            debug if (h>=l and h<=rh[this] and l>=rl[this]) then
                //first ensure that the high bound is greater than the low bound
                //  if the high bound is greater, then it is a valid range for
                //  storing actual values

                //instantiate via point
                set t=Link(this).point(p)
                set t.skips=false

                set rl[t]=l       //link low bound
                set rh[t]=h       //link high bound
                set li[t]=i       //link id for identification
                set lb[t]=true    //is link
            debug else
                //if the high bound is lower than the low bound, then the range isn't valid
                //  throw an error
                debug if (l>h) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"CODE RANGE CREATE ERROR: HIGH BOUND LOWER THAN LOW BOUND")
                debug endif
                //range was out of bounds
                debug if (h>rh[this] or l<rl[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"CODE RANGE CREATE ERROR: LINK RANGE OUT OF BOUNDS")
                debug endif
            debug endif
        endmethod

        /*************************************************************************************
        *
        *   linka
        *       A special link that links all values (lowBound to highBound).
        *
        *       integer p:          CodeRange to add to CodeRange this
        *
        *       returns:            nothing
        *
        *************************************************************************************/
        method linka takes CodeRange p returns nothing
            call link(rl[this],rh[this],p,0)
        endmethod
    endstruct

    /*************************************************************************************
    *
    *   DataBuffer : Queue, Link
    *
    *       Used to read/write code.
    *
    *   Properties
    *       readonly integer id
    *
    *   Methods
    *       method write takes integer value returns nothing
    *       method operator code takes nothing returns string
    *       method read takes nothing returns integer
    *       internal method open takes nothing returns nothing
    *
    *************************************************************************************/
    private keyword open
    struct DataBuffer extends array
        /*************************************************************************************
        *
        *   id
        *       Retrieves the current open id on the DataBuffer
        *
        *************************************************************************************/
        method operator id takes nothing returns integer
            return dz[this]
        endmethod

        /*************************************************************************************
        *
        *   internal open
        *       Prepares next slot in DataBuffer
        *
        *       takes:              nothing
        *
        *       returns:            nothing
        *
        *************************************************************************************/
        method open takes nothing returns nothing
            local Link n
            local Link y=0
            local Link l=0

            //retrieve the next node
            set n=dm[this].get    //node

            loop
                //if the current node is a pointer, have to determine
                //  whether to go inside of the pointer or not.
                exitwhen not lb[n]
                loop
                    //keep looping until can either go inside of link or the
                    //  node isn't a link

                    //link ranges of 0 to 0 are pointer links, all values fit into them
                    exitwhen not lb[n] or (0==rl[n] and 0==rh[n]) or 0==n

                    //if not a pointer link, then have to retrieve the parent
                    //  node's value
                    set y=dm[this].depthPointer
                    loop
                        exitwhen not lb[y.depthNode]
                        set y=y.depthPointer
                    endloop

                    //the value is stored into the depth pointer's id, check for fit
                    exitwhen (y.id>=rl[n] and y.id<=rh[n])
                    set n=dm[this].skip   //if value doesn't fit, skip link and all of its contents
                endloop

                //if the final found node was a pointer (meaning the value fit)
                //go inside of it
                if (lb[n]) then
                    //only store link for node ref if the link id isn't 0
                    if (0!=li[n]) then
                        set l=n
                    endif
                    set n=dm[this].get    //go to next node
                endif
            endloop

            //if there is no next node, finalize
            if (0==n) then
                set df[this]=true
                return
            endif

            //add new node to data buffer
            if (0==dn[0]) then
                set dc=dc+1
                set y=dc
            else
                set y=dn[0]
                set dn[0]=dn[y]
            endif
            //this buffer is a list because it will eventually have to be looped
            //over backwards. The buffer has to be read into the code backwards
            //or it will be impossible to read it out because some values exist
            //and some don't. Remember integers are written left to right but
            //read right to left.
            set dl[y]=dl[this]
            set dn[y]=this
            set dn[dl[y]]=y
            set dl[this]=y

            //set link id for current node to the node right above it, which
            //  is always going to be a link
            set di[y]=li[l]
            set dz[this]=li[l]

            //set node for size reference and shifting
            set dd[y]=n
        endmethod

        /*************************************************************************************
        *
        *   write
        *       Writes a value to the DataBuffer
        *
        *       integer value:      value to write
        *
        *       returns:            nothing
        *
        *************************************************************************************/
        method write takes integer v returns nothing
            local Link y=dl[this]
            local Link n=dd[y]

            //make sure
            //  buffer isn't finalized
            //  buffer is open for writing
            //  buffer is valid
            debug if (not df[this] and dw[this] and 0!=de[this] and v>=rl[n] and v<=rh[n]) then
                //store shifted value as current depth pointer id
                set dm[this].depthPointer.id=v

                //shift the value so that it is smaller
                if (rf[n]==AN) then
                    set v=-v+rh[n]
                else
                    set v=v-rl[n]
                endif

                //store value
                set dv[y]=v

                //prepare next slot for writing
                call open()
            debug else
                debug if (v<rl[n] or v>rh[n]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: VALUE OUT OF BOUNDS\n    "+I2S(v)+"-> "+I2S(rl[n])+" ... "+I2S(rh[n]))
                debug endif
                debug if (df[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: DATA BUFFER FINALIZED")
                debug endif
                debug if (not dw[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: DATA BUFFER NOT OPEN FOR WRITING")
                debug endif
                debug if (0==de[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: INVALID ENCODER")
                debug endif
            debug endif
        endmethod

        /*************************************************************************************
        *
        *   read
        *       Reads a value out of the DataBuffer
        *
        *       returns:            integer
        *
        *************************************************************************************/
        method read takes nothing returns integer
            local Link n
            local Link o
            //make sure
            //  buffer isn't finalized
            //  buffer is open for reading
            //  buffer is valid
            debug if (not dw[this] and 0!=de[this]) then
                //retrieve current node
                set n=dp[this]
                set o=dn[n]

                //go to next node
                set dp[this]=o
                set dz[this]=di[o]

                //if no more nodes, deallocate and close
                if (o==this) then
                    set de[this]=0

                    set dn[dl[this]]=dn[0]
                    set dn[0]=this
                endif

                return dv[n]
            debug else
                debug if (dw[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: DATA BUFFER NOT OPEN FOR READING")
                debug endif
                debug if (0==de[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: INVALID ENCODER")
                debug endif
            debug endif
            return 0
        endmethod

        /*************************************************************************************
        *
        *   code
        *       Converts all values in a finalized DataBuffer that is open for writing
        *       into a save/load code and returns that code.
        *
        *       returns:            string
        *
        *************************************************************************************/
        method operator code takes nothing returns string
            local BigInt i          //code as a number
            local integer h         //hash
            local integer n         //node
            local string s=""     //colorized code string
            local string c          //character
            local boolean l         //lowercase
            local Base b

            //make sure
            //  buffer is finalized
            //  buffer is open for writing
            //  buffer is valid
            debug if (df[this] and dw[this] and 0!=de[this]) then
                //create the code integer
                set i=BigInt.create(b10)

                //compress the values into one value
                set n=dl[this]
                loop
                    call i.multiply(rsh[dd[n]])
                    call i.add(dv[n],0)
                    set n=dl[n]
                    exitwhen n==this
                endloop

                //apply checksum
                set h=Checksum(i,eh[de[this]][dp[this]])

                //if        checksum          >          last value
                //                                          range
                if (integer(eh[de[this]][dp[this]])>rsh[dd[dl[this]]]) then
                    //add to front. Have to rebuild the entire number.
                    call i.destroy()
                    set i=BigInt.create(b10)

                    call i.add(h,0)

                    //compress the values into one value
                    set n=dl[this]
                    loop
                        call i.multiply(rsh[dd[n]])
                        call i.add(dv[n],0)
                        set n=dl[n]
                        exitwhen n==this
                    endloop
                else
                    //multiply to back
                    call i.multiply(eh[de[this]][dp[this]])
                    call i.add(h,0)
                endif

                //scramble
                call ApplyScramble(i,dp[this])

                //colorize
                set b=eb[de[this]][dp[this]]
                set i.base=b
                set h=DELIMITER_COUNT
                loop
                    set i=i.previous
                    exitwhen i.end
                    set c=b.char(i.digit)
                    if (0==h) then
                        set h=DELIMITER_COUNT
                        set s=s+DELIMITER_COLOR+DELIMITER
                    endif
                    set l=StringCase(c,false)==c
                    if (c==StringCase(c,true) and l) then
                        if ("0"==c or 0!=S2I(c)) then
                            //number
                            set s=s+NUM_COLOR+c
                        else
                            //special
                            set s=s+SPEC_COLOR+c
                        endif
                    elseif (l) then
                        //lower
                        set s=s+LOWER_COLOR+c
                    else
                        //upper
                        set s=s+UPPER_COLOR+c
                    endif
                    set h=h-1
                endloop

                //close
                call i.destroy()
                set df[this]=false
                set dw[this]=false
                set de[this]=0

                //deallocate
                set dn[dl[this]]=dn[0]
                set dn[0]=this

                return s+"|r"
            debug else
                debug if (not df[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: ATTEMPT TO READ PARTIAL BUFFER")
                debug endif
                debug if (not dw[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: DATA BUFFER NOT OPEN FOR WRITING")
                debug endif
                debug if (0==de[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,"DATA BUFFER ERROR: INVALID ENCODER")
                debug endif
            debug endif
            return null
        endmethod
    endstruct
 

Attachments

  • Encoder Demo.w3x
    152.5 KB · Views: 418

Nestharus

o-o
Reaction score
84
JASS:


    /*************************************************************************************
    *
    *   Encoder : Link
    *
    *       Used for forming a frame for generating codes
    *
    *   Methods
    *       static method create takes string base, integer minCodeLength, integer maxCodeLength, integer maxHash, integer ev returns Encoder
    *       method toString takes nothing returns string
    *       static method convertString takes string encoderId returns Encoder
    *       method add takes CodeRange range returns nothing
    *       method read takes string s, integer p returns DataBuffer
    *       method write takes integer p returns DataBuffer
    *
    *************************************************************************************/
    struct Encoder extends array
        /*************************************************************************************
        *
        *   create
        *       Creates a new Encoder given a base (characters used in code), a minimum
        *       code length, a maximum code length, a maximum hash (unique codes), 
        *       and an encoder version.
        *
        *       string b:           The haracters used
        *                           Must exist
        *       integer u:          Min code length
        *       integer x:          Max code length
        *       integer mh:         The maximum hash the Encoder can have. Bigger is more unique
        *                           and secure codes, but longer codes.
        *                           Must be > 1
        *       integer ev:         The version of the encoder object
        *
        *       returns:            Encoder
        *
        *************************************************************************************/
        static method create takes string b,integer u,integer x,integer mh,integer ev returns thistype
            local integer t=StringLength(b) //the Encoder
            local string s          //Encoder as a string
            local string c          //Encoder string character
            local integer h         //string length of Encoder as string
            local boolean l         //for colorizing (is lower case?)
            local integer i=pn[16]  //for looping through players

            //checksum values
            local integer m         //min checksum
            local integer r         //checksum range

            //base values
            local Base y        //original base
            local BigInt q      //original base int
            local BigInt q2     //new base

            //first ensure that the base and max checsum are valid
            debug if (1<t and 1<mh and x>=u) then
                //checksum values
                set m=R2I(mh*CHECKSUM_VARIANCE)                                 //min checksum
                set r=mh-m                                                      //range

                //base values
                set y=Base[SubString(b,1,2)+SubString(b,0,1)+SubString(b,2,t)]  //original base
                set q=BigInt.convertString(b,y)                                 //original base int

                //instantiate a new Encoder
                set t=Link.allocate()           //create encoder
                set eh[t]=Table.create()        //encoder checksum table (different for each player)
                set eb[t]=Table.create()        //encoder base table (different for each player)
                
                set ml[t]=u                     //min code length
                set mx[t]=x                     //max code length

                //generate checksums and bases for each player
                loop
                    //generate player base
                    set q2=q.copy()                     //copy original base
                    call Scramble(q2,i,3,y,true)        //scramble it
                    set eb[t]<i>=Base[q2.toString()]    //give to player
                    call q2.destroy()                   //clean
                    
                    //generate player checksum
                    //checksum=checksum-checksum/checksumRange*checksumRange+minChecksum
                    set eh[t]<i>=ph<i>-ph<i>/r*r+m
                    
                    set i=pn<i>
                    exitwhen -1==i
                endloop
                call q.destroy()            //clean original base int

                //convert the encoder version** into a string
                set ec[ev]=t
                set s=es.convertToString(ev)
                set h=StringLength(s)

                //colorize the string
                loop
                    set h=h-1
                    set c=SubString(s,h,h+1)
                    set l=StringCase(c,false)==c
                    if (c==StringCase(c,true) and l) then
                        if (&quot;0&quot;==c or 0!=S2I(c)) then
                            //number
                            set er[t]=er[t]+NUM_COLOR+c
                        else
                            //special
                            set er[t]=er[t]+SPEC_COLOR+c
                        endif
                    elseif (l) then
                        //lower
                        set er[t]=er[t]+LOWER_COLOR+c
                    else
                        //upper
                        set er[t]=er[t]+UPPER_COLOR+c
                    endif
                    exitwhen 0==h
                endloop

                return t
            debug else
                debug if (x&lt;=u) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(), 0,0,60,&quot;ENCODER ERROR: INVALID VALID CODE RANGE&quot;)
                debug endif
                debug if (1&gt;=t) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(), 0,0,60,&quot;ENCODER ERROR: INVALID BASE&quot;)
                debug endif
                debug if (1&gt;=mh) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,&quot;ENCODER ERROR: INVALID MAX HASH&quot;)
                debug endif
            debug endif

            return 0
        endmethod

        /*************************************************************************************
        *
        *   toString
        *       Returns the Encoder as a colorized string in VER_BASE.
        *
        *       returns:            string
        *
        *************************************************************************************/
        method toString takes nothing returns string
            debug if (er[this] !=null) then
                return er[this]
            debug endif
            debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,&quot;ENCODER ERROR: INVALID ENCODER&quot;)
            debug return null
        endmethod

        /*************************************************************************************
        *
        *   convertSting
        *       Returns an Encoder by converting an Encoder string into an Encoder.
        *
        *       string s:           Encoder id string
        *
        *       returns:            Encoder
        *
        *************************************************************************************/
        static method convertString takes string s returns thistype
            return ec[es.convertToInteger(s)]
        endmethod

        /*************************************************************************************
        *
        *   add
        *       Adds a CodeRange to an Encoder.
        *
        *       CodeRange r:        CodeRange to be added
        *
        *       returns:            nothing
        *
        *************************************************************************************/
        method add takes CodeRange r returns nothing
            debug if (null!=er[this]) then
                call Link(this).point(r)
                set el[this]=r
            debug else
                debug if (null==er[this]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,&quot;ENCODER ERROR: INVALID ENCODER&quot;)
                debug endif
            debug endif
        endmethod

        /*************************************************************************************
        *
        *   read
        *       Attempts to read values out of a code string.
        *
        *       string s:           Code string to read values out of
        *       integer p:          Player id to read code string for
        *
        *       returns:            DataBuffer
        *                               0 means DataBuffer couldn&#039;t be openned
        *
        *************************************************************************************/
        method read takes string s,integer p returns DataBuffer
            local BigInt i          //code integer
            local integer k=StringLength(s)
            local string c          //character
            local string b=&quot;&quot;     //filtered code string
            local DataBuffer t      //data buffer
            local integer v         //value
            local integer n         //node
            local integer array o   //original values
            local boolean f

            //first ensure that encoder is valid
            if (null!=er[this] and 0!=k) then
                //remove all DELIMITERs from code
                loop
                    set k=k-1
                    set c=SubString(s,k,k+1)
                    if (c!=DELIMITER) then
                        set b=c+b
                    endif
                    exitwhen 0==k
                endloop

                set n=StringLength(b)
                if (n&lt;ml[this] or n&gt;mx[this]) then
                    return 0
                endif
                
                //convert string into a BigInt
                set i=BigInt.convertString(b,eb[this][p])
                
                if (0==i) then
                    return 0
                endif

                //unscramble
                call UnapplyScramble(i,p)

                //retrieve whether the checksum is location at the
                //back or the front
                //  true: front
                //  false: back
                set f=integer(eh[this][p])&gt;rsh[el[this]]
                if (not f) then
                    set i.base=b10
                endif

                //if the stored checksum wasn&#039;t equal to the generated checksum, the
                //  code isn&#039;t valid. This is if the checksum is in the back.
                                    //checksum stored in code                            //code&#039;s actual checksum
                if (not f and i.divide(eh[this][p])!=Checksum(i,eh[this][p])) then
                    call i.destroy()
                    return 0
                endif

                //allocate data buffer
                if (0==dn[0]) then
                    set dc=dc+1
                    set t=dc
                else
                    set t=dn[0]
                    set dn[0]=dn[t]
                endif

                set dn[t]=t
                set dl[t]=t

                //initialize data buffer
                set de[t]=this                                    //data buffer encoder
                set dm[t]=Link(this).start()                      //open the loop

                loop
                    //prepare next slot
                    call t.open()

                    //exit when there are no slots left (finalized)
                    exitwhen df[t]

                    //divide BigInt by shifted high bound of current node of current slot
                    //  this returns the value*
                    set v=i.divide(rsh[dd[dl[t]]])

                    //retrieve node
                    set n=dd[dl[t]]
                    set o[dl[t]]=v

                    //shift the value back to what it originally was
                    if (rf[n]==AN) then
                        set v=-v+rh[n]
                    else
                        set v=v+rl[n]
                    endif

                    //store value into depth pointer id
                    set dm[t].depthPointer.id=v

                    //store value
                    set dv[dl[t]]=v
                endloop

                //unset finalization flag
                set df[t]=false

                //if the checksum was in the front
                if (f) then
                    //first, retrieve the checksum
                    set v=i.toInt()

                    //rebuild the entire number
                    call i.destroy()
                    set i=i.create(b10)
                    set n=dl[t]
                    loop
                        call i.multiply(rsh[dd[n]])
                        call i.add(o[n],0)
                        set n=dl[n]
                        exitwhen n==t
                    endloop

                    //compare the checksum stored in the number to the checksum
                    //that the number actually generates
                    if (v!=Checksum(i,eh[this][p])) then
                        //if they aren&#039;t equal, code wasn&#039;t valid
                        call i.destroy()

                        set de[t]=0       //data buffer encoder=null

                        //deallocate data buffer
                        set dn[dl[t]]=dn[0]
                        set dn[0]=t

                        //return null
                        return 0
                    endif
                endif

                call i.destroy()

                //code was valid, so return DataBuffer
                set dp[t]=dn[t]       //current node
                set dz[t]=di[dn[t]]   //current link id

                return t
            endif

            return 0
        endmethod

        /*************************************************************************************
        *
        *   write
        *       Attempts to write value into a code string.
        *
        *       integer p:          Player id to write code string for
        *
        *       returns:            DataBuffer
        *                               0 means DataBuffer couldn&#039;t be openned
        *
        *************************************************************************************/
        method write takes integer p returns DataBuffer
            local integer t
            //ensure the player is valid
            debug if (0!=ph[p]) then
                //ensure the encoder is valid
                if (null!=er[this]) then
                    //allocate data buffer
                    if (0==dn[0]) then
                        set dc=dc+1
                        set t=dc
                    else
                        set t=dn[0]
                        set dn[0]=dn[t]
                    endif
                    set dn[t]=t
                    set dl[t]=t

                    //initialize the buffer
                    set dp[t]=p                                       //data buffer player
                    set de[t]=this                                    //data buffer encoder
                    set df[t]=false                                   //buffer finalized?
                    set dw[t]=true                                    //open data buffer for writing
                    set dm[t]=Link(this).start()                      //open the loop

                    //open first buffer slot
                    call DataBuffer(t).open()

                    //return the buffer
                    return t
                endif
            debug else
                debug if (0==ph[p]) then
                    debug call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,60,&quot;ENCODER ERROR: INVALID PLAYER&quot;)
                debug endif
            debug endif

            //returning 0 means something was wrong
            return 0
        endmethod
    endstruct

    /*************************************************************************************
    *
    *   Initialization
    *
    *************************************************************************************/
    private module Init
        private static method onInit takes nothing returns nothing
            //Retrieve all human player hashes (StringHash player name)
            local integer i=11
            local player p
            set pn[16]=-1
            loop
                set p=Player(i)
                if (GetPlayerSlotState(p)==PLAYER_SLOT_STATE_PLAYING and GetPlayerController(p)==MAP_CONTROL_USER) then
                    set ph<i>=StringHash(StringCase(GetPlayerName(p)+PLAYER_CHECKSUM_SALT,false))
                    if (0&gt;ph<i>) then
                        set ph<i>=-ph<i>
                    endif
                    set pn<i>=pn[16]
                    set pn[16]=i
                endif
                exitwhen 0==i
                set i=i-1
            endloop
            set p=null

            //initialize base 10, binary, and the global encoder base
            set b10=Base[&quot;0123456789&quot;]
            set es=Base[VER_BASE]
        endmethod
    endmodule

    private struct Inits extends array
        implement Init
    endstruct
endlibrary
</i></i></i></i></i></i></i></i></i></i>
 

Narks

Vastly intelligent whale-like being from the stars
Reaction score
90
Compared to most save/load code systems, this one probably outputs codes that are less than half the size. The current data within the demo map outputs a huge code. See Welcome to see how much data is actually being packed (way more than codes of around the same size!).

please show benchmarks before making such statements

furthermore, this is just as secure as every other save/load system - because the person who breaks the system goes straight for war3map.j...
 

Nestharus

o-o
Reaction score
84
->please show benchmarks before making such statements

Comparisons were done in the BigInt thread. Of many save/load systems, only one could compete with this for size. The others were horrible.

furthermore, this is just as secure as every other save/load system - because the person who breaks the system goes straight for war3map.j...

Actually, most people port the system over to another map, and considering this is broken up into many different scripts, porting would be a serious pain ;p. Code wise (the actual outputted save/load code), it's more secure though =).
 

Narks

Vastly intelligent whale-like being from the stars
Reaction score
90
Actually, most people port the system over to another map, and considering this is broken up into many different scripts, porting would be a serious pain ;p.

er, no they dont - they take the map, inject code into war3map.j (usually a cheatpack), then disable any anti-cheats or anti-single player functions

nobody ports the system over to another map
 

Nestharus

o-o
Reaction score
84
Eh, blocking that would require a cumbersome anti cheat pack ;|.

btw, I've cracked save/load codes before w/o access to code, so security does help protect against someone just running a few saves with small changes and figuring out what values are what as well as where the checksum is ;D.

I probably wouldn't be able to crack this w/o access to the code with even a hundred saves =). Even with access, it would take me a long time to take a code and break it back down into its numbers.

Regardless, this still generates codes that are less than half the size of all placeholder based save/load systems, which is pretty much all of them ;D.
 

Narks

Vastly intelligent whale-like being from the stars
Reaction score
90
so how does this system compress data? it just converts to a higher base?
 

Nestharus

o-o
Reaction score
84
compress, value shifting, if checksum bigger than largest value, add checksum, otherwise multiply in.
 

Nestharus

o-o
Reaction score
84
Changes:
2.0.0.1-

Added |r before every space so that space characters aren't colored.

2.0.1.0-

Remove |r before every space and added support for coloring spaces.

Demo map-

Fixed a catalog bug (item with 10 charges was in 0 charge area)
Updated BigInt to latest version (had a bug in it)
Updated UnitStatePercent to latest version (slightly better)
Changed save/load display from the weak text to a multiboard + dialog =), see screenshot
 

Nestharus

o-o
Reaction score
84
Blizzard's could block that at any time like they did with return bug :\, otherwise I'd be all for it ^)^.

Also, I added an information post which goes over this thing ;P.
 
Reaction score
456
Nestharus, I must ask. Do you also like recoloring invisible pink unicorns?

EDIT//: I didn't notice that space character is not actually "space". Why not to make it just space?
 

Nestharus

o-o
Reaction score
84
EDIT//: I didn't notice that space character is not actually "space". Why not to make it just space?

Read the settings, you can change it to whatever you like.
JASS:

//
    /*************************************************************************************
    *
    *   Coloring Settings
    *
    *************************************************************************************/
        private constant string NUM_COLOR = &quot;|cff05edff&quot;    //what to color numbers
        private constant string LOWER_COLOR = &quot;|cffff69b4&quot;  //what to color lowercase characters
        private constant string UPPER_COLOR = &quot;|cff649664&quot;  //what to color uppercase characters
        private constant string SPEC_COLOR = &quot;|cffffff00&quot;   //what to color special characters
        private constant string SPACE_COLOR = &quot;|cffffffff&quot;  //what to color space characters
    
    /*************************************************************************************
    *
    *   Spacing Settings
    *
    *************************************************************************************/
        private constant string SPACE = &quot;-&quot;                 //space to make code easier to read
        private constant integer SPACE_COUNT = 4            //how many characters per space


edit
updated (still no bugs to fix ^^)
Changes-
Added the dynamic checksum placement back in for minimal codes (was dumb to take it out in the first place)

Added more documentation to the demo map with a step by step tutorial on how to build an Encoder object =D. Learn about Catalogs before learning about Encoders o-o.

edit
Ok, this is what Dr Super Good says (more or less)-

The community should raise the standards to that of Encoder v2. This allows for new systems (if any) to enter the market and gets rid of the older systems that don't make the cut.

edit
updated demo map to have latest UnitStatePercent.
 

Nestharus

o-o
Reaction score
84
Updated demo map to have latest Catalog system. Catalog had a bit of a bug in it with retrieving raw ascii values with catalogs added to catalogs.
 

Nestharus

o-o
Reaction score
84
Added a new parameter to Encoder.create for version control : )

JASS:

*           -   integer encoderVersion          Used for version control on encoders. toString returns this value and
*           -                                   convertString takes the toString value and converts it back into the encoder
*           -                                   toString() -&gt; encoderVersion
*           -                                   convertString(encoderVersion)


2.0.2.2 also fixed a bug, which had to do with more advanced features. I figure I'm the first one to run into it ;p.
 

Romek

Super Moderator
Reaction score
963
Saving and Loading is only as good as the user allows. I'd code the entire thing myself if I needed it, so that it'd be specifically catered for my map.
However, you seem to have made decent save/load code a good deal easier to make, so good job. I'll take a look at this in more detail soon* (exams soon :(), but it looks promising.

It's a shame that it uses some of your less-promising, more useless systems. But I guess there's always a first. Good job!
 

Nestharus

o-o
Reaction score
84
Actually, this outputs codes that are as good as the best save/load systems specifically tailor made for maps =). I spent like 24 hours on a save/load implementation for someone's map to output the best code possible ;o... hehe, it's really a lot of work. But anyways, pleased with the result

34 char code -> 9-22 char code =D.

CodeGen -> Encoder

And with super simplicity, it was 34->23. The last 12 or so hours was time spent upgrading it =P.

You should understand why I'm proud of this after reading my huge save/load tutorial ^)^. You should also understand why I'm pushing for all other save/load systems and tutorials to be deprecated for this =p.

Here are some pretty cool algorithms I discovered. You should be able to understand them after reading up a bit.
Code:
call inventory.linka(item)         //items

//n sized inventory (as many items as you want). Same technique can be used to save armies or w/e
call item.link(1,ItemCatalog.count,item,INV_ITEM)

JASS:

//6 slot stringed up item inventory
//only saves first empty slot ^)^, so if only 1 item in inventory, only saves 2 items
call item1.link(1,ItemCatalog.count,item2,0)        //6 slots
call item2.link(1,ItemCatalog.count,item3,0)        //5 slots
call item3.link(1,ItemCatalog.count,item4,0)        //4 slots
call item4.link(1,ItemCatalog.count,item5,0)        //3 slots
call item5.link(1,ItemCatalog.count,item6,0)        //2 slots
//item6                                             //1 slot

//12 slot inventory: 6+5+1 = 12
//only saves first empty slot again
//item12: 1
call item12.link(1,ItemCatalog.count,item1,0)       //12 slots, 6
call item12.link(1,ItemCatalog.count,item2,0)       //12 slots, 5


JASS:

local CodeRange level = CodeRange.create(1,20)
local CodeRange xp = CodeRange.create(0, 99)

call hero.linka(level)          //level
call level.link(1,19,xp,0)      //xp%, max lvl 20



But yea, this save/load system is my baby =).


edit
Here's a link to a map that uses it -> http://www.hiveworkshop.com/forums/...0-pearleastkingdom1-9-pearleastkingdom1.9.w3x

Implemented by me. That's the 9-23 char beautiful implementation ;D. I didn't put in a multiboard because I wanted to make it simpler for the author to deal with (if they want a multiboard all of a sudden and mine hides their multiboard, I doubt they'd know how to put it up again).

It also shows how I pulled off class specific items =P, which helped save some space.

Here are some codes from it

Default start unit with starting 4 items and I am just using the healing pot from code to code (-1 charge). At the second last, I have no healing pots left and the start 200 gold. At the end, I spend my 200g on pots, drop them and then save. This was in single player, which has a bit higher security than multiplayer. Notice how drastically the code changes with super small value changes ^)^ (1 bit, smallest value change possible)
Code:
7Ikq-AJrp-8O5Y (10 item charge)
HRQw-zbbT-m6vA (9 item charge)
sUEC-YSNC-kWkA (8)
DL2y-gdGT-r8EV (7)
a3uH-9WgP-uGpb
Zl0M-WV1O-Hsxw (5)
aUVk-u7aw-LB9T
DF9b-mgo0-YorX (3)
bJCQ-R7IB-AEiy
HrNX-81cu-OxhX (1)
4W63-oOmE-wRA (0),(200g)
1Q4y-ndXz-m (0),(0g)
 
General chit-chat
Help Users
  • No one is chatting at the moment.

      The Helper Discord

      Members online

      No members online now.

      Affiliates

      Hive Workshop NUON Dome World Editor Tutorials

      Network Sponsors

      Apex Steel Pipe - Buys and sells Steel Pipe.
      Top