wow/breuesk: Lists.lua comparison

comparison Lists.lua @ 49:f52d472f0b0a

Sweeping refactor to compartmentalize the various lists and to give them nice interfaces. Disentangled dependency web significantly

author	John@Yosemite-PC
date	Wed, 21 Mar 2012 22:52:42 -0400
parents	6c0a8acccbc8
children	b155a875de42

comparison

equal deleted inserted replaced

-:b3679847e292
+:f52d472f0b0a
 local assert=assert
 local getmetatable=getmetatable
 local setmetatable=setmetatable
 setfenv(1,bsk)
-lists = {}
+ListEntry =
-persons = {}
+{
+index = 0.0,
-raidNameP = {} -- "name" is present in raid
+id = 0,
-raidIdP = {} -- "id" is present in raid
+}
-reserveIdP = {} -- "reserve id present"
+ListEntry.__index = ListEntry
-local personName2id = {} -- given "name" get that person's id
+function ListEntry:new(arg1,arg2)
+local n = {}
+setmetatable(n,ListEntry)
+if type(arg1) == "number" and type(arg2) == "string" then
+n.index, n.id = index,id
+elseif type(arg1) == "table" and type(arg2) == "nil" then
+n.index, n.id = arg1.roll, arg1.id
+else
+_G.error("Do not know how to construct a ListEntry from " .. type(arg1) .. " and " .. type(arg2))
+end
+assert(n.index ~= nil)
+assert(n.id ~= nil)
+return n
+end
+function ListEntry:GetId()
+return self.id
+end
+function ListEntry:GetIndex()
+return self.index
+end
+function ListEntry:ReplaceId(newId) -- returns the old Id
+local temp = self.id
+self.id = newId
+return temp
+end
 List =
 {
-id = 0,
 name = "",
-Sort = function()
+time = 0,
-end
+-- "private" functions. only private thing about them is that my
+-- autocomplete won't pick them up when defined this way
+Sort = function(self)
+table.sort(self.data,function(a,b) return a:GetIndex() < b:GetIndex() end)
+end,
+GetLastIndex = function(self)
+if not self.data or getn(self.data) == 0 then return 0.0
+else return self.data[#self.data]:GetIndex() end
+end,
+SetTime = function(self,time)
+if time == nil or time == 0 then
+assert("Dangerous things are afoot")
+else
+self.time = time
+end
+end
 }
-function List:new() -- TODO: take args, build list
+List.__index = List
-n = {}
+function List:new(arg1, arg2, arg3)
-setmetatable(n,self)
+local n = {data={}}
-self.__index = self
+setmetatable(n,List)
+if type(arg1) == "string" and type(arg2) == "number" and type(arg3) == "nil" then
+n.name = arg1
+n.time = arg2
+elseif type(arg1) == "table" and type(arg2) == "nil" and type(arg3) == "nil" then
+n.name = arg1.name
+if arg1.data then
+for _,v in pairs(arg1.data) do
+local le = ListEntry:new(v)
+table.insert(n.data,entry)
+end
+n:Sort()
+end
+n:SetTime(arg1.time)
+else
+_G.error(sformat("Do not know how to construct list from: %s and %s and %s", type(arg1), type(arg2), type(arg3)))
+end
 return n
 end
-function List:HasID(id)
+function List:HasId(id)
-for i = 1,#self do
+for le in self:OrderedIdIter() do
-if id == self[i].id then
+if id == le then
 return true
 end
 end
 return false
 end
-function List:GetID()
+function List:GetTime()
+return self.time
+end
+function List:GetName()
+return self.name
+end
+function List:GetId()
+local listIndex = LootLists:IdOf(self) -- TODO: undo circular dep somehow
+return listIndex
+end
+function List:Rename(packet,time)
+self.name = packet.name
+self:SetTime(time)
+return packet
+end
+function List:RenameList(newName)
+local listIndex = self:GetId()
+return InitiateChange("Rename",self,{listIndex=listIndex,name=newName})
+end
+function List:RemoveEntry(entry,time)
+local pos = self:Select(entry.id)
+if pos then
+--print("Removing id " .. entry.id .. " pos " .. pos)
+table.remove(self.data,pos)
+self:Sort()
+self:SetTime(time)
+return pos
+end
+--print("Failed removal of ...")
+--PrintTable(entry)
+end
+function List:Remove(id)
+-- TODO: check id
+local listIndex = self:GetId()
+return InitiateChange("RemoveEntry",self,{listIndex=listIndex,id=id})
+end
+function List:InsertEndEntry(packet,time)
+if self:InsertEntry(packet,time) then
+self.closedRandom = true
+return packet
+end
+end
+function List:InsertEntry(packet,time)
+local le = ListEntry:new(packet)
+table.insert(self.data,le)
+self:Sort()
+self:SetTime(time)
+--printf("Inserting %s to %s", packet.id, packet.listIndex)
+return le
+end
+function List:InsertEnd(id) -- returns the LE created
+if self:Select(id) then
+printf("Person %s is already on the reqeuested list",id) -- todo: lookup name
+return false
+end
+local index = self:GetLastIndex() + 0.1
+local le = ListEntry:new(index,id)
+local listIndex = self:GetId()
+return InitiateChange("InsertEndEntry",self,{listIndex=listIndex,id=id,roll=index})
+end
+function List:InsertRandom(id) -- returns the LE created
+if self.closedRandom then
+print("Cannot add person to list by random roll because an add-to-end operation has already occurred")
+return false
+end
+if self:Select(id) then
+printf("Person %s is already on the reqeuested list",id) -- todo: lookup name
+return false
+end
+local index = math.random()
+local listIndex = self:GetId()
+return InitiateChange("InsertEntry",self,{listIndex=listIndex,id=id,roll=index})
+end
+function List:OrderedListEntryIter()
+local i = 0
+local n = #self.data
+return function()
+i = i+1
+if i<=n then return self.data[i] end
+end
+end
+function List:OrderedIdIter()
+local i = 0
+local n = #self.data
+return function()
+i = i+1
+if i<=n then return self.data[i]:GetId() end
+end
+end
+function List:GetAllIds()
+local t = {}
+for id in self:OrderedIdIter() do
+table.insert(t,id)
+end
+return t
+end
+function List:Select(entry) -- returns the position and the entry
+if type(entry) == "string" then -- search by id
+local ids = self:GetAllIds()
+for i,v in ipairs(ids) do
+if v == entry then
+return i, self.data[i]
+end
+end
+return false, nil
+else
+assert("undone")
+return false, nil
+end
+end
+function List:Suicide(packet,time)
+-- the goal here is to rotate the suicide list by 1
+-- then we can just mash it on top of the intersection between the original
+-- list and the working copy
+local affected = shallowCopy(packet.affect)
+local replacement = shallowCopy(packet.affect)
+local temp = table.remove(replacement,1) -- pop
+tinsert(replacement,temp) -- push_back
+--rintf(("Before suicide of %s on list %s",slist[1],list.name)
+--PrintTable(list)
+for le in self:OrderedListEntryIter() do
+if le:GetId() == affected[1] then
+le:ReplaceId(replacement[1])
+table.remove(affected,1)
+table.remove(replacement,1)
+end
+end
+-- TODO: flag error if affected and replacement aren't both empty now
+self:SetTime(time)
+return packet
+end
+function List:SuicidePerson(id)
+-- first calculate the effect, then initiate the change
+PersonList:RefreshRaidList()
+local slist = {}
+local pushing = false
+for le in self:OrderedListEntryIter() do -- get all ids
+local lid = le:GetId()
+if lid == id then
+pushing = true
+end
+if pushing and PersonList:IsActive(lid) then -- TODO: decouple
+tinsert(slist,lid)
+end
+end
+local listIndex = self:GetId()
+return InitiateChange("Suicide",self,{listIndex=listIndex,affect=slist})
+end
+LootLists =
+{
+--l = {} -- list of List objects, keyed by id
+}
+-- generate self, then generate sublists
+function LootLists:ConstructFromDB(db)
+self:Reset()
+local saved = db.profile.lists
+for i,v in pairs(saved) do -- upconvert saved to true list objects
+self.l[i] = List:new(v)
+end
+end
+function LootLists:SaveToDB(db)
+db.profile.lists = self.l
+end
+function LootLists:CreateList(packet,time)
+local le = List:new(packet.name,time)
+if not packet.id then packet.id = time end -- uses the timestamp for the index - it's unique, unlike anything else I can think of
+self.l[packet.id] = le
+return le
+end
+function LootLists:Create(name)
+return InitiateChange("CreateList",self,{name=name})
+end
+function LootLists:DeleteList(packet,time)
+self.l[packet.listIndex] = nil
+return id
+end
+function LootLists:Delete(index)
+-- TODO: is there anything to check first, or just fire away?
+return InitiateChange("DeleteList",self,{listIndex=index})
+end
+function LootLists:Select(id)
+if type(id) == "number" then -- by id
+return self.l[id]
+elseif type(id) == "string" then -- name
+for i,v in pairs(self.l) do
+if v:GetName() == id then
+return v
+end
+end
+end
+return nil
+end
+function LootLists:Reset()
+self.l = {}
+end
+function LootLists:GetAllIds()
+local t = {}
+for i,v in pairs(self.l) do
+table.insert(t,i)
+end
+return t
+end
+function LootLists:IdOf(list)
+for i,v in pairs(self.l) do
+if v == list then
+return i
+end
+end
+end
+Toon =
+{
+id=0,
+name="",
+class=""
+}
+Toon.__index = Toon
+function Toon:new(arg1,arg2,arg3)
+local t = {}
+setmetatable(t,Toon)
+if type(arg1) == "number" and type(arg2) == "string" and type(arg3) == "string" then
+t.id, t.name, t.class = arg1, arg2, arg3
+elseif type(arg1) == "table" and arg2 == nil and arg3 == nil then
+t.id, t.name, t.class = arg1.id, arg1.name, arg1.class
+else
+error("Cannot construct a toon object from types " .. type(arg1) .. ", " .. type(arg2) .. ", " .. type(arg3))
+end
+return t
+end
+function Toon:GetName()
+return self.name
+end
+function Toon:GetId()
 return self.id
 end
-function List:RemoveEntry()
+function Toon:GetClass()
-end
+return self.class
-function List:InsertEntry()
+end
-end
-function List:OrderedIter()
+PersonList =
-end
+{
+toons = {},
+time = 0,
+active = { raid={}, reserve={} }
+}
+function PersonList:ConstructFromDB(db)
+self:Reset()
+local dbp = db.profile.persons
+self.time = dbp.time
+if dbp.toons == nil then return end
+for i,v in pairs(dbp.toons) do
+local te = Toon:new(v)
+table.insert(self.toons,te)
+end
+end
+function PersonList:SaveToDB(db)
+db.profile.persons = { toons=self.toons, time=self.time }
+end
+function PersonList:Reset()
+self.toons = {}
+self.time = 0
+self.active = { raid={}, reserve={}, raidExtras={} }
+end
+function PersonList:Select(id)
+-- both id and name are strings, but there won't be clashes
+-- because an ID will contain either a number or all caps letters
+-- and names must be long enough to ensure that one of those is true
+if type(id) == "string" then
+for i,v in pairs(self.toons) do
+--print(i)
+--PrintTable(v)
+if v:GetName() == id or v:GetId() == id then
+return v
+end
+end
+end
+end
+function PersonList:AddToon(packet,time)
+local te = Toon:new(packet)
+table.insert(self.toons,te)
+return te
+end
+function PersonList:Add(name)
+local guid = _G.UnitGUID(name)
+-- TODO: check guid to be sure it's a player
+if not guid then
+printf("Could not add player %s - they must be in range or group",name)
+return
+end
+local _,englishClass = _G.UnitClass(name)
+--print("Person " .. name .. " is class " .. englishClass)
+local id = string.sub(guid,6) -- skip at least 0x0580 ...
+id = id:gsub("^0*(.*)","%1") -- nom all leading zeroes remaining
+local pe = self:Select(id)
+if pe and pe:GetName() ~= name then
+printf("Namechange detected for %s - new is %s, please rename the existing entry", pe:GetName(), name)
+return
+end
+if pe then
+printf("%s is already in the persons list; disregarding", name)
+return
+end
+return InitiateChange("AddToon", self, {name=name, id=id, class=englishClass})
+end
+function PersonList:RemoveToon(packet,time)
+local id = packet.id
+for i,v in pairs(self.toons) do
+if v:GetId() == id then
+table.remove(self.toons,i)
+return v
+end
+end
+end
+function PersonList:Remove(ident)
+local le = PersonList:Select(ident)
+if not le then
+printf("%s is not in the persons list, please check your spelling", ident)
+return false
+end
+local id = le:GetId()
+local listsTheyreOn = {}
+-- check if they're active on any loot list
+local allListIds = LootLists:GetAllIds()
+for _,v in pairs(allListIds) do
+if LootLists:Select(v):HasId(id) then -- TODO: this is ineloquent
+tinsert(listsTheyreOn,LootLists:Select(v):GetName())
+break
+end
+end
+if getn(listsTheyreOn) > 0 then
+printf("Cannot remove person %s because they are on one or more lists (%s)",ident,table.concat(listsTheyreOn,", "))
+return false
+end
+return InitiateChange("RemoveToon", self, {id=id})
+end
+function PersonList:IsRegistered(id)
+if self:Select(id) ~= nil then return true end
+end
+function PersonList:AddReserve(id)
+local le = self:Select(id)
+if le then
+-- todo: check that they're not already reserved
+self.active.reserve[le:GetId()] = true
+end
+end
+-- todo: remove reserve
+function PersonList:IsActive(id)
+return self.active.raid[id] or self.active.reserve[id]
+end
+function PersonList:AddMissing()
+self:RefreshRaidList()
+for _,name in pairs(self.active.raidExtras) do
+printf("Person %s is missing from the persons list - adding",name)
+self:Add(name)
+end
+-- TODO: batch into a single op - no need to spam 25 messages in a row
+end
+function PersonList:GetAllActiveIds()
+self:RefreshRaidList()
+local t = {}
+for i,v in pairs(self.active.raid) do
+if v then table.insert(t,i) end
+end
+for i,v in pairs(self.active.reserve) do
+if v then table.insert(t,i) end
+end
+return t
+end
+-- The following (adapted) code is from Xinhuan (wowace forum member)
+-- Pre-create the unitId strings we will use
+local pId = {}
+local rId = {}
+for i = 1, 4 do
+pId[i] = sformat("party%d", i)
+end
+for i = 1, 40 do
+rId[i] = sformat("raid%d", i)
+end
+function PersonList:RefreshRaidList()
+local inParty = _G.GetNumPartyMembers()
+local inRaid = _G.GetNumRaidMembers()
+local add = function(unitNameArg)
+local name = _G.UnitName(unitNameArg)
+local te = self:Select(name)
+if te then
+self.active.raid[te:GetId()]=true
+else
+table.insert(self.active.raidExtras,name)
+end
+--if personName2id[name] ~= nil then
+--    raidIdP[personName2id[name]]=true
+--end
+end
+self.active.raid = {}
+self.active.raidExtras = {}
+if inRaid > 0 then
+for i = 1, inRaid do
+add(rId[i])
+end
+elseif inParty > 0 then
+for i = 1, inParty do
+add(pId[i])
+end
+-- Now add yourself as the last party member
+add("player")
+else
+-- You're alone
+add("player")
+end
+end
+function GetSafeTimestamp()
+local changes = db.profile.changes
+local ctime = time()
+local n = getn(changes)
+if n > 0 then
+if changes[n].time >= ctime then
+ctime = changes[n].time + 1
+end
+end
+return ctime
+end
+function InitiateChange(finalizeAction,acceptor,arg)
+local change = {}
+change.time = GetSafeTimestamp()
+change.action = finalizeAction
+change.arg = arg
+if acceptor[finalizeAction](acceptor,arg,change.time) then
+table.insert(db.profile.changes,change)
+-- TODO: broadcast
+return arg
+else
+return nil
+end
+end
+function ProcessChange(change)
+-- try list-o-lists and persons - if has matching function, call it
+local action = change.action
+if PersonList[action] then
+PersonList[action](PersonList,change.arg,change.time)
+return
+elseif LootLists[action] then
+LootLists[action](LootLists,change.arg,change.time)
+return
+else
+-- pray that the change has a listIndex in it ...
+if change.arg.listIndex then
+local l = LootLists:Select(change.arg.listIndex)
+if l and l[action] then
+l[action](l,change.arg,change.time)
+return
+end
+end
+end
+_G.error("Could not process change: " .. change.action)
+end
 function SelfDestruct()
-lists = {}
+LootLists:Reset()
-persons = {}
+PersonList:Reset()
 db.profile.persons = {}
 db.profile.changes = {}
 db.profile.lists = {}
-raidNameP = {}
-raidIdP = {}
-reserveIdP = {}
-personName2id = {}
 end
 -- Debugging {{{
 function PrettyPrintList(listIndex)
-local list = lists[listIndex]
+PersonList:RefreshRaidList()
-print("List: " .. list.name .. " (" .. listIndex .. ") - last modified " .. date("%m/%d/%y %H:%M:%S", list.time) .. " (",list.time,")" )
+local le = LootLists:Select(listIndex)
-for i = 1,#list do
+print("List: " .. le:GetName() .. " (" .. le:GetId() .. ") - last modified " .. date("%m/%d/%y %H:%M:%S", le:GetTime()) .. " ("..le:GetTime()..")" )
-print("  " .. i .. " - " .. persons[list[i].id].main)
+local pos = 1
+for i in le:OrderedIdIter() do -- ordered iterator
+local s = ""
+if PersonList:IsActive(i) then
+s = "*"
+end
+print("  " .. pos .. " - " .. PersonList:Select(i):GetName() .. " ("..i..")",s)
+pos = pos + 1
 end
 end
 function PrettyPrintLists()
-for i,_ in pairs(lists) do
+for _,i in pairs(LootLists:GetAllIds()) do
 PrettyPrintList(i)
 end
 end
 function PrintLists()
-PrintTable(lists)
+PrintTable(LootLists)
 end
 function PrintChanges()
 PrintTable(db.profile.changes)
 end
 function PrintPersons()
-PrintTable(persons)
+PrintTable(PersonList)
 end
 function PrintAPI(object)
 for i,v in pairs(object) do
 if type(v) == "function" then
 print("function "..i.."()")
 end
 end
 end
-function PrintRaidAndReserve()
-print("RaidNameP")
-PrintTable(raidNameP)
-print("RaidIdP")
-PrintTable(raidIdP)
-print("ReserveP")
-PrintTable(reserveIdP)
-print("personName2id")
-PrintTable(personName2id)
-end
 --}}}
-function UpdatePersonsReverse()
-for i,v in pairs(persons) do
-if i ~= "time" then
-personName2id[v.main] = i
-end
-end
-end
 -- Change processing {{{
 function CreateWorkingStateFromChanges(changes)
-local personsBase = db.profile.persons
-local lists = db.profile.lists
 -- copy the base to the working state
-wipe(lists)
+LootLists:ConstructFromDB(db)
-wipe(persons)
+PersonList:ConstructFromDB(db)
-wipe(personName2id)
-tcopy(lists,lists)
-tcopy(persons,personsBase)
 -- now just go through the changes list applying each
 for i,v in ipairs(changes) do
 ProcessChange(v)
 end
--- update the persons reverse list
-UpdatePersonsReverse()
-end
-function CreateChange(change)
--- sanity
-assert(change)
-assert(change.action)
-assert(change.arg)
-StartChange(change)
-CommitChange(change)
-end
-function StartChange(change)
-local changes = db.profile.changes
-change.time = time()
-local n = getn(changes)
-if n > 0 then
-if changes[n].time >= change.time then
-change.time = changes[n].time + 1
-end
-end
-end
-function CommitChange(change)
-local changes = db.profile.changes
-tinsert(changes,change)
--- TODO: broadcast change
-end
-function ProcessChange(change)
-if change.action == "AddPerson" then
-DoAddPerson(change)
-elseif change.action == "RenameList" then
-DoRenameList(change)
-elseif change.action == "CreateList" then
-DoCreateList(change)
-elseif change.action == "DeleteList" then
-DoDeleteList(change)
-elseif change.action == "AddToListEnd" then
-DoAddPersonToListEnd(change)
-elseif change.action == "AddToListRand" then
-DoAddPersonToListRandom(change)
-elseif change.action == "RemovePerson" then
-DoRemovePerson(change)
-elseif change.action == "RemovePersonFromList" then
-DoRemovePersonFromList(change)
-elseif change.action == "SuicidePerson" then
-DoSuicidePerson(change)
-else
-print("Unknown message encountered")
-PrintTable(change)
-assert(false)
-end
 end
 --}}}
---
 -- holy crap long winded {{{
 -- timestamp logic:
 -- use time() for comparisons - local clients use date() to make it pretty. only
 -- dowisde - we can't have a server timestamp. Which kind of sucks, but it turns
 -- out you can change timezones when you enter an instance server, so you really
 -- it's assumed that the change has been vetted elsewhere. These are very blunt
 -- routines.
 --
 -- Note that "undo" has no special voodoo to it. It's basically a change that
 -- reverses the prior change on the stack.--}}}
-function DoAddPerson(change)--{{{
-assert(change)
-assert(change.arg.id)
--- require admin
-local persons = persons
-local name = change.arg.name
-local id = change.arg.id
-assert(persons[id]==nil)
-persons[id] = {main=name,class=change.arg.class}
-persons.time=change.time
-personName2id[name] = id
-return true
-end--}}}
 function AddPerson(name)--{{{
-local persons = persons
+print("Adding ... " .. name)
-local guid = _G.UnitGUID(name)
+PersonList:Add(name)
--- TODO: check guid to be sure it's a player
-if not guid then
-printf("Could not add player %s - they must be in range or group",name)
-return
-end
-local _,englishClass = _G.UnitClass(name)
---print("Person " .. name .. " is class " .. englishClass)
-local id = string.sub(guid,6) -- skip at least 0x0580 ...
-id = id:gsub("^0*(.*)","%1") -- nom all leading zeroes remaining
-if persons[id] and persons[id] ~= name then
-printf("Namechange detected for %s - new is %s, please rename the existing entry", persons[id].main, name)
-return
-end
-if persons[id] ~= nil then
-printf("%s is already in the persons list; disregarding", name)
-return
-end
-local change = {action="AddPerson",arg={name=name,id=id,class=englishClass}}
-if DoAddPerson(change) then
-CreateChange(change)
-end
-end--}}}
-function DoCreateList(change)--{{{
---if GetListIndex(change.arg.name) then
---    rintf(("List %s already exists",v.name)
---    return false
---end
-lists[change.arg.id]={name=change.arg.name,time=change.time}
-return true
 end--}}}
 function CreateList(name)--{{{
 -- require admin
-local change={action="CreateList",arg={name=name}}
-StartChange(change)
-change.arg.id=change.time -- use the creation timestamp as the list's index. it's as unique as anything...
 print("Creating ... " .. name)
-if DoCreateList(change) then
+return LootLists:Create(name)
-CommitChange(change)
-end
-end--}}}
-function DoAddPersonToListEnd(change)--{{{
-local list = lists[change.arg.listIndex]
-local index
-if getn(list) > 0 then
-index = list[#list].index + 0.1
-else
-index = 0.1
-end
-local entry = {index=index, id=change.arg.id}
-tinsert(list,entry)
-list.time = change.time
-list.closedRandom = true
-return true
 end--}}}
 function AddPersonToListEnd(name,listName)--{{{
 -- require admin
-local listIndex = GetListIndex(listName)
+local l = LootLists:Select(listName)
-local id = personName2id[name]
+local te = PersonList:Select(name)
-if IdIsInList(id,lists[listIndex]) then
+-- TODO: if not te ...
-printf("Person %s is already on the reqeuested list",name)
+printf("Adding %s (%s) to list %s", name, te:GetId(), listName)
-return false
+return l:InsertEnd(te:GetId())
-end
-printf("Adding %s (%s) to list %s (%s)", name, id, listName, listIndex)
-local change = {action="AddToListEnd",arg={id=id,listIndex=listIndex}}
-StartChange(change)
-if DoAddPersonToListEnd(change) then
-CommitChange(change)
-end
-end--}}}
-function DoAddPersonToListRandom(change)--{{{
-local list = lists[change.arg.listIndex]
-local entry = {index=change.arg.roll, id=change.arg.id}
-tinsert(list,entry)
-table.sort(list,function(a,b) return a.index < b.index end)
-list.time = change.time
-return true
 end--}}}
 function AddPersonToListRandom(name,listName)--{{{
 -- require admin
-local listIndex = GetListIndex(listName)
+local l = LootLists:Select(listName)
-if lists[listIndex].closedRandom then
+local te = PersonList:Select(name)
-print("Cannot add person to list by random roll because an add-to-end operation has already occurred")
+-- TODO: if not te ...
-return false
+printf("Adding %s (%s) to list %s - randomly!", name, te:GetId(), listName)
-end
+return l:InsertRandom(te:GetId())
-local id = personName2id[name]
-if IdIsInList(id,lists[listIndex]) then
-printf("Person %s is already on the reqeuested list",name)
-return false
-end
-local roll = math.random()
-printf("Adding %s (%s) to list %s (%s) with roll (%f)", name, id, listName, listIndex, roll)
-local change = {action="AddToListRand",arg={id=id,listIndex=listIndex,roll=roll}}
-StartChange(change)
-if DoAddPersonToListRandom(change) then
-CommitChange(change)
-end
-end--}}}
-function DoRemovePerson(change)--{{{
-local person = persons[change.arg.id]
-personName2id[person.main] = nil
-persons[change.arg.id] = nil
-persons.time = change.time
-return true
-end--}}}
-function RemovePerson(name)--{{{
-local id = personName2id[name]
-if not id then
-printf("%s is not in the persons list, please check your spelling", name)
-return false
-end
-local listsTheyreOn = {}
--- check if they're active on any loot list
-for i,v in pairs(lists) do
-if IdIsInList(id,v) then
-tinsert(listsTheyreOn,v.name)
-break
-end
-end
-if getn(listsTheyreOn) > 0 then
-printf("Cannot remove person %s because they are on one or more lists (%s)",name,table.concat(listsTheyreOn,", "))
-return false
-end
-local change = {action="RemovePerson",arg={id=id}}
-StartChange(change)
-if DoRemovePerson(change) then
-CommitChange(change)
-end
-end--}}}
-function DoSuicidePerson(change)--{{{
-local list = lists[change.arg.listIndex]
-local affected = shallowCopy(change.arg.affect)
--- the goal here is to rotate the suicide list by 1
--- then we can just mash it on top of the intersection between the original
--- list and the working copy
-local replacement = shallowCopy(change.arg.affect)
-local temp = table.remove(replacement,1) -- pop
-tinsert(replacement,temp) -- push_back
---rintf(("Before suicide of %s on list %s",slist[1],list.name)
---PrintTable(list)
-for i = 1, #list do
-if list[i].id == affected[1] then
-table.remove(affected,1)
-list[i].id = replacement[1]
-table.remove(replacement,1)
-end
-end
-list.time=change.time
-return true
 end--}}}
 function SuicidePerson(name,listName)--{{{
 -- require admin
-PopulateRaidList()
+PersonList:RefreshRaidList()
-local listIndex = GetListIndex(listName)
+local le = LootLists:Select(listName)
-local id = personName2id[name]
+local te = PersonList:Select(name)
-local affect=GetSuicideList(id,lists[listIndex])
+return le:SuicidePerson(te:GetId())
-local change = {action="SuicidePerson",arg={affect=affect,listIndex=listIndex}}
-StartChange(change)
-if DoSuicidePerson(change) then
-CommitChange(change)
-end
-end--}}}
-function DoRenameList(change)--{{{
-lists[change.arg.listIndex].name = change.arg.name
-lists[change.arg.listIndex].time = change.time
-return true
 end--}}}
 function RenameList(listName,newListName)--{{{
 -- require admin
-local listIndex = GetListIndex(listName)
+local le = LootLists:Select(listName)
-local change = {action="RenameList",arg={listIndex=listIndex,name=newListName}}
+return le:RenameList(newListName)
-StartChange(change)
-if DoRenameList(change) then
-CommitChange(change)
-end
-end--}}}
-function DoDeleteList(change)--{{{
-lists[change.arg.listIndex] = nil
-return true
 end--}}}
 function DeleteList(listName)--{{{
-local listIndex = GetListIndex(listName)
+return LootLists:DeleteList(LootLists:Select(listName):GetId())
-local change = {action="DeleteList",arg={listIndex=listIndex}}
-StartChange(change)
-if DoDeleteList(change) then
-CommitChange(change)
-end
-end--}}}
-function DoRemovePersonFromList(change)--{{{
-local list = lists[change.arg.listIndex]
-for i,v in ipairs(list) do
-if v.id == change.arg.id then
-table.remove(list,i)
-break
-end
-end
-table.sort(list,function(a,b) return a.index < b.index end)
-list.time = change.time
-return true
 end--}}}
 function RemovePersonFromList(name,listName)--{{{
-local listIndex = GetListIndex(listName)
+local le = LootLists:Select(listName)
-local pid = personName2id[name]
+local te = PersonList:Select(name)
--- todo: check that they're on the list in the first place
+return le:Remove(te:GetId())
-local change = {action="RemovePersonFromList",arg={id=pid,listIndex=listIndex}}
-StartChange(change)
-if DoRemovePersonFromList(change) then
-CommitChange(change)
-end
 end
 --}}}
+function RemovePerson(person)
+print("Removing " .. person)
+PersonList:Remove(person)
+end
+function ReservePerson(person)
+print("Reserving " .. person)
+PersonList:AddReserve(person)
+end
 --}}}
 -- Higher order actions (ie calls other standard actions){{{
 function TrimLists(time)
 if not CheckListCausality() then
 -- apply first half
 CreateWorkingStateFromChanges(before)
 -- save this state permanently; trim the changes permanently
-tcopy(db.profile.persons,persons)
+LootLists:SaveToDB(db)
-tcopy(db.profile.lists,lists)
+PersonList:SaveToDB(db)
 while db.profile.changes ~= nil and db.profile.changes[1] ~= nil and db.profile.changes[1].time <= time do
 table.remove(db.profile.changes,1)
 end
 -- using the trimmed list and the new bases, recreate the working state
 CreateWorkingStateFromChanges(db.profile.changes)
 end
-function AddMissingPersons()
-PopulateRaidList()
-local t = {}
-for id,_ in pairs(persons) do
-t[id] = true
-end
-for name,_ in pairs(raidNameP) do
-if personName2id[name] == nil then
-printf("Person %s is missing from the persons list - adding",name)
-AddPerson(name)
-end
-end
--- TODO: batch into a single op - no need to spam 25 messages in a row
-end
 function PopulateListRandom(listIndex)
 -- difference (raid+reserve)-list, then random shuffle that, then add
-PopulateRaidList()
+local actives = PersonList:GetAllActiveIds()
-local list = lists[listIndex]
+local list = LootLists:Select(listIndex)
-local t = {} -- after loops, contains intersection of IDs present between raid and reserve
+--swap keys on actives
-for i,v in pairs(raidIdP) do
+local t = {}
-if v then t[i] = true end
+for _,v in pairs(actives) do t[v] = true end
-end
-for i,v in pairs(reserveIdP) do
-if v then t[i] = true end
-end
 -- now remove from t all of the people already present on the list
-if list then
+if t then
-for i = 1,#list do
+for id in list:OrderedIdIter() do -- id iterator
-if t[list[i].id] then
+if t[id] then
-t[list[i].id] = false
+t[id] = false
 end
 end
 end
 -- add all remaining
 for i,v in pairs(t) do
 if v then
-AddPersonToListRandom(persons[i].main,list.name) -- TODO: APTLR keys off of string names. probably need to change this.
+AddPersonToListRandom(i,list:GetId())
 end
 end
 end
 function NukePerson(name) -- delete from all lists and then from persons
-local pid = personName2id[name]
+for _,id in pairs(LootLists:GetAllIds()) do
-for i,v in pairs(lists) do
+RemovePersonFromList(name,id)
-RemovePersonFromList(name,v.name)
 end
 RemovePerson(name)
 end
 --}}}
--- "Soft" actions- ie things that cause nonpermanent state {{{
--- reserves
-function AddReserve(name)
-print("Reserving" .. name)
-reserveIdP[personName2id[name]]=true
--- TODO: communicate to others. don't store this in any way.
-end
-function RemoveReserve(name)
-reserveIdP[personName2id[name]]=false
--- TODO: communicate to others. don't store this in any way.
-end
---function GetActiveList()
---    return lists[1] -- todo!
---end
---}}}
--- The following (adapted) code is from Xinhuan (wowace forum member)
--- Pre-create the unitID strings we will use
-local pID = {}
-local rID = {}
-for i = 1, 4 do
-pID[i] = sformat("party%d", i)
-end
-for i = 1, 40 do
-rID[i] = sformat("raid%d", i)
-end
-function PopulateRaidList()
-local inParty = _G.GetNumPartyMembers()
-local inRaid = _G.GetNumRaidMembers()
-local add = function(unitNameArg)
-local name = _G.UnitName(unitNameArg)
-raidNameP[name]=true
-if personName2id[name] ~= nil then
-raidIdP[personName2id[name]]=true
-end
-end
-wipe(raidNameP)
-wipe(raidIdP)
-if inRaid > 0 then
-for i = 1, inRaid do
-add(rID[i])
-end
-elseif inParty > 0 then
-for i = 1, inParty do
-add(pID[i])
-end
--- Now add yourself as the last party member
-add("player")
-else
--- You're alone
-add("player")
-end
---PrintTable(raidNameP)
-end
 -- undo rules!
 -- only the most recent event can be undone
 -- ^^^ on a given list?
 -- algorithm is easy, given "Suicide A B C"
 -- just find A,B,C in the list and replace in order from the s message
 -- while undo is allowed *per-list*, certain events in the stream will
 -- prevent proper undo, such as add/delete player or add/delete list
-function GetSuicideList(id,list)
---print("Calculating changeset for "..name.." from list -")
---PrintTable(list)
-local t = {}
-local ret = {}
-local pushing = false
-for i = 1, #list do
-if list[i].id == id then
-pushing = true
-end
-if pushing and (raidIdP[list[i].id] or reserveIdP[list[i].id]) then
-tinsert(ret,list[i].id)
-end
-end
---print("GSL")
---PrintTable(ret)
---print("GSL")
-return ret
-end
-function IdIsInList(id,listRef)
-for i = 1,#listRef do
-if id == listRef[i].id then
-return true
-end
-end
-return false
-end
 -- returns true if the events in the list are in time order
 function CheckListCausality()
 local t = nil
 for i,v in ipairs(db.profile.changes) do
 t = v.time
 end
 return true
 end
--- Support functions
-function GetListIndex(name)
-for i,v in pairs(lists) do
-if v.name == name then
-return i
-end
-end
-return nil
-end

Mercurial > wow > breuesk

comparison Lists.lua @ 49:f52d472f0b0a