Back to Home

ESO Lua File v100018

libraries/globals/localization.lua

[◄ back to folders ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
ESO_NumberFormats = {}
local strArgs = {}
function zo_strformat(formatString, ...)
    for i = 1, select("#", ...) do
        local currentArg = select(i, ...)
        if type(currentArg) == "number" then
            local str = ""
            local numFmt = "d"
            local num, frac = math.modf(currentArg)
            
            local width = 0
            local digits = 1
            local unsigned = false
            if ESO_NumberFormats[formatString] ~= nil and ESO_NumberFormats[formatString][i] ~= nil then
                width = ESO_NumberFormats[formatString][i].width or width
                digits = ESO_NumberFormats[formatString][i].digits or digits
                unsigned = ESO_NumberFormats[formatString][i].unsigned or unsigned
            end
            if width > 0 then
                str = string.format("0%d", width)
            end
            if frac ~= 0 then
                numFmt = "f"
                str = str..string.format(".%d", digits)
            elseif unsigned == true then
                numFmt = "u"
            end
            str = string.format("%%%s%s", str, numFmt)
            strArgs[i] = string.format(str, currentArg)
        elseif type(currentArg) == "string" then
            strArgs[i] = currentArg
        else
            strArgs[i] = ""
        end
    end
    if type(formatString) == "number" then
        formatString = GetString(formatString)
    end
    return LocalizeString(formatString, unpack(strArgs))
end
do
    -- zo_strformat elegantly handles the case where we pass in a param as the "formatter" (e.g.: collectible descriptions).
    -- However, in order to avoid having each string generate its own cache table, the ZO_CachedStrFormat function need to be explicitely told "I have no formatter"
    -- so it can add all of them to one table. This cuts down on overhead, with the downside that it loses slight parity with zo_strformat.
    -- However, the fact that we do this whole no param thing at all is exploiting a quirk in the grammar to get around a bug in the grammar anyway so
    -- it's a relatively rare scenario
    ZO_CACHED_STR_FORMAT_NO_FORMATTER = ""
    local g_cachedStringsByFormatter = 
    {
        [ZO_CACHED_STR_FORMAT_NO_FORMATTER] = {} --Used for strings that need to run through grammar without a formatter
    }
    function ZO_CachedStrFormat(formatter, ...)
        formatter = formatter or ZO_CACHED_STR_FORMAT_NO_FORMATTER
        local formatterCache = g_cachedStringsByFormatter[formatter]
        if not formatterCache then
            formatterCache = {}
            g_cachedStringsByFormatter[formatter] = formatterCache
        end
        
        local cachedString
        if formatter == ZO_CACHED_STR_FORMAT_NO_FORMATTER then
            --"No formatter" only works with 1 param
            local rawString = ...
            local hashKey = HashString(rawString)
            cachedString = formatterCache[hashKey]
            if not cachedString then
                cachedString = zo_strformat(rawString)
                formatterCache[hashKey] = cachedString
            end
        else
            local concatParams = table.concat({ ... })
            local hashKey = HashString(concatParams)
            cachedString = formatterCache[hashKey]
            if not cachedString then
                cachedString = zo_strformat(formatter, ...)
                formatterCache[hashKey] = cachedString
            end
        end
        return cachedString
    end
end
function zo_strtrim(str)
    -- The extra parentheses are used to discard the additional return value (which is the total number of matches)
    return(zo_strgsub(str, "^%s*(.-)%s*$", "%1"))
end
do
    local DIGIT_GROUP_REPLACER = GetString(SI_DIGIT_GROUP_SEPARATOR)
    local DIGIT_GROUP_REPLACER_THRESHOLD = zo_pow(10, GetDigitGroupingSize())
    local DIGIT_GROUP_DECIMAL_REPLACER = GetString(SI_DIGIT_GROUP_DECIMAL_SEPARATOR)
    
    function ZO_CommaDelimitNumber(amount)
        if amount < DIGIT_GROUP_REPLACER_THRESHOLD then
            return tostring(amount)
        end
        return FormatIntegerWithDigitGrouping(amount, DIGIT_GROUP_REPLACER, GetDigitGroupingSize())
    end
    function ZO_LocalizeDecimalNumber(amount)
        local amountString = tostring(amount)
        if "." ~= DIGIT_GROUP_DECIMAL_REPLACER then
            amountString = zo_strgsub(amountString, "%.", DIGIT_GROUP_DECIMAL_REPLACER)
        end
        if amount >= DIGIT_GROUP_REPLACER_THRESHOLD then
            -- We have a number like 10000.5, so localize the non-decimal digit group separators (e.g., 10000 becomes 10,000)
            local decimalSeparatorIndex = zo_strfind(amountString, "%"..DIGIT_GROUP_DECIMAL_REPLACER) -- Look for the literal separator
            local decimalPartString = decimalSeparatorIndex and zo_strsub(amountString, decimalSeparatorIndex) or ""
            local wholePartString = zo_strsub(amountString, 1, decimalSeparatorIndex and decimalSeparatorIndex - 1)
            amountString = ZO_CommaDelimitNumber(tonumber(wholePartString))..decimalPartString
        end
        return amountString
    end
end
function ZO_GenerateCommaSeparatedList(argumentTable)
    if argumentTable ~= nil and #argumentTable > 0 then
        local numArguments = #argumentTable
        -- start off the list with the first element in the array
        local listString = argumentTable[1]
        -- loop through the second through the second to last element adding commas in between
        -- if there are only two things in the array this loop will be skipped
        for i = 2, (numArguments - 1) do
            listString = listString .. GetString(SI_LIST_COMMA_SEPARATOR) .. argumentTable[i]
        end
        -- add the last element of the array to the list
        -- special behavior to add "and" for the last element
        if numArguments >= 2 then
            local finalSeparator = SI_LIST_COMMA_AND_SEPARATOR
            -- if there are only two it doesn't make sense to add ", and "
            if numArguments == 2 then
                finalSeparator = SI_LIST_AND_SEPARATOR
            end
            listString = listString .. GetString(finalSeparator) .. argumentTable[numArguments]
        end
        return listString
    else
        return ""
    end
end
function ZO_GenerateCommaSeparatedListWithoutAnd(argumentTable)
    if argumentTable ~= nil and #argumentTable > 0 then
        local numArguments = #argumentTable
        local listString = argumentTable[1]
        for i = 2, numArguments do
            listString = listString .. GetString(SI_LIST_COMMA_SEPARATOR) .. argumentTable[i]
        end
        return listString
    else
        return ""
    end
end