[vJASS] GetUnitCollisionSize (exact)

[SA Dashie]

Worked on from Vexorian's system, GetunitCollisionSize.

His system was off by decimal places and I need it to be accurate to the collision size value that the user gave the unit. The way I came up with the exact value the unit has with collision size is kinda dumb, but from my testing it works without fault.

I also created a new GetUnitTypeIdCollisionSize function.

Versions:
- Standalone (calculates new value even when unit type has been calculated before).
- Table (calculates new value once for every unit type has been calculated before).

There is no Cache version as I don't know where I would get the CSSafeCache (or another Cache) library from.

Standalone version

library_once GetUnitCollisionSize
//********************************************************
//* GetUnitCollisionSize (Standalone version, exact)
//* --------------------
//*   If you need it, use it.
//*
//*  Originally by Vexorian,
//*  edited by SA Dashie for 100% accuracy
//*
//*  Gives out the correct number everytime from
//*  1.00 collision size to 1000.00
//*
//*
//* To implement it just create a custom text 'trigger'
//* called GetUnitCollisionSize, and paste this there.
//*
//* To copy from one map to another just copy the trigger
//* holding this code to the target map.
//*
//*
//*  API:
//*
//*    function GetUnitCollisionSize takes unit u returns real
//*  
//*    function GetUnitTypeIdCollisionSize takes integer i returns real
//*
//*********************************************************

//========================================================
    globals
        private constant integer ITERATIONS         = 27    //DO NOT TOUCH; have not tested, although it may throw out the wrong number
                                                            //if the ITERATIONS variable is changed...
                                                            //too much, slow, too short "innacurate", let it be bigger than 0...
                                                            //27 iterations will always return the right value...
        public  constant real    MAX_COLLISION_SIZE = 1000.0//DO NOT TOUCH; have not tested, although it may throw out the wrong number
                                                            //if the MAX_COLLISION_SIZE variable is changed...
                                                            //should be THE max collision size in the map,
                                                            //well, not really, just make sure it is greater than it
                                                            //few maps should have collision sizes bigger than 300.0...
        private real array       correction                 //starting from highest, if collision value is less than indexed
                                                            //value then the collision value get's the index*0.01 taken away
                                                            //from the value and corrected to only have 2 decimal places...
        private constant integer CORRECTION_COUNT    = 42   //how many indexes the correction array has...
    endglobals

    private module initCorrection
        private static method onInit takes nothing returns nothing
            set correction[1]=55.85
            set correction[2]=26.66
            set correction[3]=17.50
            set correction[4]=13.06
            set correction[5]=10.39
            set correction[6]=8.66
            set correction[7]=7.43
            set correction[8]=6.50
            set correction[9]=5.79
            set correction[10]=5.20
            set correction[11]=4.75
            set correction[12]=4.35
            set correction[13]=4.02
            set correction[14]=3.75
            set correction[15]=3.50
            set correction[16]=3.29
            set correction[17]=3.10
            set correction[18]=2.94
            set correction[19]=2.79
            set correction[20]=2.66
            set correction[21]=2.55
            set correction[22]=2.44
            set correction[23]=2.35
            set correction[24]=2.26
            set correction[25]=2.17
            set correction[26]=2.10
            set correction[27]=2.031
            set correction[28]=1.971
            set correction[29]=1.911
            set correction[30]=1.861
            set correction[31]=1.811
            set correction[32]=1.761
            set correction[33]=1.721
            set correction[34]=1.672
            set correction[35]=1.641
            set correction[36]=1.602
            set correction[37]=1.571
            set correction[38]=1.541
            set correction[39]=1.511
            set correction[40]=1.481
            set correction[41]=1.452
            set correction[42]=1.431
        endmethod
    endmodule
  
    private struct inits extends array
        implement initCorrection
    endstruct

//========================================================
function GetUnitCollisionSize takes unit u returns real
 local integer i=0
 local real x=GetUnitX(u)
 local real y=GetUnitY(u)
 local real hi
 local real lo
 local real mid
 local string convert


 // At about 27 loops it is accurate enough to go to the next stage
    set hi=MAX_COLLISION_SIZE
    set lo=0.0
    loop
        set mid=(lo+hi)/2.0
        exitwhen (i==ITERATIONS)
        if (IsUnitInRangeXY(u,x+mid,y,0.0)) then
            set lo=mid
        else
            set hi=mid
        endif
        set i=i+1
    endloop
  
  
 // The smaller the collision size, the bigger the added decimal places there are
 // Let's fix that and remove those extra decimal places to make it 100% accurate to the original collision size (to 2 decimal places)
    set i=CORRECTION_COUNT
    loop
        if (mid<correction[i]) then
            set mid=mid-i*0.01
            exitwhen true
        endif
        exitwhen (i==1)
        set i=i-1
    endloop
    set convert=R2S(mid)
    set mid=S2R(SubString(convert,0,StringLength(convert)-1))
  
  
 return mid
