A bunch of beginner LUA questions

[Shinni]

I wrote a little script to help me add map pins.
However, this is my first time working with LUA and while understanding other scripts works fine, writing "blind" is kinda hard.
I can't test my script without a beta, so there are probably a bunch of errors in it.
There are some sections where I am really unsure whether they work (see bottom of this post).
Feel free to read the whole script, though. There are probably other errors i couldn't find.
(You may also correct my English, if I made some mistakes. I don't mind improving in another language besides LUA )

complete script:

Warning: Spoiler

CustomMapPins = ZO_Object:Subclass()
 
function CustomMapPins:New( ... )
    local result = ZO_Object.New( self )
    result:Initialize( ... )
    
    return result
end
 
function CustomMapPins:Initialize()
    self.defaultIcon = "EsoUI/Art/MapPins/hostile_pin.dds"
    self.pins = {}
end
 
-- redraws the pins for the given pinType (removes them, if the pinType is disabled)
-- redraws all pinTypes if parameter ommited
function CustomMapPins:RefreshPins( pinType )
    ZO_WorldMap_RefreshCustomPinsOfType( pinType )
end
 
-- removes the pin with given pintype and tag
-- you may want to call refreshPins after removing pins
function CustomMapPins:RemovePin( pinType, pinTag )
    self.pins[pinType][pinTag] = nil
end
 
-- creates a pin of pinType on the given location (subzone, locx, locy).
-- pinType will be created with the default icon if undefined
-- radius may be omitted/nil if it's a real pin instead of an area
-- pinTag should be an uniqe identifier but can be ommited
-- after adding your pins you want to call RefreshPins, so the pins are actually drawn to the map
function CustomMapPins:CreatePin( pinType, subzone, locx, locy, radius, pinTag )
    if not self.pins[pinType] then
        self:CreatePinType( pinType )
    end
    
    --create default pinTag if no parameter given
    if not pinTag then
        pinTag = { pinType, subzone, locx, locy }
    end
    
    self.pins[pinType][pinTag] = { zone = subzone, x = locx, y = locy, radius = radius }
end
 
-- creates a new pinType
-- eg:
-- CreatePinType( "Jute", { level = 20, texture = "MyAddon/That_nice_icon_esohead_is_using_for_their_map.dds" } , "delicous Jute... gather me now!" )
-- attributes for pinLayoutData:
-- level (priority of the tag; player has 160, groupmembers 130, quest 110, keeps 30)
-- texture: quote: 
--  "How the texturing data works:
--  The texture can come from a string or a callback function
--  If it's a callback function it must return first the base icon texture, and second the pin's pulseTexture"
-- size, minSize, isAnimated, insetX, insetY
function CustomMapPins:CreatePinType( pinType, pinLayoutData, pinTooltipCreator )
    --simple tooltip, showing only the given string
    if type(pinTooltipCreator) == "string" then
        pinTooltipCreator = { creator = function(pin) InformationTooltip:AddLine(pinTooltipCreator) end, tooltip = InformationTooltip }
    end
    
    --use default pin icon and move pins of this type behind all other pins (level 20)
    if not pinLayoutData then
        pinLayoutData = { level = 20, texture = self.defaultIcon }
    end
    
    ZO_WorldMap_AddCustomPin(
        pinType,
        -- this function is called everytime, the customs pins of the given pinType are to be drawn (map update because of zone/area change or RefreshPins call)
        function( g_mapPinManager )
            for pinTag, pin in pairs(self.pins[pinType]) do
                --only draw pin, if player is on the correct map
                if pin.zone = GetMapName() then
                    if pin.radius then
                        g_mapPinManager:CreatePin( pinType, pinTag, pin.x, pin.y, pin.radius )
                    else
                        g_mapPinManager:CreatePin( pinType, pinTag, pin.x, pin.y )
                    end
                end
            end
        end,
        nil, -- a function to be called, when the map is resized... no need when using default pins
        pinLayoutData,
        pinTooltipCreator
    )
    --enable this pinTag by default
    ZO_WorldMap_SetCustomPinEnabled(pinType, true)
    
    self.pins[pinType] = {}
end
 
-- en-/disables the given pinType
-- this function allows the implementation of filters
function CustomMapPins:enablePins( pinType, enable )
    ZO_WorldMap_SetCustomPinEnabled( pinType, enable )
end

1)
Does this delete the entry with the key pinTag, or will the key be associated with the value nil?
(The former implies the later but will pairs(self.pins[pinType]) yield (pinTag, nil) or is it completely removed from the table?)

self.pins[pinType][pinTag] = nil

2)
radius = radius gives me headaches...I'm really unsure about this. (Line 42)

pins[pinTag] = { area = subzone, x = locx, y = locy, radius = radius }

3)
At first, pinTooltipCreator is a string, but then its assigned to a table.
What happens with AddLine(pinTooltipCreator)? What's the application order of LUA?
Will it add the string because when the function was defined, pinTooltipCreator was still a string?
...or will it crash because when the function is executed, pinTooltipCreator is a table?

if type(pinTooltipCreator) == "string" then
    pinTooltipCreator = { creator = function(pin) InformationTooltip:AddLine(pinTooltipCreator) end, tooltip = InformationTooltip }
end

4)
The function is defined and called inside methods of two different objects. Will self represent the defining or the executing object?

function( g_mapPinManager )
    for pinTag, pin in pairs(self.pins[pinType]) do
        --only draw pin, if player is on the correct map
        if pin.zone = GetMapName() then
            if pin.radius then
                g_mapPinManager:CreatePin( pinType, pinTag, pin.x, pin.y, pin.radius )
            else
                g_mapPinManager:CreatePin( pinType, pinTag, pin.x, pin.y )
            end
        end
    end
end

[Pawkette]

You wanna call

self:CreatePinType

Key being the colon instead of a period, also Create instead of create. Colon signifies self being passed invisibly to the function.

foo:Bar() == foo.Bar( self )

Will keep reading

[Shinni]

Thanks, I fixed the mentioned errors.
Using : instead of . is kinda new to me. I've rarely seen a : in other languages.

[Wukar]

Lua indeed has some nice benefits.

http://www.lua.org/pil/5.html

Lua also offers a special syntax for object-oriented calls, the colon operator. An expression like o:foo(x) is just another way to write o.foo(o, x), that is, to call o.foo adding o as a first extra argument. In Chapter 16 we will discuss such calls (and object-oriented programming) in more detail.