wow/breuesk: Lists.lua comparison

comparison Lists.lua @ 17:71fc79846a5d

nuke db without having to exit game printouts for more things populate random is working killing bugs

author	John@Doomsday
date	Fri, 09 Mar 2012 13:26:56 -0500
parents	16b7e6390f42
children	bf3e94bc3bf5

comparison

equal deleted inserted replaced

-:16b7e6390f42
+:71fc79846a5d
 -- A separate user list is held - lists index into this
 -- TODO: rename player
 -- TODO: list trimming
--- TODO: lists allow double-add
 -- TODO: collapse slists into delimited strings for space
+-- TODO: list-of-lists must not use int indices. those will lead to peril.
+-- holy crap long notes {{{
 -- notes on list storage:
 -- Using names as keys as I do now is atrocious.
 -- It prevents insertions (twss) to the middle of the list because then it acts
 -- as a side effect onto all the others. ie ABCD -> AXBCD would be phrased as
 -- "insert X and shift down B,C,D" which sucks. BCD haven't really been affected
 --                     * if a stream contains a random-add after an add-to-end
 --                     it is declared invalid. tough tits. it's just not a fair
 --                     distribution at that point.
 --                     * actually, fuck it. I'll give them an unlock command and
 --                     let them screw over their lists :)
+--}}}
--- todo: list-of-lists must not use int indices. those will lead to peril.
+-- there are some dep chains here. for instance, to have a raidIdP value, a
+-- person must have a bsk.persons value which leads to a personName2id which
+-- leads to a raidIdP
 bsk.lists = {}
 bsk.persons = {}
 local raidNameP = {} -- "name" is present in raid
 local raidIdP = {} -- "id" is present in raid
 local tinsert = table.insert
 local sformat = string.format
 local getn = table.getn
+function bsk:SelfDestruct()
+bsk.lists = {}
+bsk.persons = {}
+bsk.db.profile.persons = {}
+bsk.db.profile.changes = {}
+bsk.db.profile.listBase = {}
+raidNameP = {}
+raidIdP = {}
+reserveIdP = {}
+personName2id = {}
+end
 function bsk:tcopy(to, from)
 for k,v in pairs(from) do
 if(type(v)=="table") then
 to[k] = {}
 bsk:tcopy(to[k], v);
 self:Print(depth .. i .. " - not sure how to print type: " .. type(v) )
 end
 end
 end
+function bsk:PrintRaidAndReserve()
+bsk:Print("RaidNameP")
+bsk:PrintTable(raidNameP)
+bsk:Print("RaidIdP")
+bsk:PrintTable(raidIdP)
+bsk:Print("ReserveP")
+bsk:PrintTable(reserveIdP)
+bsk:Print("personName2id")
+bsk:PrintTable(personName2id)
+end
 --}}}
 function bsk:UpdatePersonsReverse()
 for i,v in pairs(bsk.persons) do
 if i ~= "time" then
 end
 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
-self:Print(sformat("Namechange detected for %s - new is %s, please rename the existing entry", persons[id], name))
+self:Print(sformat("Namechange detected for %s - new is %s, please rename the existing entry", persons[id].main, name))
 return
 end
 if persons[id] ~= nil then
 self:Print(sformat("%s is already in the persons list; disregarding", name))
 return
 -- require admin
 local listIndex = bsk:GetListIndex(listName)
 local id = personName2id[name]
 if bsk:IdIsInList(id,bsk.lists[listIndex]) then
 bsk:Print(sformat("Person %s is already on the reqeuested list",name))
-return
+return false
 end
 bsk:Print(sformat("Adding %s (%s) to list %s (%s)", name, id, listName, listIndex))
 local change = {action="AddToListEnd",arg={id=id,listIndex=listIndex}}
 bsk:StartChange(change)
 if bsk:DoAddPersonToListEnd(change) then
 local listIndex = bsk:GetListIndex(listName)
 if bsk.lists[listIndex].closedRandom then
 self:Print("Cannot add person to list by random roll because an add-to-end operation has already occurred")
 return false
 end
+local id = personName2id[name]
 if bsk:IdIsInList(id,bsk.lists[listIndex]) then
 bsk:Print(sformat("Person %s is already on the reqeuested list",name))
-return
+return false
 end