endfunction

function GetUnitTypeIdCollisionSize takes integer i returns real
 local unit u=CreateUnit(Player(14),i,0,0,0)
 local real mid=GetUnitCollisionSize(u)
 call RemoveUnit(u)
 set u=null
 return mid
endfunction

endlibrary

Table version

library_once GetUnitCollisionSize initializer init requires Table // http://www.hiveworkshop.com/threads/snippet-new-table.188084/
//********************************************************
//* GetUnitCollisionSize (Table version, exact)
//* --------------------
//*   If you need it, use it.
//*
//*  Originally by Vexorian,
//*  edited by SA Dashie for 100% accuracy
//*
//*  Gives out the correct number everytime from
//*  1.00 collision size to 1000.00
//*
//*
//* To implement it just create a custom text 'trigger'
//* called GetUnitCollisionSize, and paste this there.
//*
//* To copy from one map to another just copy the trigger
//* holding this code to the target map.
//*
//*
//*  API:
//*
//*    function GetUnitCollisionSize takes unit u returns real
//*  
//*    function GetUnitTypeIdCollisionSize takes integer i returns real
//*
//*********************************************************

//========================================================
    globals
        private constant integer ITERATIONS         = 27    //DO NOT TOUCH; have not tested, although it may throw out the wrong number
                                                            //if the ITERATIONS variable is changed...
                                                            //too much, slow, too short "innacurate", let it be bigger than 0...
                                                            //27 iterations will always return the right value...
        public  constant real    MAX_COLLISION_SIZE = 1000.0//DO NOT TOUCH; have not tested, although it may throw out the wrong number
                                                            //if the MAX_COLLISION_SIZE variable is changed...
                                                            //should be THE max collision size in the map,
                                                            //well, not really, just make sure it is greater than it
                                                            //few maps should have collision sizes bigger than 300.0...
        private real array       correction                 //starting from highest, if collision value is less than indexed
                                                            //value then the collision value get's the index*0.01 taken away
                                                            //from the value and corrected to only have 2 decimal places...
        private constant integer CORRECTION_COUNT    = 42   //how many indexes the correction array has...
      
      
        private Table memo
    endglobals

    private module initCorrection
        private static method onInit takes nothing returns nothing
            set correction[1]=55.85
            set correction[2]=26.66
            set correction[3]=17.50
            set correction[4]=13.06
            set correction[5]=10.39
            set correction[6]=8.66
            set correction[7]=7.43
            set correction[8]=6.50
            set correction[9]=5.79
            set correction[10]=5.20
            set correction[11]=4.75
            set correction[12]=4.35
            set correction[13]=4.02
            set correction[14]=3.75
            set correction[15]=3.50
            set correction[16]=3.29
            set correction[17]=3.10
            set correction[18]=2.94
            set correction[19]=2.79
            set correction[20]=2.66
            set correction[21]=2.55
            set correction[22]=2.44
            set correction[23]=2.35
            set correction[24]=2.26
            set correction[25]=2.17
            set correction[26]=2.10
            set correction[27]=2.031
            set correction[28]=1.971
            set correction[29]=1.911
            set correction[30]=1.861
            set correction[31]=1.811
            set correction[32]=1.761
            set correction[33]=1.721
            set correction[34]=1.672
            set correction[35]=1.641
            set correction[36]=1.602
            set correction[37]=1.571
            set correction[38]=1.541
            set correction[39]=1.511
            set correction[40]=1.481
            set correction[41]=1.452
            set correction[42]=1.431
        endmethod
    endmodule
  
    private struct inits extends array
        implement initCorrection
    endstruct

