|
John@0
|
1 -- lists consist of three things
|
|
John@0
|
2 -- 1) a base state - agreed on by one or more list holders
|
|
John@0
|
3 -- 2) change sets - incremental list changes (can be rolled forwards or
|
|
John@0
|
4 -- backwards)
|
|
John@0
|
5 -- 3) working state - not saved because it can be so easily calculated
|
|
John@0
|
6 --
|
|
John@0
|
7 -- A separate user list is held - lists index into this
|
|
John@0
|
8
|
|
John@0
|
9
|
|
John@0
|
10 -- TODO: rename player
|
|
John@5
|
11 -- TODO: list trimming
|
|
John@0
|
12
|
|
John@4
|
13 -- notes on list storage:
|
|
John@7
|
14 -- Using names as keys as I do now is atrocious.
|
|
John@4
|
15 -- It prevents insertions (twss) to the middle of the list because then it acts
|
|
John@4
|
16 -- as a side effect onto all the others. ie ABCD -> AXBCD would be phrased as
|
|
John@4
|
17 -- "insert X and shift down B,C,D" which sucks. BCD haven't really been affected
|
|
John@4
|
18 -- (yet) because their relative positions to the others are still intact - ie
|
|
John@4
|
19 -- they are still below A right where they belong. But really X hasn't done
|
|
John@4
|
20 -- anything to affect their relative standing.
|
|
John@4
|
21 --
|
|
John@4
|
22 -- Ok so we can't use names.
|
|
John@4
|
23 --
|
|
John@4
|
24 -- We can't use monotonic integers either because it suffers the same problem.
|
|
John@4
|
25 -- Also consider, randoming in someone to a list of ABCD. Say they roll spot 2.
|
|
John@4
|
26 -- What if someone else runs a separate raid and also randoms someone into slot
|
|
John@4
|
27 -- 2? How do you handle that conflict? Difficult. Also, consider this:
|
|
John@4
|
28 -- List of ABCD on night 1.
|
|
John@4
|
29 -- Admin 1 on night 2 rolls in 30 new people. ABCD's indexes are shuffled to be
|
|
John@4
|
30 -- between 1-35.
|
|
John@4
|
31 -- Admin 2 on night 3 rolls in 5 new ones and people ABCD and PQRST now all have
|
|
John@4
|
32 -- indexes between 1-9.
|
|
John@4
|
33 -- When these two are resolved against one another, do the 1-9 peopole end up on
|
|
John@4
|
34 -- top of the list compared to those other 30?
|
|
John@4
|
35 --
|
|
John@4
|
36 -- Solution:
|
|
John@4
|
37 -- Need a huge random space with purposely left gaps to leave plenty of room for
|
|
John@4
|
38 -- conflicts.
|
|
John@4
|
39 -- So if ABCD had randomed on a space of say, 10,000 and then were sorted into
|
|
John@4
|
40 -- order, then the next 30 could roll into that same space and have a proper
|
|
John@4
|
41 -- ordering. Then the next 5, etc.
|
|
John@4
|
42 --
|
|
John@4
|
43 -- Handling conflicts:
|
|
John@4
|
44 --
|
|
John@0
|
45
|
|
John@8
|
46 -- todo: list-of-lists must not use int indices. those will lead to peril.
|
|
John@0
|
47 bsk.lists = {}
|
|
John@8
|
48 bsk.persons = {}
|
|
John@0
|
49
|
|
John@8
|
50 local raidList = {}
|
|
John@8
|
51 local reserveList = {}
|
|
John@8
|
52 local activeListKey = 1 -- temporary
|
|
John@8
|
53 local personsReverse = {}
|
|
John@0
|
54
|
|
John@0
|
55 local tinsert = table.insert
|
|
John@0
|
56 local sformat = string.format
|
|
John@0
|
57 local getn = table.getn
|
|
John@0
|
58
|
|
John@0
|
59 function bsk:tcopy(to, from)
|
|
John@0
|
60 for k,v in pairs(from) do
|
|
John@0
|
61 if(type(v)=="table") then
|
|
John@0
|
62 to[k] = {}
|
|
John@0
|
63 bsk:tcopy(to[k], v);
|
|
John@0
|
64 else
|
|
John@0
|
65 to[k] = v;
|
|
John@0
|
66 end
|
|
John@0
|
67 end
|
|
John@0
|
68 end
|
|
John@0
|
69 local shallowCopy = function(t)
|
|
John@0
|
70 local u = { }
|
|
John@0
|
71 for k, v in pairs(t) do u[k] = v end
|
|
John@0
|
72 return setmetatable(u, getmetatable(t))
|
|
John@0
|
73 end
|
|
John@0
|
74
|
|
John@1
|
75 -- Debugging {{{
|
|
John@1
|
76 function bsk:PrintLists()
|
|
John@1
|
77 bsk:PrintTable(bsk.lists)
|
|
John@1
|
78 end
|
|
John@1
|
79 function bsk:PrintChanges()
|
|
John@1
|
80 bsk:PrintTable(bsk.db.profile.changes)
|
|
John@1
|
81 end
|
|
John@8
|
82 function bsk:PrintPersons()
|
|
John@8
|
83 bsk:PrintTable(bsk.persons)
|
|
John@1
|
84 end
|
|
John@0
|
85 function bsk:PrintTable(table, depth)
|
|
John@0
|
86 depth = depth or ""
|
|
John@0
|
87 if not table then return end
|
|
John@0
|
88 for i,v in pairs(table) do
|
|
John@0
|
89 if( type(v) == "string" ) then
|
|
John@0
|
90 self:Print(depth .. i .. " - " .. v)
|
|
John@0
|
91 elseif( type(v) == "number" ) then
|
|
John@0
|
92 self:Print(depth .. i .. " - " .. tostring(v))
|
|
John@0
|
93 elseif( type(v) == "table" ) then
|
|
John@0
|
94 self:Print(depth .. i .." - ")
|
|
John@0
|
95 self:PrintTable(v,depth.." ")
|
|
John@0
|
96 elseif( type(v) == "boolean" ) then
|
|
John@0
|
97 self:Print(depth .. i .. " - " .. tostring(v))
|
|
John@0
|
98 else
|
|
John@0
|
99 self:Print(depth .. i .. " - not sure how to print type: " .. type(v) )
|
|
John@0
|
100 end
|
|
John@0
|
101 end
|
|
John@0
|
102 end
|
|
John@0
|
103
|
|
John@0
|
104 --}}}
|
|
John@0
|
105
|
|
John@5
|
106 function bsk:CreateWorkingStateFromChanges(changes)
|
|
John@8
|
107 local personsBase = self.db.profile.persons
|
|
John@0
|
108 local listBase = self.db.profile.listBase
|
|
John@0
|
109
|
|
John@0
|
110 -- copy the base to the working state
|
|
John@0
|
111 wipe(bsk.lists)
|
|
John@8
|
112 wipe(bsk.persons)
|
|
John@8
|
113 wipe(personsReverse)
|
|
John@8
|
114
|
|
John@0
|
115 bsk:tcopy(bsk.lists,listBase)
|
|
John@8
|
116 bsk:tcopy(bsk.persons,personsBase)
|
|
John@0
|
117
|
|
John@0
|
118 -- now just go through the changes list applying each
|
|
John@5
|
119 for i,v in ipairs(changes) do
|
|
John@0
|
120 bsk:ProcessChange(v)
|
|
John@0
|
121 end
|
|
John@0
|
122 end
|
|
John@0
|
123
|
|
John@0
|
124 function bsk:CreateChange(change)
|
|
John@0
|
125 -- sanity
|
|
John@0
|
126 assert(change)
|
|
John@0
|
127 assert(change.action)
|
|
John@0
|
128 assert(change.arg)
|
|
John@0
|
129
|
|
John@0
|
130 bsk:StartChange(change)
|
|
John@0
|
131 bsk:CommitChange(change)
|
|
John@0
|
132 end
|
|
John@0
|
133
|
|
John@0
|
134 function bsk:StartChange(change)
|
|
John@0
|
135 local changes = self.db.profile.changes
|
|
John@0
|
136 change.time = time()
|
|
John@0
|
137 local n = getn(changes)
|
|
John@0
|
138 if n > 0 then
|
|
John@0
|
139 if changes[n].time >= change.time then
|
|
John@0
|
140 change.time = changes[n].time + 1
|
|
John@0
|
141 end
|
|
John@0
|
142 end
|
|
John@0
|
143 end
|
|
John@0
|
144
|
|
John@0
|
145 function bsk:CommitChange(change)
|
|
John@0
|
146 local changes = self.db.profile.changes
|
|
John@0
|
147 tinsert(changes,change)
|
|
John@0
|
148 -- TODO: broadcast change
|
|
John@0
|
149 end
|
|
John@0
|
150
|
|
John@0
|
151
|
|
John@0
|
152 -- timestamp logic:
|
|
John@0
|
153 -- use time() for comparisons - local clients use date() to make it pretty. only
|
|
John@0
|
154 -- dowisde - we can't have a server timestamp. Which kind of sucks, but it turns
|
|
John@0
|
155 -- out you can change timezones when you enter an instance server, so you really
|
|
John@0
|
156 -- never know what time it is.
|
|
John@0
|
157 -- There's unfortunately no hard-and-proven method for determining the true time
|
|
John@0
|
158 -- difference between local time and server time. You can't just query the two
|
|
John@0
|
159 -- and compare them because your server timezone can change (!) if you go into
|
|
John@0
|
160 -- an instance server with a different timezone. This is apparently a big
|
|
John@0
|
161 -- problem on Oceanic realms.
|
|
John@0
|
162 --
|
|
John@0
|
163 -- Timestamp handling (brainstorming how to deal with drift):
|
|
John@0
|
164 -- (not an issue) if someone sends you time in the future, update your offset so you won't
|
|
John@0
|
165 -- send out events in the "past" to that person
|
|
John@0
|
166 -- (not an issue - using local UTC now) on change-zone-event: check if you've changed timezones - might need update
|
|
John@0
|
167 -- each time you add a change, check the tail of the change list; if this is
|
|
John@0
|
168 -- less than that, you have a problem. Print a message. if this is equal, then
|
|
John@0
|
169 -- that's ok, just bump it by 1 second. This could happen in the case of, say,
|
|
John@0
|
170 -- spam-clicking the undo button or adding names to the list. The recipients
|
|
John@0
|
171 -- should be ok with this since they'll follow the same algorithm. The only
|
|
John@0
|
172 -- real chance for a problem is if two people click within the 1 second window?
|
|
John@0
|
173 -- if someone sends you a past event,
|
|
John@0
|
174 -- it's ok if it's newer than anything in the changes list
|
|
John@0
|
175 -- otherwise ... causality has been violated.
|
|
John@0
|
176 -- Whenever an admin signon event happens, have the admins each perform a
|
|
John@0
|
177 -- timestamp check. Issue warnings for anyone with a clock that's more than
|
|
John@0
|
178 -- X seconds out of sync with the others. Seriously, why isn't NTP a standard
|
|
John@0
|
179 -- setting on all operating systems ...
|
|
John@0
|
180
|
|
John@0
|
181 function bsk:ProcessChange(change)
|
|
John@8
|
182 if change.action == "AddPerson" then
|
|
John@8
|
183 bsk:DoAddPerson(change)
|
|
John@0
|
184 elseif change.action == "CreateList" then
|
|
John@0
|
185 bsk:DoCreateList(change)
|
|
John@8
|
186 elseif change.action == "AddPersonToList" then
|
|
John@8
|
187 bsk:DoAddPersonToList(change)
|
|
John@8
|
188 elseif change.action == "SuicidePerson" then
|
|
John@8
|
189 bsk:DoSuicidePerson(change)
|
|
John@0
|
190 else
|
|
John@0
|
191 bsk:Print("Unknown message encountered")
|
|
John@0
|
192 bsk:PrintTable(change)
|
|
John@0
|
193 assert(false)
|
|
John@0
|
194 end
|
|
John@0
|
195 end
|
|
John@0
|
196
|
|
John@1
|
197 -- Action and DoAction defs {{{
|
|
John@0
|
198 --
|
|
John@0
|
199 -- The actual actions for changes start here
|
|
John@0
|
200 --
|
|
John@0
|
201 -- Each action occurs as a pair of functions. The bsk:Action() function is from
|
|
John@0
|
202 -- a list admin's point of view. Each will check for admin status, then create a
|
|
John@0
|
203 -- change bundle, call the handler for that change (ie the DoAction func), and
|
|
John@0
|
204 -- then record/transmist the bundle. These are simple and repetitive functions.
|
|
John@0
|
205 --
|
|
John@0
|
206 -- The bsk:DoAction() function is tasked with executing the bundle and is what
|
|
John@0
|
207 -- non-admins and admins alike will call to transform their working state via a
|
|
John@0
|
208 -- change packet. Each Do() function will accept *only* a change packet, and
|
|
John@0
|
209 -- it's assumed that the change has been vetted elsewhere. These are very blunt
|
|
John@0
|
210 -- routines.
|
|
John@0
|
211 --
|
|
John@0
|
212 -- Note that "undo" has no special voodoo to it. It's basically a change that
|
|
John@0
|
213 -- reverses the prior change on the stack.
|
|
John@0
|
214
|
|
John@8
|
215 -- persons list
|
|
John@8
|
216 function bsk:DoAddPerson(change)
|
|
John@0
|
217 assert(change)
|
|
John@8
|
218 assert(change.arg.id)
|
|
John@0
|
219 local arg = change.arg
|
|
John@0
|
220 -- require admin
|
|
John@8
|
221 local persons = bsk.persons
|
|
John@0
|
222 local name = arg.name
|
|
John@8
|
223 local id = arg.id
|
|
John@8
|
224 assert(persons[id]==nil)
|
|
John@8
|
225 persons[id] = {main=name}
|
|
John@8
|
226 persons.time=change.time
|
|
John@8
|
227 personsReverse[name] = id
|
|
John@0
|
228 return true
|
|
John@0
|
229 end
|
|
John@0
|
230
|
|
John@8
|
231 function bsk:AddPerson(name)
|
|
John@8
|
232 local persons = bsk.persons
|
|
John@0
|
233 local guid = UnitGUID(name)
|
|
John@0
|
234 -- TODO: check guid to be sure it's a player
|
|
John@0
|
235 if not guid then
|
|
John@0
|
236 self:Print(sformat("Could not add player %s - they must be in range or group",name))
|
|
John@0
|
237 return
|
|
John@0
|
238 end
|
|
John@8
|
239 local id = string.sub(guid,6) -- skip at least 0x0580 ...
|
|
John@8
|
240 id = id:gsub("^0*(.*)","%1") -- nom all leading zeroes remaining
|
|
John@8
|
241
|
|
John@8
|
242 if persons[id] and persons[id] ~= name then
|
|
John@8
|
243 self:Print(sformat("Namechange detected for %s - new is %s, please rename the existing entry", persons[id], name))
|
|
John@0
|
244 return
|
|
John@0
|
245 end
|
|
John@8
|
246 if persons[id] ~= nil then
|
|
John@8
|
247 self:Print(sformat("%s is already in the persons list; disregarding", name))
|
|
John@0
|
248 return
|
|
John@0
|
249 end
|
|
John@8
|
250 local change = {action="AddPerson",arg={name=name,id=id}}
|
|
John@8
|
251 if bsk:DoAddPerson(change) then
|
|
John@0
|
252 bsk:CreateChange(change)
|
|
John@0
|
253 end
|
|
John@0
|
254 end
|
|
John@0
|
255
|
|
John@0
|
256 function bsk:DoCreateList(change)
|
|
John@0
|
257 -- TODO: this segment will probably be useful as bsk:SearchForListByName
|
|
John@0
|
258 local lists = bsk.lists
|
|
John@0
|
259 for i,v in pairs(lists) do
|
|
John@0
|
260 if v.name == change.arg.name then
|
|
John@0
|
261 self:Print(sformat("List %s already exists",v.name))
|
|
John@0
|
262 return false
|
|
John@0
|
263 end
|
|
John@0
|
264 end
|
|
John@0
|
265 tinsert(lists,{name=change.arg.name,time=change.time})
|
|
John@0
|
266 return true
|
|
John@0
|
267 end
|
|
John@0
|
268
|
|
John@0
|
269 function bsk:CreateList(name)
|
|
John@0
|
270 -- require admin
|
|
John@0
|
271 local change={action="CreateList",arg={name=name}}
|
|
John@0
|
272 bsk:StartChange(change)
|
|
John@0
|
273 self:Print("Creating ... " .. name)
|
|
John@0
|
274 if bsk:DoCreateList(change) then
|
|
John@0
|
275 bsk:CommitChange(change)
|
|
John@0
|
276 end
|
|
John@0
|
277 end
|
|
John@0
|
278
|
|
John@8
|
279 function bsk:DoAddPersonToList(change)
|
|
John@0
|
280 local listIndex = change.arg.listIndex
|
|
John@0
|
281 local slist = change.arg.slist
|
|
John@0
|
282 local list = bsk.lists[listIndex]
|
|
John@0
|
283
|
|
John@0
|
284 if #slist == 1 then -- end of list insertion - just one person
|
|
John@0
|
285 tinsert(list,slist[1])
|
|
John@0
|
286 list.time = change.time
|
|
John@0
|
287 else
|
|
John@0
|
288 self:Print("Adding to middle of list is not yet supported")
|
|
John@0
|
289 return false
|
|
John@0
|
290 end
|
|
John@0
|
291 return true
|
|
John@0
|
292 end
|
|
John@0
|
293
|
|
John@8
|
294 function bsk:AddPersonToList(name,list)
|
|
John@0
|
295 -- require admin
|
|
John@0
|
296 local listIndex = bsk:GetListIndex(list)
|
|
John@8
|
297 local id = personsReverse[name]
|
|
John@8
|
298 local slist = {id} -- TODO: support adding to elsewhere besides the end
|
|
John@8
|
299 local change = {action="AddPersonToList",arg={id=id,listIndex=listIndex,slist=slist}}
|
|
John@0
|
300 bsk:StartChange(change)
|
|
John@8
|
301 if bsk:DoAddPersonToList(change) then
|
|
John@0
|
302 bsk:CommitChange(change)
|
|
John@0
|
303 end
|
|
John@0
|
304 end
|
|
John@0
|
305
|
|
John@8
|
306 function bsk:DoRemovePerson(change)
|
|
John@0
|
307
|
|
John@0
|
308 -- return true
|
|
John@0
|
309 end
|
|
John@0
|
310
|
|
John@8
|
311 function bsk:RemovePerson(name)
|
|
John@8
|
312 -- from both persons and lists
|
|
John@0
|
313 end
|
|
John@0
|
314
|
|
John@8
|
315 function bsk:DoSuicidePerson(change)
|
|
John@0
|
316 local listIndex = change.arg.listIndex
|
|
John@0
|
317 local list = bsk.lists[listIndex]
|
|
John@0
|
318 local slist = shallowCopy(change.arg.list)
|
|
John@0
|
319 -- the goal here is to rotate the suicide list by 1
|
|
John@0
|
320 -- then we can just mash it on top of the intersection between the original
|
|
John@0
|
321 -- list and the working copy
|
|
John@0
|
322 local stemp = shallowCopy(change.arg.list)
|
|
John@0
|
323 local temp = table.remove(stemp,1) -- pop
|
|
John@0
|
324 tinsert(stemp,temp) -- push_back
|
|
John@0
|
325 --bsk:Print(sformat("Before suicide of %s on list %s",slist[1],list.name))
|
|
John@0
|
326 --bsk:PrintTable(list)
|
|
John@0
|
327 for i = 1, #list do
|
|
John@0
|
328 if list[i] == slist[1] then
|
|
John@0
|
329 table.remove(slist,1)
|
|
John@0
|
330 list[i] = stemp[1]
|
|
John@0
|
331 table.remove(stemp,1)
|
|
John@0
|
332 end
|
|
John@0
|
333 end
|
|
John@0
|
334 list.time=change.time
|
|
John@0
|
335 --bsk:Print("After")
|
|
John@0
|
336 --bsk:PrintTable(list)
|
|
John@0
|
337 return true
|
|
John@0
|
338 end
|
|
John@0
|
339
|
|
John@8
|
340 function bsk:SuicidePerson(name,list)
|
|
John@0
|
341 -- require admin
|
|
John@0
|
342 bsk:PopulateRaidList()
|
|
John@0
|
343 local listIndex = bsk:GetListIndex(list)
|
|
John@1
|
344 local slist=bsk:GetSuicideList(name,bsk.lists[listIndex])
|
|
John@8
|
345 local change = {action="SuicidePerson",arg={names=names,list=slist,listIndex=listIndex}}
|
|
John@0
|
346 bsk:StartChange(change)
|
|
John@8
|
347 if bsk:DoSuicidePerson(change) then
|
|
John@0
|
348 bsk:CommitChange(change)
|
|
John@0
|
349 end
|
|
John@0
|
350 end
|
|
John@5
|
351
|
|
John@5
|
352 function bsk:TrimLists(time)
|
|
John@5
|
353 if not bsk:CheckListCausality() then
|
|
John@5
|
354 self:Print("Unable to trim lists due to violated causality")
|
|
John@5
|
355
|
|
John@5
|
356 return false
|
|
John@5
|
357 end
|
|
John@5
|
358
|
|
John@5
|
359 if type(time) ~= "number" then
|
|
John@5
|
360 time = tonumber(time)
|
|
John@5
|
361 end
|
|
John@5
|
362
|
|
John@5
|
363 -- bisect the changes list by "time"
|
|
John@5
|
364 local before = {}
|
|
John@5
|
365 for i,v in ipairs(self.db.profile.changes) do
|
|
John@5
|
366 if v.time <= time then
|
|
John@5
|
367 tinsert(before,v)
|
|
John@5
|
368 else
|
|
John@5
|
369 break
|
|
John@5
|
370 end
|
|
John@5
|
371 end
|
|
John@5
|
372
|
|
John@5
|
373 -- apply first half
|
|
John@5
|
374 bsk:CreateWorkingStateFromChanges(before)
|
|
John@5
|
375
|
|
John@5
|
376 -- save this state permanently; trim the changes permanently
|
|
John@8
|
377 bsk:tcopy(bsk.db.profile.persons,bsk.persons)
|
|
John@5
|
378 bsk:tcopy(bsk.db.profile.listBase,bsk.lists)
|
|
John@8
|
379 while bsk.db.profile.changes ~= nil and bsk.db.profile.changes[1] ~= nil and bsk.db.profile.changes[1].time <= time do
|
|
John@5
|
380 table.remove(bsk.db.profile.changes,1)
|
|
John@5
|
381 end
|
|
John@5
|
382
|
|
John@5
|
383 -- using the trimmed list and the new bases, recreate the working state
|
|
John@5
|
384 bsk:CreateWorkingStateFromChanges(bsk.db.profile.changes)
|
|
John@5
|
385 end
|
|
John@5
|
386
|
|
John@1
|
387 --}}}
|
|
John@1
|
388 -- Higher order actions (ie calls other Doers){{{
|
|
John@8
|
389 function bsk:AddMissingPersons()
|
|
John@1
|
390 bsk:PopulateRaidList()
|
|
John@1
|
391 local t = {}
|
|
John@8
|
392 for _,v in pairs(bsk.persons) do
|
|
John@8
|
393 t[v.main] = true
|
|
John@8
|
394 -- TODO: also add alts here
|
|
John@1
|
395 end
|
|
John@8
|
396 for i,_ in pairs(raidList) do
|
|
John@2
|
397 if t[i] == nil then
|
|
John@8
|
398 bsk:Print(sformat("Person %s is missing from the persons list - adding",i))
|
|
John@8
|
399 bsk:AddPerson(i)
|
|
John@1
|
400 end
|
|
John@1
|
401 end
|
|
John@1
|
402 -- TODO: batch into a single op - no need to spam 25 messages in a row
|
|
John@1
|
403 end
|
|
John@3
|
404 function bsk:PopulateListRandom(index)
|
|
John@3
|
405 -- difference (raid+reserve)^list, then random shuffle that, then add
|
|
John@3
|
406 bsk:PopulateRaidList()
|
|
John@3
|
407 local list = bsk.lists[index]
|
|
John@3
|
408
|
|
John@3
|
409 local t = {}
|
|
John@3
|
410 --for i = 1,#list do
|
|
John@8
|
411 -- if not (raidList(list[i]) or reserveList(list[i])) then
|
|
John@3
|
412 -- tinsert(t,)
|
|
John@3
|
413 -- end
|
|
John@3
|
414 --end
|
|
John@3
|
415 end
|
|
John@1
|
416 --}}}
|
|
John@1
|
417
|
|
John@1
|
418 -- "Soft" actions- ie things that cause nonpermanent state {{{
|
|
John@1
|
419
|
|
John@1
|
420 -- reserves
|
|
John@1
|
421 function bsk:AddReserve(name)
|
|
John@8
|
422 reserveList[name]=true
|
|
John@1
|
423 -- TODO: communicate to others. don't store this in any way.
|
|
John@1
|
424 end
|
|
John@1
|
425
|
|
John@1
|
426 function bsk:RemoveReserve(name)
|
|
John@8
|
427 reserveList[name]=false
|
|
John@1
|
428 -- TODO: communicate to others. don't store this in any way.
|
|
John@1
|
429 end
|
|
John@1
|
430
|
|
John@1
|
431
|
|
John@1
|
432 --function bsk:GetActiveList()
|
|
John@1
|
433 -- return bsk.lists[1] -- todo!
|
|
John@1
|
434 --end
|
|
John@1
|
435
|
|
John@1
|
436 --}}}
|
|
John@0
|
437
|
|
John@0
|
438 -- The following code is from Xinhuan (wowace forum member)
|
|
John@0
|
439 -- Pre-create the unitID strings we will use
|
|
John@0
|
440 local pID = {}
|
|
John@0
|
441 local rID = {}
|
|
John@0
|
442 for i = 1, 4 do
|
|
John@0
|
443 pID[i] = format("party%d", i)
|
|
John@0
|
444 end
|
|
John@0
|
445 for i = 1, 40 do
|
|
John@0
|
446 rID[i] = format("raid%d", i)
|
|
John@0
|
447 end
|
|
John@0
|
448 function bsk:PopulateRaidList()
|
|
John@0
|
449 local inParty = GetNumPartyMembers()
|
|
John@0
|
450 local inRaid = GetNumRaidMembers()
|
|
John@0
|
451
|
|
John@8
|
452 wipe(raidList)
|
|
John@0
|
453 if inRaid > 0 then
|
|
John@0
|
454 for i = 1, inRaid do
|
|
John@8
|
455 raidList[UnitName(rID[i])]=true
|
|
John@0
|
456 end
|
|
John@0
|
457 elseif inParty > 0 then
|
|
John@0
|
458 for i = 1, inParty do
|
|
John@8
|
459 raidList[UnitName(pID[i])]=true
|
|
John@0
|
460 end
|
|
John@0
|
461 -- Now add yourself as the last party member
|
|
John@8
|
462 raidList[UnitName("player")]=true
|
|
John@0
|
463 else
|
|
John@0
|
464 -- You're alone
|
|
John@8
|
465 raidList[UnitName("player")]=true
|
|
John@0
|
466 end
|
|
John@0
|
467 end
|
|
John@0
|
468
|
|
John@0
|
469 -- undo rules!
|
|
John@0
|
470 -- only the most recent event can be undone
|
|
John@0
|
471 -- ^^^ on a given list?
|
|
John@0
|
472 -- algorithm is easy, given "Suicide A B C"
|
|
John@0
|
473 -- just find A,B,C in the list and replace in order from the s message
|
|
John@0
|
474 -- while undo is allowed *per-list*, certain events in the stream will
|
|
John@0
|
475 -- prevent proper undo, such as add/delete player or add/delete list
|
|
John@0
|
476
|
|
John@0
|
477
|
|
John@1
|
478 function bsk:GetSuicideList(name,list)
|
|
John@1
|
479 --self:Print("Calculating changeset for "..name.." from list -")
|
|
John@1
|
480 --self:PrintTable(list)
|
|
John@1
|
481 local t = {}
|
|
John@1
|
482 local ret = {}
|
|
John@1
|
483 local pushing = false
|
|
John@1
|
484 for i = 1, #list do
|
|
John@1
|
485 if list[i] == name then
|
|
John@1
|
486 pushing = true
|
|
John@1
|
487 end
|
|
John@8
|
488 if pushing and (raidList[list[i]] or reserveList[list[i]]) then
|
|
John@1
|
489 tinsert(ret,list[i])
|
|
John@1
|
490 end
|
|
John@1
|
491 end
|
|
John@1
|
492 return ret
|
|
John@0
|
493 end
|
|
John@0
|
494
|
|
John@5
|
495 -- returns true if the events in the list are in time order
|
|
John@5
|
496 function bsk:CheckListCausality()
|
|
John@5
|
497 local t = nil
|
|
John@5
|
498 for i,v in ipairs(bsk.db.profile.changes) do
|
|
John@5
|
499 if t ~= nil then
|
|
John@5
|
500 if v.time <= t then
|
|
John@5
|
501 return false
|
|
John@5
|
502 end
|
|
John@5
|
503 end
|
|
John@5
|
504 t = v.time
|
|
John@5
|
505 end
|
|
John@5
|
506 return true
|
|
John@5
|
507 end
|
|
John@0
|
508
|
|
John@0
|
509 -- Support functions
|
|
John@0
|
510
|
|
John@0
|
511 function bsk:GetListIndex(name)
|
|
John@0
|
512 for i,v in pairs(bsk.lists) do
|
|
John@0
|
513 if v.name == name then
|
|
John@0
|
514 return i
|
|
John@0
|
515 end
|
|
John@0
|
516 end
|
|
John@0
|
517 assert(false)
|
|
John@0
|
518 end
|
|
John@1
|
519
|
|
John@3
|
520 local shuffleArray = function(array)
|
|
John@3
|
521 local arrayCount = #array
|
|
John@3
|
522 for i = arrayCount, 2, -1 do
|
|
John@3
|
523 local j = math.random(1, i)
|
|
John@3
|
524 array[i], array[j] = array[j], array[i]
|
|
John@3
|
525 end
|
|
John@3
|
526 return array
|
|
John@3
|
527 end
|
|
John@3
|
528
|