-local id = personName2id[name]
 local roll = math.random()
 bsk:Print(sformat("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}}
 bsk:StartChange(change)
 if bsk:DoAddPersonToListRandom(change) then
 local list = bsk.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
 --bsk:Print(sformat("Before suicide of %s on list %s",slist[1],list.name))
 --bsk:PrintTable(list)
 for i = 1, #list do
-if list[i].id == affect[1] then
+if list[i].id == affected[1] then
-table.remove(affect,1)
+table.remove(affected,1)
 list[i].id = replacement[1]
 table.remove(replacement,1)
 end
 end
 list.time=change.time
 return true
 end
-function bsk:SuicidePerson(name,list)
+function bsk:SuicidePerson(name,listName)
 -- require admin
 bsk:PopulateRaidList()
 local listIndex = bsk:GetListIndex(listName)
 local id = personName2id[name]
 local affect=bsk:GetSuicideList(id,bsk.lists[listIndex])
 local change = {action="SuicidePerson",arg={affect=affect,listIndex=listIndex}}
-bsk:PrintTable(change)
 bsk:StartChange(change)
 if bsk:DoSuicidePerson(change) then
 bsk:CommitChange(change)
 end
 end
 function bsk:TrimLists(time)
 if not bsk:CheckListCausality() then
 self:Print("Unable to trim lists due to violated causality")
 return false
 end
 if type(time) ~= "number" then
 time = tonumber(time)
 -- using the trimmed list and the new bases, recreate the working state
 bsk:CreateWorkingStateFromChanges(bsk.db.profile.changes)
 end
 --}}}
--- Higher order actions (ie calls other Doers){{{
+-- Higher order actions (ie calls other standard actions){{{
 function bsk:AddMissingPersons()
 bsk:PopulateRaidList()
 local t = {}
-for i,_ in pairs(bsk.persons) do
+for id,_ in pairs(bsk.persons) do
-t[i] = true
+t[id] = true
 end
-for i,_ in pairs(raidNameP) do
+for name,_ in pairs(raidNameP) do
-if t[i] == nil then
+if personName2id[name] == nil then
-bsk:Print(sformat("Person %s is missing from the persons list - adding",i))
+bsk:Print(sformat("Person %s is missing from the persons list - adding",name))
-bsk:AddPerson(i)
+bsk:AddPerson(name)
 end
 end
 -- TODO: batch into a single op - no need to spam 25 messages in a row
 end
-function bsk:PopulateListRandom(index)
+function bsk:PopulateListRandom(listIndex)
--- difference (raid+reserve)^list, then random shuffle that, then add
+-- difference (raid+reserve)-list, then random shuffle that, then add
 bsk:PopulateRaidList()
-local list = bsk.lists[index]
+local list = bsk.lists[listIndex]
-local t = {}
+local t = {} -- after loops, contains intersection of IDs present between raid and reserve
---for i = 1,#list do
+for i,v in pairs(raidIdP) do
---    if not (raidNameP(list[i]) or reserveIdP(list[i])) then
+if v then t[i] = true end
---        tinsert(t,)
+end
---    end
+for i,v in pairs(reserveIdP) do
---end
+if v then t[i] = true end
+end
+-- now remove from t all of the people already present on the list
+for i = 1,#list do
+if t[list[i].id] then
+t[list[i].id] = false
+end
+end
+-- add all remaining
+for i,v in pairs(t) do
+if v then
+bsk:AddPersonToListRandom(bsk.persons[i].main,list.name) -- TODO: APTLR keys off of string names. probably need to change this.
+end
+end
 end
 --}}}
 -- "Soft" actions- ie things that cause nonpermanent state {{{
 -- reserves
 --    return bsk.lists[1] -- todo!
 --end
 --}}}
--- The following code is from Xinhuan (wowace forum member)
+-- 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] = format("party%d", i)
 rID[i] = format("raid%d", i)
 end
 function bsk:PopulateRaidList()
 local inParty = GetNumPartyMembers()
 local inRaid = GetNumRaidMembers()
-local add = function(name) raidNameP[name]=true; if personName2id[id] == nil then  end end
+local add = function(unitNameArg)
+local name = 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
-local name = UnitName(rID[i])
+add(rID[i])
-raidNameP[name]=true
-raidIdP[personName2id[name]]=true
 end
 elseif inParty > 0 then
 for i = 1, inParty do
-local name = UnitName(pID[i])
+add(pID[i])
-raidNameP[name]=true
-raidIdP[personName2id[name]]=true
 end
 -- Now add yourself as the last party member
-local name = UnitName("player")
+add("player")
-raidNameP[name]=true
-raidIdP[personName2id[name]]=true
 else
 -- You're alone
-local name = UnitName("player")
+add("player")
-raidNameP[name]=true
+end
-raidIdP[personName2id[name]]=true
+bsk:PrintTable(raidNameP)
-end
 end
 -- undo rules!
 -- only the most recent event can be undone
 -- ^^^ on a given list?
 for i,v in pairs(bsk.lists) do
 if v.name == name then
 return i
 end
 end
-assert(false)
+return nil
 end
 local shuffleArray = function(array)
 local arrayCount = #array
 for i = arrayCount, 2, -1 do

Mercurial > wow > breuesk

comparison Lists.lua @ 17:71fc79846a5d