//=========================================================
function GetUnitCollisionSize takes unit u returns real
 local integer i=0
 local real x=GetUnitX(u)
 local real y=GetUnitY(u)
 local integer typ=GetUnitTypeId(u)
 local real hi
 local real lo
 local real mid
 local string convert


 // At about 27 loops it is accurate enough to go to the next stage
    set hi=MAX_COLLISION_SIZE
    set lo=0.0
    loop
        set mid=(lo+hi)/2.0
        exitwhen (i==ITERATIONS)
        if (IsUnitInRangeXY(u,x+mid,y,0.0)) then
            set lo=mid
        else
            set hi=mid
        endif
        set i=i+1
    endloop
  
  
 // The smaller the collision size, the bigger the added decimal places there are
 // Let's fix that and remove those extra decimal places to make it 100% accurate to the original collision size (to 2 decimal places)
    set i=CORRECTION_COUNT
    loop
        if (mid<correction[i]) then
            set mid=mid-i*0.01
            exitwhen true
        endif
        exitwhen (i==1)
        set i=i-1
    endloop
    set convert=R2S(mid)
    set mid=S2R(SubString(convert,0,StringLength(convert)-1))
  
    set memo[typ]=mid
  
  
 return mid
endfunction

function GetUnitTypeIdCollisionSize takes integer i returns real
 local unit u=CreateUnit(Player(14),i,0,0,0)
 local real mid=GetUnitCollisionSize(u)
 call RemoveUnit(u)
 set u=null
 return mid
endfunction

    private function init takes nothing returns nothing
     set memo=Table.create()
    endfunction

endlibrary

//--

old code

Standalone version

library_once GetUnitCollisionSize
//********************************************************
//* GetUnitCollisionSize (Standalone version, exact)
//* --------------------
//*   If you need it, use it.
//*
//*  Originally by Vexorian,
//*  edited by SA Dashie for 100% accuracy
//*
//*
//* To implement it just create a custom text 'trigger'
//* called GetUnitCollisionSize, and paste this there.
//*
//* To copy from one map to another just copy the trigger
//* holding this code to the target map.
//*
//*
//*  API:
//*
//*    function GetUnitCollisionSize takes unit u returns real
//*
//*    function GetUnitTypeIdCollisionSize takes integer i returns real
//*
//*********************************************************

//========================================================
    globals
        private constant integer ITERATIONS         = 27    //too much, slow, too short "innacurate", let it be bigger than 0...
                                                            //27 iterations will always return the right value...
        public  constant real    MAX_COLLISION_SIZE = 1000.0//should be THE max collision size in the map,
                                                            //well, not really, just make sure it is greater than it
                                                            //few maps should have collision sizes bigger than 300.0...
        private real array correction                       //starting from highest, if collision value is less than indexed
                                                            //value then the collision value get's the index*0.01 taken away
                                                            //from the value and corrected to only have 2 decimal places...
    endglobals

    private module initCorrection
        private static method onInit takes nothing returns nothing
            set correction[1]=53.97
            set correction[2]=26.31
            set correction[3]=17.34
            set correction[4]=12.95
            set correction[5]=10.32
            set correction[6]=8.58
            set correction[7]=7.35
            set correction[8]=6.41
            set correction[9]=5.69
            set correction[10]=5.10
            set correction[11]=4.63
            set correction[12]=4.23
            set correction[13]=3.90
            set correction[14]=3.61
            set correction[15]=3.35
            set correction[16]=3.14
            set correction[17]=2.94
            set correction[18]=2.77
            set correction[19]=2.61
            set correction[20]=2.47
            set correction[21]=2.34
            set correction[22]=2.23
            set correction[23]=2.12
            set correction[24]=2.02
            set correction[25]=1.93
            set correction[26]=1.85
            set correction[27]=1.77
            set correction[28]=1.70
        endmethod
    endmodule

    private struct inits extends array
        implement initCorrection
    endstruct

//========================================================
function GetUnitCollisionSize takes unit u returns real
local integer i=0
local real x=GetUnitX(u)
local real y=GetUnitY(u)
local real hi
local real lo
local real mid
local string convert


    set hi=MAX_COLLISION_SIZE
    set lo=0.0
    loop
        set mid=(lo+hi)/2.0
        exitwhen (i==ITERATIONS)
        if (IsUnitInRangeXY(u,x+mid,y,0.0)) then
            set lo=mid
        else
            set hi=mid
        endif
        set i=i+1
    endloop

    if (mid<correction[28]) then
        set mid=1.42
    else
        set i=27
        loop
            if (mid<correction[i]) then
                set mid=mid-i*0.01
                exitwhen true
            endif
            exitwhen (i==1)
            set i=i-1
        endloop
        set convert=R2S(mid)
        set mid=S2R(SubString(convert,0,StringLength(convert)-1))
    endif


return mid
endfunction

