Mercurial > wow > breuesk

annotate Lists.lua @ 39:ecef0cba2913

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