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@5
|
10 -- TODO: list trimming
|
John@24
|
11 -- TODO: collapse slists into delimited strings for space (premature optimization?)
|
John@18
|
12 -- TODO: organize working state data a little more carefully - hard to keep
|
John@18
|
13 -- track of all the arrays that are floating out there
|
John@18
|
14 -- TODO: (meta) remove player from all lists
|
John@25
|
15 -- TODO: remove person (trivial unless implementing a history viewer or
|
John@25
|
16 -- something)
|
John@18
|
17
|
John@17
|
18 -- holy crap long notes {{{
|
John@4
|
19 -- notes on list storage:
|
John@7
|
20 -- Using names as keys as I do now is atrocious.
|
John@4
|
21 -- It prevents insertions (twss) to the middle of the list because then it acts
|
John@4
|
22 -- as a side effect onto all the others. ie ABCD -> AXBCD would be phrased as
|
John@4
|
23 -- "insert X and shift down B,C,D" which sucks. BCD haven't really been affected
|
John@4
|
24 -- (yet) because their relative positions to the others are still intact - ie
|
John@4
|
25 -- they are still below A right where they belong. But really X hasn't done
|
John@4
|
26 -- anything to affect their relative standing.
|
John@4
|
27 --
|
John@4
|
28 -- Ok so we can't use names.
|
John@4
|
29 --
|
John@4
|
30 -- We can't use monotonic integers either because it suffers the same problem.
|
John@4
|
31 -- Also consider, randoming in someone to a list of ABCD. Say they roll spot 2.
|
John@4
|
32 -- What if someone else runs a separate raid and also randoms someone into slot
|
John@4
|
33 -- 2? How do you handle that conflict? Difficult. Also, consider this:
|
John@4
|
34 -- List of ABCD on night 1.
|
John@4
|
35 -- Admin 1 on night 2 rolls in 30 new people. ABCD's indexes are shuffled to be
|
John@4
|
36 -- between 1-35.
|
John@4
|
37 -- Admin 2 on night 3 rolls in 5 new ones and people ABCD and PQRST now all have
|
John@4
|
38 -- indexes between 1-9.
|
John@4
|
39 -- When these two are resolved against one another, do the 1-9 peopole end up on
|
John@4
|
40 -- top of the list compared to those other 30?
|
John@4
|
41 --
|
John@4
|
42 -- Solution:
|
John@4
|
43 -- Need a huge random space with purposely left gaps to leave plenty of room for
|
John@4
|
44 -- conflicts.
|
John@4
|
45 -- So if ABCD had randomed on a space of say, 10,000 and then were sorted into
|
John@4
|
46 -- order, then the next 30 could roll into that same space and have a proper
|
John@4
|
47 -- ordering. Then the next 5, etc.
|
John@4
|
48 --
|
John@4
|
49 -- Handling conflicts:
|
John@4
|
50 --
|
John@9
|
51 -- Executive decision: random on a range of [0,1], ie math.random
|
John@9
|
52 -- then on an add-to-end event just do last + .1
|
John@9
|
53 -- disallow random after any add-to-end event occurs
|
John@9
|
54 -- because the list either elongates beyond 1 OR becomes
|
John@9
|
55 -- ridiculously bottom heavy, thus meaning that randoms
|
John@9
|
56 -- don't get an even distibution from then on (in fact
|
John@9
|
57 -- they'll end up getting top favor)
|
John@9
|
58 -- * if a stream contains a random-add after an add-to-end
|
John@9
|
59 -- it is declared invalid. tough tits. it's just not a fair
|
John@9
|
60 -- distribution at that point.
|
John@10
|
61 -- * actually, fuck it. I'll give them an unlock command and
|
John@10
|
62 -- let them screw over their lists :)
|
John@17
|
63 --}}}
|
John@18
|
64
|
John@17
|
65 -- there are some dep chains here. for instance, to have a raidIdP value, a
|
John@17
|
66 -- person must have a bsk.persons value which leads to a personName2id which
|
John@17
|
67 -- leads to a raidIdP
|
John@0
|
68
|
John@0
|
69 bsk.lists = {}
|
John@8
|
70 bsk.persons = {}
|
John@0
|
71
|
John@16
|
72 local raidNameP = {} -- "name" is present in raid
|
John@16
|
73 local raidIdP = {} -- "id" is present in raid
|
John@16
|
74 local reserveIdP = {} -- "reserve id present"
|
John@8
|
75 local activeListKey = 1 -- temporary
|
John@16
|
76 local personName2id = {} -- given "name" get that person's id
|
John@0
|
77
|
John@0
|
78 local tinsert = table.insert
|
John@0
|
79 local sformat = string.format
|
John@0
|
80 local getn = table.getn
|
John@0
|
81
|
John@17
|
82 function bsk:SelfDestruct()
|
John@17
|
83 bsk.lists = {}
|
John@17
|
84 bsk.persons = {}
|
John@17
|
85 bsk.db.profile.persons = {}
|
John@17
|
86 bsk.db.profile.changes = {}
|
John@17
|
87 bsk.db.profile.listBase = {}
|
John@17
|
88 raidNameP = {}
|
John@17
|
89 raidIdP = {}
|
John@17
|
90 reserveIdP = {}
|
John@17
|
91 personName2id = {}
|
John@17
|
92 end
|
John@0
|
93 function bsk:tcopy(to, from)
|
John@0
|
94 for k,v in pairs(from) do
|
John@0
|
95 if(type(v)=="table") then
|
John@0
|
96 to[k] = {}
|
John@0
|
97 bsk:tcopy(to[k], v);
|
John@0
|
98 else
|
John@0
|
99 to[k] = v;
|
John@0
|
100 end
|
John@0
|
101 end
|
John@0
|
102 end
|
John@0
|
103 local shallowCopy = function(t)
|
John@0
|
104 local u = { }
|
John@0
|
105 for k, v in pairs(t) do u[k] = v end
|
John@0
|
106 return setmetatable(u, getmetatable(t))
|
John@0
|
107 end
|
John@0
|
108
|
John@1
|
109 -- Debugging {{{
|
John@9
|
110 function bsk:PrettyPrintList(listIndex)
|
John@9
|
111 local list = bsk.lists[listIndex]
|
John@19
|
112 bsk:Print("List: " .. list.name .. " (" .. listIndex .. ") - last modified " .. date("%m/%d/%y %H:%M:%S", list.time) .. " (",list.time,")" )
|
John@9
|
113 for i = 1,#list do
|
John@12
|
114 bsk:Print(" " .. i .. " - " .. bsk.persons[list[i].id].main)
|
John@9
|
115 end
|
John@9
|
116 end
|
John@9
|
117 function bsk:PrettyPrintLists()
|
John@9
|
118 for i,_ in pairs(bsk.lists) do
|
John@9
|
119 bsk:PrettyPrintList(i)
|
John@9
|
120 end
|
John@9
|
121 end
|
John@1
|
122 function bsk:PrintLists()
|
John@1
|
123 bsk:PrintTable(bsk.lists)
|
John@1
|
124 end
|
John@1
|
125 function bsk:PrintChanges()
|
John@1
|
126 bsk:PrintTable(bsk.db.profile.changes)
|
John@1
|
127 end
|
John@8
|
128 function bsk:PrintPersons()
|
John@8
|
129 bsk:PrintTable(bsk.persons)
|
John@1
|
130 end
|
John@0
|
131 function bsk:PrintTable(table, depth)
|
John@0
|
132 depth = depth or ""
|
John@0
|
133 if not table then return end
|
John@0
|
134 for i,v in pairs(table) do
|
John@0
|
135 if( type(v) == "string" ) then
|
John@0
|
136 self:Print(depth .. i .. " - " .. v)
|
John@0
|
137 elseif( type(v) == "number" ) then
|
John@0
|
138 self:Print(depth .. i .. " - " .. tostring(v))
|
John@0
|
139 elseif( type(v) == "table" ) then
|
John@0
|
140 self:Print(depth .. i .." - ")
|
John@0
|
141 self:PrintTable(v,depth.." ")
|
John@0
|
142 elseif( type(v) == "boolean" ) then
|
John@0
|
143 self:Print(depth .. i .. " - " .. tostring(v))
|
John@0
|
144 else
|
John@0
|
145 self:Print(depth .. i .. " - not sure how to print type: " .. type(v) )
|
John@0
|
146 end
|
John@0
|
147 end
|
John@0
|
148 end
|
John@0
|
149
|
John@17
|
150 function bsk:PrintRaidAndReserve()
|
John@17
|
151 bsk:Print("RaidNameP")
|
John@17
|
152 bsk:PrintTable(raidNameP)
|
John@17
|
153 bsk:Print("RaidIdP")
|
John@17
|
154 bsk:PrintTable(raidIdP)
|
John@17
|
155 bsk:Print("ReserveP")
|
John@17
|
156 bsk:PrintTable(reserveIdP)
|
John@17
|
157 bsk:Print("personName2id")
|
John@17
|
158 bsk:PrintTable(personName2id)
|
John@17
|
159 end
|
John@0
|
160 --}}}
|
John@0
|
161
|
John@9
|
162 function bsk:UpdatePersonsReverse()
|
John@9
|
163 for i,v in pairs(bsk.persons) do
|
John@9
|
164 if i ~= "time" then
|
John@16
|
165 personName2id[v.main] = i
|
John@9
|
166 end
|
John@9
|
167 end
|
John@9
|
168 end
|
John@9
|
169
|
John@16
|
170 -- Change processing {{{
|
John@5
|
171 function bsk:CreateWorkingStateFromChanges(changes)
|
John@8
|
172 local personsBase = self.db.profile.persons
|
John@0
|
173 local listBase = self.db.profile.listBase
|
John@0
|
174
|
John@0
|
175 -- copy the base to the working state
|
John@0
|
176 wipe(bsk.lists)
|
John@8
|
177 wipe(bsk.persons)
|
John@16
|
178 wipe(personName2id)
|
John@8
|
179
|
John@0
|
180 bsk:tcopy(bsk.lists,listBase)
|
John@8
|
181 bsk:tcopy(bsk.persons,personsBase)
|
John@0
|
182
|
John@0
|
183 -- now just go through the changes list applying each
|
John@5
|
184 for i,v in ipairs(changes) do
|
John@0
|
185 bsk:ProcessChange(v)
|
John@0
|
186 end
|
John@9
|
187
|
John@9
|
188 -- update the persons reverse list
|
John@9
|
189 bsk:UpdatePersonsReverse()
|
John@0
|
190 end
|
John@0
|
191
|
John@0
|
192 function bsk:CreateChange(change)
|
John@0
|
193 -- sanity
|
John@0
|
194 assert(change)
|
John@0
|
195 assert(change.action)
|
John@0
|
196 assert(change.arg)
|
John@0
|
197
|
John@0
|
198 bsk:StartChange(change)
|
John@0
|
199 bsk:CommitChange(change)
|
John@0
|
200 end
|
John@0
|
201
|
John@0
|
202 function bsk:StartChange(change)
|
John@0
|
203 local changes = self.db.profile.changes
|
John@0
|
204 change.time = time()
|
John@0
|
205 local n = getn(changes)
|
John@0
|
206 if n > 0 then
|
John@0
|
207 if changes[n].time >= change.time then
|
John@0
|
208 change.time = changes[n].time + 1
|
John@0
|
209 end
|
John@0
|
210 end
|
John@0
|
211 end
|
John@0
|
212
|
John@0
|
213 function bsk:CommitChange(change)
|
John@0
|
214 local changes = self.db.profile.changes
|
John@0
|
215 tinsert(changes,change)
|
John@0
|
216 -- TODO: broadcast change
|
John@0
|
217 end
|
John@0
|
218
|
John@16
|
219 function bsk:ProcessChange(change)
|
John@16
|
220 if change.action == "AddPerson" then
|
John@16
|
221 bsk:DoAddPerson(change)
|
John@20
|
222 elseif change.action == "RenameList" then
|
John@20
|
223 bsk:DoRenameList(change)
|
John@16
|
224 elseif change.action == "CreateList" then
|
John@16
|
225 bsk:DoCreateList(change)
|
John@21
|
226 elseif change.action == "DeleteList" then
|
John@21
|
227 bsk:DoDeleteList(change)
|
John@16
|
228 elseif change.action == "AddToListEnd" then
|
John@16
|
229 bsk:DoAddPersonToListEnd(change)
|
John@16
|
230 elseif change.action == "AddToListRand" then
|
John@16
|
231 bsk:DoAddPersonToListRandom(change)
|
John@22
|
232 elseif change.action == "RemovePersonFromList" then
|
John@22
|
233 bsk:DoRemovePersonFromList(change)
|
John@16
|
234 elseif change.action == "SuicidePerson" then
|
John@16
|
235 bsk:DoSuicidePerson(change)
|
John@16
|
236 else
|
John@16
|
237 bsk:Print("Unknown message encountered")
|
John@16
|
238 bsk:PrintTable(change)
|
John@16
|
239 assert(false)
|
John@16
|
240 end
|
John@16
|
241 end
|
John@16
|
242
|
John@16
|
243 --}}}
|
John@0
|
244
|
John@0
|
245 -- timestamp logic:
|
John@0
|
246 -- use time() for comparisons - local clients use date() to make it pretty. only
|
John@0
|
247 -- dowisde - we can't have a server timestamp. Which kind of sucks, but it turns
|
John@0
|
248 -- out you can change timezones when you enter an instance server, so you really
|
John@0
|
249 -- never know what time it is.
|
John@0
|
250 -- There's unfortunately no hard-and-proven method for determining the true time
|
John@0
|
251 -- difference between local time and server time. You can't just query the two
|
John@0
|
252 -- and compare them because your server timezone can change (!) if you go into
|
John@0
|
253 -- an instance server with a different timezone. This is apparently a big
|
John@0
|
254 -- problem on Oceanic realms.
|
John@0
|
255 --
|
John@0
|
256 -- Timestamp handling (brainstorming how to deal with drift):
|
John@0
|
257 -- (not an issue) if someone sends you time in the future, update your offset so you won't
|
John@0
|
258 -- send out events in the "past" to that person
|
John@0
|
259 -- (not an issue - using local UTC now) on change-zone-event: check if you've changed timezones - might need update
|
John@0
|
260 -- each time you add a change, check the tail of the change list; if this is
|
John@0
|
261 -- less than that, you have a problem. Print a message. if this is equal, then
|
John@0
|
262 -- that's ok, just bump it by 1 second. This could happen in the case of, say,
|
John@0
|
263 -- spam-clicking the undo button or adding names to the list. The recipients
|
John@0
|
264 -- should be ok with this since they'll follow the same algorithm. The only
|
John@0
|
265 -- real chance for a problem is if two people click within the 1 second window?
|
John@0
|
266 -- if someone sends you a past event,
|
John@0
|
267 -- it's ok if it's newer than anything in the changes list
|
John@0
|
268 -- otherwise ... causality has been violated.
|
John@0
|
269 -- Whenever an admin signon event happens, have the admins each perform a
|
John@0
|
270 -- timestamp check. Issue warnings for anyone with a clock that's more than
|
John@0
|
271 -- X seconds out of sync with the others. Seriously, why isn't NTP a standard
|
John@0
|
272 -- setting on all operating systems ...
|
John@0
|
273
|
John@1
|
274 -- Action and DoAction defs {{{
|
John@0
|
275 --
|
John@0
|
276 -- The actual actions for changes start here
|
John@0
|
277 --
|
John@0
|
278 -- Each action occurs as a pair of functions. The bsk:Action() function is from
|
John@0
|
279 -- a list admin's point of view. Each will check for admin status, then create a
|
John@0
|
280 -- change bundle, call the handler for that change (ie the DoAction func), and
|
John@0
|
281 -- then record/transmist the bundle. These are simple and repetitive functions.
|
John@0
|
282 --
|
John@0
|
283 -- The bsk:DoAction() function is tasked with executing the bundle and is what
|
John@0
|
284 -- non-admins and admins alike will call to transform their working state via a
|
John@0
|
285 -- change packet. Each Do() function will accept *only* a change packet, and
|
John@0
|
286 -- it's assumed that the change has been vetted elsewhere. These are very blunt
|
John@0
|
287 -- routines.
|
John@0
|
288 --
|
John@0
|
289 -- Note that "undo" has no special voodoo to it. It's basically a change that
|
John@0
|
290 -- reverses the prior change on the stack.
|
John@0
|
291
|
John@8
|
292 -- persons list
|
John@8
|
293 function bsk:DoAddPerson(change)
|
John@0
|
294 assert(change)
|
John@8
|
295 assert(change.arg.id)
|
John@0
|
296 local arg = change.arg
|
John@0
|
297 -- require admin
|
John@8
|
298 local persons = bsk.persons
|
John@0
|
299 local name = arg.name
|
John@8
|
300 local id = arg.id
|
John@8
|
301 assert(persons[id]==nil)
|
John@8
|
302 persons[id] = {main=name}
|
John@8
|
303 persons.time=change.time
|
John@16
|
304 personName2id[name] = id
|
John@0
|
305 return true
|
John@0
|
306 end
|
John@0
|
307
|
John@8
|
308 function bsk:AddPerson(name)
|
John@8
|
309 local persons = bsk.persons
|
John@0
|
310 local guid = UnitGUID(name)
|
John@0
|
311 -- TODO: check guid to be sure it's a player
|
John@0
|
312 if not guid then
|
John@0
|
313 self:Print(sformat("Could not add player %s - they must be in range or group",name))
|
John@0
|
314 return
|
John@0
|
315 end
|
John@8
|
316 local id = string.sub(guid,6) -- skip at least 0x0580 ...
|
John@8
|
317 id = id:gsub("^0*(.*)","%1") -- nom all leading zeroes remaining
|
John@8
|
318
|
John@8
|
319 if persons[id] and persons[id] ~= name then
|
John@17
|
320 self:Print(sformat("Namechange detected for %s - new is %s, please rename the existing entry", persons[id].main, name))
|
John@0
|
321 return
|
John@0
|
322 end
|
John@8
|
323 if persons[id] ~= nil then
|
John@8
|
324 self:Print(sformat("%s is already in the persons list; disregarding", name))
|
John@0
|
325 return
|
John@0
|
326 end
|
John@8
|
327 local change = {action="AddPerson",arg={name=name,id=id}}
|
John@8
|
328 if bsk:DoAddPerson(change) then
|
John@0
|
329 bsk:CreateChange(change)
|
John@0
|
330 end
|
John@0
|
331 end
|
John@0
|
332
|
John@0
|
333 function bsk:DoCreateList(change)
|
John@18
|
334 --if bsk:GetListIndex(change.arg.name) then
|
John@18
|
335 -- self:Print(sformat("List %s already exists",v.name))
|
John@18
|
336 -- return false
|
John@18
|
337 --end
|
John@19
|
338 bsk.lists[change.arg.id]={name=change.arg.name,time=change.time}
|
John@0
|
339 return true
|
John@0
|
340 end
|
John@0
|
341
|
John@0
|
342 function bsk:CreateList(name)
|
John@0
|
343 -- require admin
|
John@0
|
344 local change={action="CreateList",arg={name=name}}
|
John@0
|
345 bsk:StartChange(change)
|
John@18
|
346 change.arg.id=change.time -- use the creation timestamp as the list's index. it's as unique as anything...
|
John@0
|
347 self:Print("Creating ... " .. name)
|
John@0
|
348 if bsk:DoCreateList(change) then
|
John@0
|
349 bsk:CommitChange(change)
|
John@0
|
350 end
|
John@0
|
351 end
|
John@0
|
352
|
John@10
|
353 function bsk:DoAddPersonToListEnd(change)
|
John@10
|
354 local list = bsk.lists[change.arg.listIndex]
|
John@22
|
355 local index
|
John@22
|
356 if getn(list) > 0 then
|
John@22
|
357 index = list[#list].index + 0.1
|
John@22
|
358 else
|
John@22
|
359 index = 0.1
|
John@22
|
360 end
|
John@10
|
361 local entry = {index=index, id=change.arg.id}
|
John@0
|
362
|
John@10
|
363 tinsert(list,entry)
|
John@10
|
364 list.time = change.time
|
John@10
|
365 list.closedRandom = true
|
John@10
|
366
|
John@0
|
367 return true
|
John@0
|
368 end
|
John@0
|
369
|
John@16
|
370 function bsk:AddPersonToListEnd(name,listName)
|
John@0
|
371 -- require admin
|
John@16
|
372 local listIndex = bsk:GetListIndex(listName)
|
John@16
|
373 local id = personName2id[name]
|
John@13
|
374 if bsk:IdIsInList(id,bsk.lists[listIndex]) then
|
John@13
|
375 bsk:Print(sformat("Person %s is already on the reqeuested list",name))
|
John@17
|
376 return false
|
John@13
|
377 end
|
John@16
|
378 bsk:Print(sformat("Adding %s (%s) to list %s (%s)", name, id, listName, listIndex))
|
John@10
|
379 local change = {action="AddToListEnd",arg={id=id,listIndex=listIndex}}
|
John@0
|
380 bsk:StartChange(change)
|
John@10
|
381 if bsk:DoAddPersonToListEnd(change) then
|
John@10
|
382 bsk:CommitChange(change)
|
John@10
|
383 end
|
John@10
|
384 end
|
John@10
|
385
|
John@10
|
386 function bsk:DoAddPersonToListRandom(change)
|
John@10
|
387 local list = bsk.lists[change.arg.listIndex]
|
John@10
|
388 local entry = {index=change.arg.roll, id=change.arg.id}
|
John@10
|
389
|
John@10
|
390 tinsert(list,entry)
|
John@12
|
391 table.sort(list,function(a,b) return a.index < b.index end)
|
John@10
|
392 list.time = change.time
|
John@10
|
393
|
John@10
|
394 return true
|
John@10
|
395 end
|
John@10
|
396
|
John@16
|
397 function bsk:AddPersonToListRandom(name,listName)
|
John@10
|
398 -- require admin
|
John@16
|
399 local listIndex = bsk:GetListIndex(listName)
|
John@10
|
400 if bsk.lists[listIndex].closedRandom then
|
John@10
|
401 self:Print("Cannot add person to list by random roll because an add-to-end operation has already occurred")
|
John@12
|
402 return false
|
John@10
|
403 end
|
John@17
|
404 local id = personName2id[name]
|
John@13
|
405 if bsk:IdIsInList(id,bsk.lists[listIndex]) then
|
John@13
|
406 bsk:Print(sformat("Person %s is already on the reqeuested list",name))
|
John@17
|
407 return false
|
John@13
|
408 end
|
John@10
|
409 local roll = math.random()
|
John@16
|
410 bsk:Print(sformat("Adding %s (%s) to list %s (%s) with roll (%f)", name, id, listName, listIndex, roll))
|
John@10
|
411 local change = {action="AddToListRand",arg={id=id,listIndex=listIndex,roll=roll}}
|
John@10
|
412 bsk:StartChange(change)
|
John@10
|
413 if bsk:DoAddPersonToListRandom(change) then
|
John@0
|
414 bsk:CommitChange(change)
|
John@0
|
415 end
|
John@0
|
416 end
|
John@0
|
417
|
John@8
|
418 function bsk:DoRemovePerson(change)
|
John@0
|
419
|
John@0
|
420 -- return true
|
John@0
|
421 end
|
John@0
|
422
|
John@8
|
423 function bsk:RemovePerson(name)
|
John@8
|
424 -- from both persons and lists
|
John@0
|
425 end
|
John@0
|
426
|
John@8
|
427 function bsk:DoSuicidePerson(change)
|
John@16
|
428 local list = bsk.lists[change.arg.listIndex]
|
John@16
|
429 local affected = shallowCopy(change.arg.affect)
|
John@0
|
430 -- the goal here is to rotate the suicide list by 1
|
John@0
|
431 -- then we can just mash it on top of the intersection between the original
|
John@0
|
432 -- list and the working copy
|
John@17
|
433
|
John@16
|
434 local replacement = shallowCopy(change.arg.affect)
|
John@16
|
435 local temp = table.remove(replacement,1) -- pop
|
John@16
|
436 tinsert(replacement,temp) -- push_back
|
John@0
|
437 --bsk:Print(sformat("Before suicide of %s on list %s",slist[1],list.name))
|
John@0
|
438 --bsk:PrintTable(list)
|
John@0
|
439 for i = 1, #list do
|
John@17
|
440 if list[i].id == affected[1] then
|
John@17
|
441 table.remove(affected,1)
|
John@16
|
442 list[i].id = replacement[1]
|
John@16
|
443 table.remove(replacement,1)
|
John@0
|
444 end
|
John@0
|
445 end
|
John@0
|
446 list.time=change.time
|
John@0
|
447 return true
|
John@0
|
448 end
|
John@0
|
449
|
John@17
|
450 function bsk:SuicidePerson(name,listName)
|
John@0
|
451 -- require admin
|
John@0
|
452 bsk:PopulateRaidList()
|
John@16
|
453 local listIndex = bsk:GetListIndex(listName)
|
John@16
|
454 local id = personName2id[name]
|
John@16
|
455 local affect=bsk:GetSuicideList(id,bsk.lists[listIndex])
|
John@16
|
456 local change = {action="SuicidePerson",arg={affect=affect,listIndex=listIndex}}
|
John@0
|
457 bsk:StartChange(change)
|
John@8
|
458 if bsk:DoSuicidePerson(change) then
|
John@0
|
459 bsk:CommitChange(change)
|
John@0
|
460 end
|
John@0
|
461 end
|
John@5
|
462
|
John@20
|
463 function bsk:DoRenameList(change)
|
John@20
|
464 bsk.lists[change.arg.listIndex].name = change.arg.name
|
John@20
|
465 bsk.lists[change.arg.listIndex].time = change.time
|
John@20
|
466 return true
|
John@20
|
467 end
|
John@20
|
468
|
John@20
|
469 function bsk:RenameList(listName,newListName)
|
John@20
|
470 -- require admin
|
John@20
|
471 local listIndex = bsk:GetListIndex(listName)
|
John@20
|
472 local change = {action="RenameList",arg={listIndex=listIndex,name=newListName}}
|
John@20
|
473 bsk:StartChange(change)
|
John@20
|
474 if bsk:DoRenameList(change) then
|
John@20
|
475 bsk:CommitChange(change)
|
John@20
|
476 end
|
John@20
|
477 end
|
John@20
|
478
|
John@21
|
479 function bsk:DoDeleteList(change)
|
John@21
|
480 bsk.lists[change.arg.listIndex] = nil
|
John@21
|
481 return true
|
John@21
|
482 end
|
John@21
|
483
|
John@21
|
484 function bsk:DeleteList(listName)
|
John@21
|
485 local listIndex = bsk:GetListIndex(listName)
|
John@21
|
486 local change = {action="DeleteList",arg={listIndex=listIndex}}
|
John@21
|
487 bsk:StartChange(change)
|
John@21
|
488 if bsk:DoDeleteList(change) then
|
John@21
|
489 bsk:CommitChange(change)
|
John@21
|
490 end
|
John@21
|
491 end
|
John@21
|
492
|
John@22
|
493 function bsk:DoRemovePersonFromList(change)
|
John@22
|
494 local list = bsk.lists[change.arg.listIndex]
|
John@22
|
495
|
John@22
|
496 for i,v in pairs(list) do
|
John@22
|
497 if v.id == change.arg.id then
|
John@22
|
498 table.remove(list,i)
|
John@22
|
499 break
|
John@22
|
500 end
|
John@22
|
501 end
|
John@22
|
502 table.sort(list,function(a,b) return a.index < b.index end)
|
John@22
|
503 list.time = change.time
|
John@22
|
504 return true
|
John@22
|
505 end
|
John@22
|
506
|
John@22
|
507 function bsk:RemovePersonFromList(name,listName)
|
John@22
|
508 local listIndex = bsk:GetListIndex(listName)
|
John@22
|
509 local pid = personName2id[name]
|
John@22
|
510 local change = {action="RemovePersonFromList",arg={id=pid,listIndex=listIndex}}
|
John@22
|
511 bsk:StartChange(change)
|
John@22
|
512 if bsk:DoRemovePersonFromList(change) then
|
John@22
|
513 bsk:CommitChange(change)
|
John@22
|
514 end
|
John@22
|
515 end
|
John@20
|
516 --}}}
|
John@20
|
517 -- Higher order actions (ie calls other standard actions){{{
|
John@20
|
518
|
John@5
|
519 function bsk:TrimLists(time)
|
John@5
|
520 if not bsk:CheckListCausality() then
|
John@18
|
521 self:Print("Unable to trim changelist due to violated causality")
|
John@5
|
522 return false
|
John@5
|
523 end
|
John@5
|
524
|
John@5
|
525 if type(time) ~= "number" then
|
John@5
|
526 time = tonumber(time)
|
John@5
|
527 end
|
John@5
|
528
|
John@5
|
529 -- bisect the changes list by "time"
|
John@5
|
530 local before = {}
|
John@5
|
531 for i,v in ipairs(self.db.profile.changes) do
|
John@5
|
532 if v.time <= time then
|
John@5
|
533 tinsert(before,v)
|
John@5
|
534 else
|
John@5
|
535 break
|
John@5
|
536 end
|
John@5
|
537 end
|
John@5
|
538
|
John@5
|
539 -- apply first half
|
John@5
|
540 bsk:CreateWorkingStateFromChanges(before)
|
John@5
|
541
|
John@5
|
542 -- save this state permanently; trim the changes permanently
|
John@8
|
543 bsk:tcopy(bsk.db.profile.persons,bsk.persons)
|
John@5
|
544 bsk:tcopy(bsk.db.profile.listBase,bsk.lists)
|
John@8
|
545 while bsk.db.profile.changes ~= nil and bsk.db.profile.changes[1] ~= nil and bsk.db.profile.changes[1].time <= time do
|
John@5
|
546 table.remove(bsk.db.profile.changes,1)
|
John@5
|
547 end
|
John@5
|
548
|
John@5
|
549 -- using the trimmed list and the new bases, recreate the working state
|
John@5
|
550 bsk:CreateWorkingStateFromChanges(bsk.db.profile.changes)
|
John@5
|
551 end
|
John@5
|
552
|
John@8
|
553 function bsk:AddMissingPersons()
|
John@1
|
554 bsk:PopulateRaidList()
|
John@1
|
555 local t = {}
|
John@17
|
556 for id,_ in pairs(bsk.persons) do
|
John@17
|
557 t[id] = true
|
John@1
|
558 end
|
John@17
|
559 for name,_ in pairs(raidNameP) do
|
John@17
|
560 if personName2id[name] == nil then
|
John@17
|
561 bsk:Print(sformat("Person %s is missing from the persons list - adding",name))
|
John@17
|
562 bsk:AddPerson(name)
|
John@1
|
563 end
|
John@1
|
564 end
|
John@1
|
565 -- TODO: batch into a single op - no need to spam 25 messages in a row
|
John@1
|
566 end
|
John@17
|
567 function bsk:PopulateListRandom(listIndex)
|
John@17
|
568 -- difference (raid+reserve)-list, then random shuffle that, then add
|
John@3
|
569 bsk:PopulateRaidList()
|
John@17
|
570 local list = bsk.lists[listIndex]
|
John@3
|
571
|
John@17
|
572 local t = {} -- after loops, contains intersection of IDs present between raid and reserve
|
John@17
|
573 for i,v in pairs(raidIdP) do
|
John@17
|
574 if v then t[i] = true end
|
John@17
|
575 end
|
John@17
|
576 for i,v in pairs(reserveIdP) do
|
John@17
|
577 if v then t[i] = true end
|
John@17
|
578 end
|
John@17
|
579
|
John@17
|
580 -- now remove from t all of the people already present on the list
|
John@21
|
581 if list then
|
John@21
|
582 for i = 1,#list do
|
John@21
|
583 if t[list[i].id] then
|
John@21
|
584 t[list[i].id] = false
|
John@21
|
585 end
|
John@17
|
586 end
|
John@17
|
587 end
|
John@17
|
588
|
John@17
|
589 -- add all remaining
|
John@17
|
590 for i,v in pairs(t) do
|
John@17
|
591 if v then
|
John@17
|
592 bsk:AddPersonToListRandom(bsk.persons[i].main,list.name) -- TODO: APTLR keys off of string names. probably need to change this.
|
John@17
|
593 end
|
John@17
|
594 end
|
John@3
|
595 end
|
John@1
|
596 --}}}
|
John@1
|
597 -- "Soft" actions- ie things that cause nonpermanent state {{{
|
John@1
|
598
|
John@1
|
599 -- reserves
|
John@1
|
600 function bsk:AddReserve(name)
|
John@16
|
601 reserveIdP[personName2id[name]]=true
|
John@1
|
602 -- TODO: communicate to others. don't store this in any way.
|
John@1
|
603 end
|
John@1
|
604
|
John@1
|
605 function bsk:RemoveReserve(name)
|
John@16
|
606 reserveIdP[personName2id[name]]=false
|
John@1
|
607 -- TODO: communicate to others. don't store this in any way.
|
John@1
|
608 end
|
John@1
|
609
|
John@1
|
610
|
John@1
|
611 --function bsk:GetActiveList()
|
John@1
|
612 -- return bsk.lists[1] -- todo!
|
John@1
|
613 --end
|
John@1
|
614
|
John@1
|
615 --}}}
|
John@0
|
616
|
John@17
|
617 -- The following (adapted) code is from Xinhuan (wowace forum member)
|
John@0
|
618 -- Pre-create the unitID strings we will use
|
John@0
|
619 local pID = {}
|
John@0
|
620 local rID = {}
|
John@0
|
621 for i = 1, 4 do
|
John@0
|
622 pID[i] = format("party%d", i)
|
John@0
|
623 end
|
John@0
|
624 for i = 1, 40 do
|
John@0
|
625 rID[i] = format("raid%d", i)
|
John@0
|
626 end
|
John@0
|
627 function bsk:PopulateRaidList()
|
John@0
|
628 local inParty = GetNumPartyMembers()
|
John@0
|
629 local inRaid = GetNumRaidMembers()
|
John@17
|
630 local add = function(unitNameArg)
|
John@17
|
631 local name = UnitName(unitNameArg)
|
John@17
|
632 raidNameP[name]=true
|
John@17
|
633 if personName2id[name] ~= nil then
|
John@17
|
634 raidIdP[personName2id[name]]=true
|
John@17
|
635 end
|
John@17
|
636 end
|
John@0
|
637
|
John@16
|
638 wipe(raidNameP)
|
John@16
|
639 wipe(raidIdP)
|
John@0
|
640 if inRaid > 0 then
|
John@0
|
641 for i = 1, inRaid do
|
John@17
|
642 add(rID[i])
|
John@0
|
643 end
|
John@0
|
644 elseif inParty > 0 then
|
John@0
|
645 for i = 1, inParty do
|
John@17
|
646 add(pID[i])
|
John@0
|
647 end
|
John@0
|
648 -- Now add yourself as the last party member
|
John@17
|
649 add("player")
|
John@0
|
650 else
|
John@0
|
651 -- You're alone
|
John@17
|
652 add("player")
|
John@0
|
653 end
|
John@19
|
654 --bsk:PrintTable(raidNameP)
|
John@0
|
655 end
|
John@0
|
656
|
John@0
|
657 -- undo rules!
|
John@0
|
658 -- only the most recent event can be undone
|
John@0
|
659 -- ^^^ on a given list?
|
John@0
|
660 -- algorithm is easy, given "Suicide A B C"
|
John@0
|
661 -- just find A,B,C in the list and replace in order from the s message
|
John@0
|
662 -- while undo is allowed *per-list*, certain events in the stream will
|
John@0
|
663 -- prevent proper undo, such as add/delete player or add/delete list
|
John@0
|
664
|
John@0
|
665
|
John@12
|
666 function bsk:GetSuicideList(id,list)
|
John@1
|
667 --self:Print("Calculating changeset for "..name.." from list -")
|
John@1
|
668 --self:PrintTable(list)
|
John@1
|
669 local t = {}
|
John@1
|
670 local ret = {}
|
John@1
|
671 local pushing = false
|
John@1
|
672 for i = 1, #list do
|
John@12
|
673 if list[i].id == id then
|
John@1
|
674 pushing = true
|
John@1
|
675 end
|
John@16
|
676 if pushing and (raidIdP[list[i].id] or reserveIdP[list[i].id]) then
|
John@10
|
677 tinsert(ret,list[i].id)
|
John@1
|
678 end
|
John@1
|
679 end
|
John@16
|
680 --bsk:Print("GSL")
|
John@16
|
681 --bsk:PrintTable(ret)
|
John@16
|
682 --bsk:Print("GSL")
|
John@1
|
683 return ret
|
John@0
|
684 end
|
John@0
|
685
|
John@13
|
686 function bsk:IdIsInList(id,listRef)
|
John@13
|
687 for i = 1,#listRef do
|
John@13
|
688 if id == listRef[i].id then
|
John@13
|
689 return true
|
John@13
|
690 end
|
John@13
|
691 end
|
John@13
|
692 return false
|
John@13
|
693 end
|
John@13
|
694
|
John@5
|
695 -- returns true if the events in the list are in time order
|
John@5
|
696 function bsk:CheckListCausality()
|
John@5
|
697 local t = nil
|
John@5
|
698 for i,v in ipairs(bsk.db.profile.changes) do
|
John@5
|
699 if t ~= nil then
|
John@5
|
700 if v.time <= t then
|
John@5
|
701 return false
|
John@5
|
702 end
|
John@5
|
703 end
|
John@5
|
704 t = v.time
|
John@5
|
705 end
|
John@5
|
706 return true
|
John@5
|
707 end
|
John@0
|
708
|
John@0
|
709 -- Support functions
|
John@0
|
710
|
John@0
|
711 function bsk:GetListIndex(name)
|
John@0
|
712 for i,v in pairs(bsk.lists) do
|
John@0
|
713 if v.name == name then
|
John@0
|
714 return i
|
John@0
|
715 end
|
John@0
|
716 end
|
John@17
|
717 return nil
|
John@0
|
718 end
|
John@1
|
719
|
John@3
|
720 local shuffleArray = function(array)
|
John@3
|
721 local arrayCount = #array
|
John@3
|
722 for i = arrayCount, 2, -1 do
|
John@3
|
723 local j = math.random(1, i)
|
John@3
|
724 array[i], array[j] = array[j], array[i]
|
John@3
|
725 end
|
John@3
|
726 return array
|
John@3
|
727 end
|
John@3
|
728
|