function GetUnitTypeIdCollisionSize takes integer i returns real
local unit u=CreateUnit(Player(14),i,0,0,0)
local real mid=GetUnitCollisionSize(u)


call RemoveUnit(u)
set u=null

return mid
endfunction

endlibrary

Table version

library_once GetUnitCollisionSize initializer init requires Table // http://www.hiveworkshop.com/threads/snippet-new-table.188084/
//********************************************************
//* GetUnitCollisionSize (Table version, exact)
//* --------------------
//*   If you need it, use it.
//*
//*  Originally by Vexorian,
//*  edited by SA Dashie for 100% accuracy
//*
//*
//* To implement it just create a custom text 'trigger'
//* called GetUnitCollisionSize, and paste this there.
//*
//* To copy from one map to another just copy the trigger
//* holding this code to the target map.
//*
//*
//*  API:
//*
//*    function GetUnitCollisionSize takes unit u returns real
//*
//*    function GetUnitTypeIdCollisionSize takes integer i returns real
//*
//*********************************************************

//=========================================================
    globals
        private constant integer ITERATIONS         = 27    //too much, slow, too short "innacurate", let it be bigger than 0...
                                                            //27 iterations will always return the right value...
        public  constant real    MAX_COLLISION_SIZE = 1000.0//should be THE max collision size in the map,
                                                            //well, not really, just make sure it is greater than it
                                                            //few maps should have collision sizes bigger than 300.0...
        private real array correction                       //starting from highest, if collision value is less than indexed
                                                            //value then the collision value get's the index*0.01 taken away
                                                            //from the value and corrected to only have 2 decimal places...
 
 
        private Table memo
    endglobals

    private module initCorrection
        private static method onInit takes nothing returns nothing
            set correction[1]=53.97
            set correction[2]=26.31
            set correction[3]=17.34
            set correction[4]=12.95
            set correction[5]=10.32
            set correction[6]=8.58
            set correction[7]=7.35
            set correction[8]=6.41
            set correction[9]=5.69
            set correction[10]=5.10
            set correction[11]=4.63
            set correction[12]=4.23
            set correction[13]=3.90
            set correction[14]=3.61
            set correction[15]=3.35
            set correction[16]=3.14
            set correction[17]=2.94
            set correction[18]=2.77
            set correction[19]=2.61
            set correction[20]=2.47
            set correction[21]=2.34
            set correction[22]=2.23
            set correction[23]=2.12
            set correction[24]=2.02
            set correction[25]=1.93
            set correction[26]=1.85
            set correction[27]=1.77
            set correction[28]=1.70
        endmethod
    endmodule

    private struct inits extends array
        implement initCorrection
    endstruct

//=========================================================
function GetUnitCollisionSize takes unit u returns real
local integer i=0
local real x=GetUnitX(u)
local real y=GetUnitY(u)
local integer typ=GetUnitTypeId(u)
local real hi
local real lo
local real mid
local string convert


    if (memo.has(typ) ) then
        return I2R(memo[typ])
    endif


    set hi=MAX_COLLISION_SIZE
    set lo=0.0
    loop
        set mid=(lo+hi)/2.0
        exitwhen (i==ITERATIONS)
        if (IsUnitInRangeXY(u,x+mid,y,0.0)) then
            set lo=mid
        else
            set hi=mid
        endif
        set i=i+1
    endloop

    if (mid<correction[28]) then
        set mid=1.42
    else
        set i=27
        loop
            if (mid<correction[i]) then
                set mid=mid-i*0.01
                exitwhen true
            endif
            exitwhen (i==1)
            set i=i-1
        endloop
        set convert=R2S(mid)
        set mid=S2R(SubString(convert,0,StringLength(convert)-1))
    endif
    set memo[typ]=R2I(mid+0.500000001)
return mid
endfunction

function GetUnitTypeIdCollisionSize takes integer i returns real
local unit u=CreateUnit(Player(14),i,0,0,0)
local real mid=GetUnitCollisionSize(u)


call RemoveUnit(u)
set u=null

return mid
endfunction

    private function init takes nothing returns nothing
     set memo=Table.create()
    endfunction

endlibrary

 

[IcemanBo]

I was not aware that decimals matters for collision. Mind to attach a demo which shows the difference of your system in a mentionable/viewable result where Vex's will be wrong?

 

[Almia]

JASS/script.j at master · nestharus/JASS · GitHub

I am using this on my collision-based things

 

[IcemanBo]

From nestharus his library:

