Okay I'll take a stab at that question. What I've come to use is a pretty simple little framework of code for every map:
Code:
function H2I takes handle value returns integer
return value
return 0
endfunction
function I2U takes integer value returns unit
return value
return null
endfunction
function I2Timer takes integer value returns timer
return value
return null
endfunction
//Note: VarCache is a global game cache variable
function SetHandleInt takes handle subject, string name, integer value returns nothing
call StoreInteger(udg_VarCache, I2S(H2I(subject)), name, value)
endfunction
function GetHandleInt takes handle subject, string name returns integer
return GetStoredInteger(udg_VarCache, I2S(H2I(subject)), name)
endfunction
function SetHandleReal takes handle subject, string name, real value returns nothing
call StoreReal(udg_VarCache, I2S(H2I(subject)), name, value)
endfunction
function GetHandleReal takes handle subject, string name returns real
return GetStoredReal(udg_VarCache, I2S(H2I(subject)), name)
endfunction
function DoesHandleVarExist takes handle subject, string name returns boolean
return HaveStoredInteger(udg_VarCache, I2S(H2I(subject)), name)
endfunction
function FlushHandle takes handle subject returns nothing
call FlushStoredMission(udg_VarCache, I2S(H2I(subject)))
endfunction
Of these, the following are the most important:
H2I - Handle to Int. Because you can convert Int's to almost anything with handle bug, Int's are what I use most.
I2U - Int to Unit, quite often, the information your storing is a [reference to a] unit. Other RB exploiters include ones like I2Timer, I2Trigger, I2Item.
Of the next group of functions, SetHandleInt and GetHandleInt are basically generic custom values for any handle you please. Most often this will be a unit, but also commonly a trigger or timer. But again, you can use it to attach values to pratically anything you might need, like items, groups, quests. The good thing is because they take a handle you can use them with any handle and don't need lots of functions (like you don't need SetUnitInt)
A simple example, lets say you want to record some piece of data for a unit:
Code:
//set
call SetHandleInt(tempUnit, "age", 1)
//get
local integer a = GetHandleInt(tempunit,"age")
//modify
call SetHandleInt(tempUnit,"age",a+1)
So it can be used almost exactly like a units custom value.
Now, lets say you want to link two units together, say a summoned unit to the summoning unit, you could do it like this:
Code:
call SetHandleInt(GetSummonedUnit(),"master",H2I(GetSummoningUnit())
Now to get a summoned units master you can do this:
Code:
local unit master
if DoesHandleVarExist(GetEnumUnit(),"master") then
//Unit has a master, so do stuff
set master = I2U(GetHandleInt(GetTriggerUnit())
call IssuePointOrder(GetEnumUnit(),"move",GetUnitX(master),GetUnitY(master))
endif
Finally, you might want to clean up the variables when a unit dies.
Code:
//generic event "unit dies"
call FlushHandle(GetDyingUnit())
Now it seems that every advanced JASS coder has slightly different prefences on exactly how they use handle vars, like with function names and semantics and stuff. And I didn't invent mine either, I originally ripped it from Battledome but have since modified it some. As an example, some people prefer to have additional functions like this:
Code:
function SetHandleUnit takes handle h, string name, unit u returns nothing
call SetHandleInt(h,name,H2I(u))
endfunction
function GetHandleUnit takes handle h, string name returns unit
return I2U(GetHandleInt(h,name))
endfunction
So the "H2I" and "I2U" conversions are done inside the functions - they are wrappers for Get/SetHandleInt. This can arguably make code more readable and I actually did use such functions for a while, because it makes it more clear what is going on.