* Assumes collision will always be an integer
*
* 100% accurate to 1 decimal for collision sizes >= 5.1

Dashie, are you here?

 

[SA Dashie]

Test map attached for comparing Vexorian's and mine with the value of the obtained collision size value.
Just click on the unit you want to get the value from.
Uhmm... Mine seems to start to get inaccurate bellow 3.90. I'll fix that sometime.

From nestharus his library:

* Assumes collision will always be an integer
*
* 100% accurate to 1 decimal for collision sizes >= 5.1

Dashie, are you here?

I would rather use a system with decimal accuracy(to double decimal place e.g. 5.00) for public resources as to try to cover everyone's preferences.
Idk someone might need that kinda accuracy..?

The point is here that the collision value set to the unit will be exact, meaning right to the decimal place giving the user of a resource with this one less thing to worry/think about.

 

[Bribe]

Considering object editor has accuracy of only 0.01, why are you using these weird array values instead of just letting the general math resolve the results?

 

[Nestharus]

Uhm..

Remove this line from my lib? I am not sure why I even put it in there.

set m = R2I(m*10)/10.

That'll put it at 3 decimals of accuracy due to this little line

exitwhen nm+.001 > m and nm-.001 < m

Modify the .001 to make it more accurate if you want.


So I dunno... I guess my lib without that random R2I line in it is more accurate than this lib and vexorian's? lol >.>


Yea, the trick is not to iterate N times. The trick is to iterate until your mid point isn't moving around much ^_^.

 

[IcemanBo]

Dashie, what you say to Nestharus's comment?

 

[IcemanBo]

Mine seems to start to get inaccurate bellow 3.90. I'll fix that sometime.

also any news?

 

[IcemanBo]

@SA Dashie.

 

[SA Dashie]

Hi IcemanBo.
I'll try and reply withing the next 2 days. I'll need to retest this code to be sure of some things (can't atm).

 

[SA Dashie]

Nestharus your code presents the same issue as Vexorians (although throws out a different number). It is not 100% accurate to 2 decimal places. The code I present is correction code.

I will give out more details on Monday or soon after. I'll be leaving on an interstate trip till then.

 

[Aniki]

I'm not sure why data that's changeable in the OE shouldn't be exposed to jass (Blizzard haven't provided such native functions), but one could simply read the value from memory (using mem-read):

function GetUnitCollisionSize takes unit u returns real
    return RMemory[GetObjectData(pUnitData, GetUnitTypeId(u)) + 0x19C/4]
endfunction
function GetUnitCollisionSizeById takes integer unit_type_id returns real
    return RMemory[GetObjectData(pUnitData, unit_type_id) + 0x19C/4]
endfunction

 

[Nestharus]

Nestharus your code presents the same issue as Vexorians (although throws out a different number). It is not 100% accurate to 2 decimal places. The code I present is correction code.

I will give out more details on Monday or soon after. I'll be leaving on an interstate trip till then.

Introduction

It you continue to estimate a value until that value no longer changes, then your estimation is no longer an estimate.

If you want to calculate the value down to two decimal places, then you must continue to estimate until the value down to 2 decimal places no longer changes.

My script, your script, and Vexorian's script are all wrong. None of them do this.

In order to do this, you must continue to estimate until the low guess and high guess are within a fraction of the decimal you are looking for. For example, if you are estimating to two decimal places, then the low and high must be within less than .01 of each other. From here, if you then take and round the estimate of this final range, you will get the value down to two decimal places.

Let's test the algorithm out on a value of 7.11. We are going to start the guess with a range of [0, 10]. To the left of the range is the midpoint of that range. To the right of the range is the difference between the high and low of that range. The midpoint is used to update our next range and the difference between the high and the low tells us when to stop.

5 [0 + 10] 10
7.5 [5 + 10] 5
6.25[5 + 7.5] 2.5
6.875[6.25 + 7.5] 1.25
7.1875[6.875 + 7.5] 0.625
7.03125[6.875 + 7.1875] 0.3125
7.109375 [7.03125 + 7.1875] 0.15625
7.1484375[7.109375 + 7.1875] 0.078125 (first decimal captured)
7.12890625[7.109375 + 7.1484375] 0.0390625
7.119140625 [7.109375 + 7.12890625] 0.01953125
7.1142578125 [7.109375 + 7.119140625] 0.009765625 (second decimal captured)

7.1142578125 + .005 = 7.1192578125*100 = 711.92578125 to int = 711/100 = 7.11




Proof

Why does this work?

Firstly, because the difference between the high and low of our estimate is always going to be less than .01, their midpoint must be within less than .005 of the actual value. If delta is the smallest value possible, then we have the following maximal and minimal values

max: actual + .005 - delta
min: actual - .005 + delta

Recall that actual is always going to be accurate to two decimal places. This means that everything past the second decimal place in the actual answer is going to be 0. As such, the 2 decimal places in the answer will not be able to be changed with floored rounding unless either .01 is added (a full decimal) or delta is subtracted.

actual.## + .01 = new number as a result of floored rounding to two decimal places
actual.## - delta = new number as a result of floored rounding to two decimal places

Rounding will add .005 to the number, so if we look at our min/max from before and account for rounding, the following values will be the result

max: actual + .005 + .005 - delta = actual + .01 - delta (first two decimals do not change)
min: actual - .005 + .005 + delta = actual + delta (first two decimals do not change)

What happens if we subtract .005 to round instead of add .005?

max: actual + .005 - .005 - delta = actual - delta (first two decimal places do change!)
min: actual - .005 - .005 + delta = actual - .01 + delta (first two decimal places do change!)


Now for an example of this with real numbers

Consider a target value of 6.99. If the low and high must be less than .01 of each other, then you can have the following scenarios (low end, high end, middle).

high: [6.9899999999999991, 6.999999999999999] (low as close to as possible, maximal difference)
low: [6.980000000000001, 6.9900000000000009] (high as close to as possible, maximal difference)
middle: [6.985000000000001, 6.9900000000000009] (both as centered around as possible, maximal difference)

In all three cases, the values are at the upper limit of a fraction of .01 within each other. In the first case, the values are as high as they can go. In the second case, they are as low as they can go. In the final case, they are as centered around the actual value as possible.

high: 6.99499999999999905 -> 6.99999999999999905 -> 6.99
low: 6.98500000000000095 -> 6.99000000000000095-> 6.99
middle: 6.98750000000000095-> 6.99250000000000095-> 6.99




Script

I have updated the script to reflect the correct algorithm. This will capture the exact collision down to 2 decimal places.

library GetUnitCollision /* v2.0.1.0
*************************************************************************************
*
*   Retrieves collision size for a unit (different from pathing map)
*
*   Accurate to 2 decimals
*
*************************************************************************************
*
*   */uses/*
*
*       */ Table /*             hiveworkshop.com/forums/jass-functions-413/snippet-new-table-188084/
*
*************************************************************************************
*
*   Functions
*
*       function GetUnitCollision takes unit whichUnit returns real
*
************************************************************************************/
   globals
       private Table unitCollisionTable
   endglobals
 
   private function CalculateUnitCollision takes unit u, real x, real y, integer i returns real
       local real low = 0
       local real high = 300
       local real mid = 150
 
       loop
           if (IsUnitInRangeXY(u, x + mid, y, 0)) then
               set low = mid
           else
               set high = mid
           endif

           set mid = (low + high)/2

           exitwhen low + .01 > high
       endloop
 
       set mid = R2I((mid + .005)*100)/100.
 
       set unitCollisionTable.real[unitTypeId] = mid
 
       return mid
   endfunction
   function GetUnitCollision takes unit whichUnit returns real
       local integer unitTypeId = GetUnitTypeId(whichUnit)
 
       if (unitCollisionTable.real.has(unitTypeId)) then
           return unitCollisionTable.real[unitTypeId]
       endif
 
       return CalculateUnitCollision(whichUnit, GetUnitX(whichUnit), GetUnitY(whichUnit), unitTypeId)
   endfunction
 
   private module Initializer
       private static method onInit takes nothing returns nothing
           set unitCollisionTable = Table.create()
       endmethod
   endmodule
 
   private struct init extends array
       implement Initializer
   endstruct
endlibrary

 

[SA Dashie]

Ok considering that I already spent a few hours last night trying to fix my code I'll update it in the original post before I distract myself again.
From my testing (I believe I've done it thoroughly enough) it works to a T from 1.00 -> 1000.00 now (it does not detect below 1.00).
The Table version stored this as an integer and is changed to a real value.

I'll read your post after Nestharus.

 

[Nestharus]

Well, it contains a proof and shows the solution, so you ought to read it : ).

 

[IcemanBo]

Table version doesn't really use table peroperly atm. There could be one script with Table optional, and if no table -> hashtable. (or just set Table mandatory) If table entry exists for a unit type, no unit creation is needed.

Edit:
Can be approved after update.