Blooncyclopedia

Module:BATTD costs: Difference between revisions

← Older edit
Polavux (talk | contribs)
Bureaucrats, Interface administrators, Administrators
60,677 edits
No edit summary
mNo edit summary
 
(5 intermediate revisions by the same user not shown)
Line 3: Line 3:
-- helper functions
-- helper functions


local function GetTotalCosts(baseCost, initialPurchasedUpgrades, accessibleUpgrades, nextUpgrades,
local function GetTotalCosts(baseCost, initialPurchasedUpgrades, accessibleUpgrades, startingUpgrade,
upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
local sFormat = string.format
local sFormat = string.format
Line 31: Line 31:
end
end
local function IsUpgradeAvailable(myUpgradeId, purchasedUpgrades)
local function RecursiveGetTotalCosts(currentCost, purchasedUpgrades, myUpgradeId)
-- skip this upgrade if we don't have all the prereqs
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
if not (prereqId == "root" or purchasedUpgrades[prereqId]) then return false end
if not purchasedUpgrades[prereqId] then return false end
end
for _, upgradeLock in ipairs(upgradeLocksById[myUpgradeId]) do
if purchasedUpgrades[upgradeLock] then return false end
end
return not purchasedUpgrades[myUpgradeId]
end
local function GetPurchasedAndAvailableUpgrades(purchasedUpgrades, availableUpgradeId)
-- skip this upgrade if we don't have all the prereqs
for _, prereqId in ipairs(upgradePrereqsById[availableUpgradeId]) do
if not (prereqId == "root" or purchasedUpgrades[prereqId]) then return nil, nil end
end
end
-- skip this upgrade if it's locked by an already purchased upgrade
-- skip this upgrade if it's locked by an already purchased upgrade
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
if upgradeLocksById[purchasedUpgradeId][availableUpgradeId] then return nil, nil end
if upgradeLocksById[purchasedUpgradeId][myUpgradeId] then return false end
end
end
--upgradeLocksById[startingUpgrade][myUpgradeId] = true
-- shallow copy purchasedUpgrades but with this upgrade included in it now
-- shallow copy purchasedUpgrades but with this upgrade included in it now
local purchasedUpgradesNext = { [availableUpgradeId] = true }
local purchasedUpgradesNext = { [myUpgradeId] = true }
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
purchasedUpgradesNext[purchasedUpgradeId] = true
purchasedUpgradesNext[purchasedUpgradeId] = true
-- lock this upgrade combination so we never retread this ground again
if not initialPurchasedUpgrades[purchasedUpgradeId] then
upgradeLocksById[purchasedUpgradeId][availableUpgradeId] = true
upgradeLocksById[availableUpgradeId][purchasedUpgradeId] = true
end
end
end
-- determine new availableUpgrades
-- add row to output
local availableUpgradesNext = {}
row = {sFormat("|-\n|$%s||$%s", FormatNum(currentCost), FormatNum(currentCost*0.7))}
for accessibleUpgradeId, _ in pairs(accessibleUpgrades) do
for accessibleUpgradeId, _ in pairs(accessibleUpgrades) do
if IsUpgradeAvailable(accessibleUpgradeId, purchasedUpgradesNext) then availableUpgradesNext[accessibleUpgradeId] = true end
row[#row+1] = sFormat("||%s", purchasedUpgradesNext[accessibleUpgradeId] and Y or N)
end
end
return purchasedUpgradesNext, availableUpgradesNext
outputTable[#outputTable+1] = tConcat(row, "")
end
local function RecursiveGetTotalCosts(currentCost, purchasedUpgrades, availableUpgrades)
row = {sFormat("\n|-\n|$%s||$%s", FormatNum(currentCost), FormatNum(currentCost*0.7))}
mw.logObject(purchasedUpgrades)
mw.logObject(availableUpgrades)
for upgradeId, _ in pairs(accessibleUpgrades) do
-- depth first
row[#row+1] = sFormat("||%s", purchasedUpgrades[upgradeId] and Y or N)
for _, prereqOfId in ipairs(upgradePrereqsOfById[myUpgradeId]) do
RecursiveGetTotalCosts(currentCost + upgradesById[prereqOfId].cost, purchasedUpgradesNext, prereqOfId)
end
end
outputTable[#outputTable+1] = tConcat(row, "")
-- breadth next
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
for availableUpgradeId, _ in pairs(availableUpgrades) do
for _, prereqOfId in ipairs(upgradePrereqsOfById[purchasedUpgradeId]) do
local purchasedUpgradesNext, availableUpgradesNext = GetPurchasedAndAvailableUpgrades(purchasedUpgrades, availableUpgradeId)
--RecursiveGetTotalCosts(currentCost + upgradesById[prereqOfId].cost, purchasedUpgradesNext, prereqOfId)
if purchasedUpgradesNext and availableUpgradesNext then
--if #outputTable == 20 then return end
RecursiveGetTotalCosts(currentCost + upgradesById[availableUpgradeId].cost, purchasedUpgradesNext, availableUpgradesNext)
end
end
end
end
return true
end
end
RecursiveGetTotalCosts(baseCost, initialPurchasedUpgrades, nextUpgrades)
RecursiveGetTotalCosts(baseCost, initialPurchasedUpgrades, startingUpgrade)
outputTable[#outputTable+1] = "\n|}"
outputTable[#outputTable+1] = "|}"
return tConcat(outputTable, "")
return tConcat(outputTable, "\n")
end
end


Line 111: Line 86:
local query = mw.ext.cargo.query
local query = mw.ext.cargo.query
local upgradesById = {} -- key:value table  - upgrade:upgrade data
local upgradesById = { root = {} } -- key:value table  - upgrade:upgrade data
local upgradeLocksById = {} -- key:values table - upgrades:upgrades that this upgrade locks
local upgradeLocksById = { root = {} } -- key:values table - upgrades:upgrades that this upgrade locks
local upgradePrereqsById = {} -- key:values table - upgrade:prerequisites to purchase this upgrade
local upgradePrereqsById = { root = {} } -- key:values table - upgrade:prerequisites to purchase this upgrade
local upgradePrereqsOfById = { -- key:values table - upgrades:upgrades this is a prerequisite of
local upgradePrereqsOfById = { root = {} } -- key:values table - upgrades:upgrades this is a prerequisite of
root = {}
}
-- tower cost + total cost of this upgrade and all its prereqs
local baseCost = tonumber(query("battd_characters", "cost", {
where=sFormat("name='%s'", towerName)
})[1].cost)
-- cargo queries for data
-- cargo queries for data
Line 136: Line 114:
for i, upgrade in ipairs(upgrades) do
for i, upgrade in ipairs(upgrades) do
upgradesById[upgrade.id] = upgrade
upgradesById[upgrade.id] = upgrade
if upgrade.name == upgradeName then upgradeId = upgrade.id end
upgradeLocksById[upgrade.id] = {}
upgradeLocksById[upgrade.id] = {}
end
end
Line 170: Line 146:
end
end
end
end
-- tower cost + total cost of this upgrade and all its prereqs
local baseCost = tonumber(query("battd_characters", "cost", {
where=sFormat("name='%s'", towerName)
})[1].cost)


return upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost
return upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost
end
end


local function Upgrade(towerName, upgradeName, Y, N)
local function Upgrade(towerName, upgradeId, Y, N)
local upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost = SetUpTables(towerName)
local upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost = SetUpTables(towerName)
local upgradeId = ""
local purchasedUpgrades = {} -- this upgrade and any other upgrades that had to already be purchased to get it
local purchasedUpgrades = {} -- this upgrade and any other upgrades that had to already be purchased to get it
local accessibleUpgrades = {} -- list of upgrades that are possible to reach from this upgrade
local accessibleUpgrades = {} -- list of upgrades that are possible to reach from this upgrade by some route
local nextUpgrades = {} -- list of upgrades that are currently purchasable from this upgrade
-- build purchasedUpgrades recursively
-- build purchasedUpgrades recursively
local function GetPurchasedUpgrades(myUpgradeId)
local function GetPurchasedUpgrades(myUpgradeId)
baseCost = baseCost + upgradesById[myUpgradeId].cost
if not purchasedUpgrades[myUpgradeId] then baseCost = baseCost + upgradesById[myUpgradeId].cost end
purchasedUpgrades[myUpgradeId] = true
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
if prereqId ~= "root" then GetPurchasedUpgrades(myUpgradeId) end
if prereqId ~= "root" then GetPurchasedUpgrades(prereqId) end
purchasedUpgrades[prereqId] = true
end
end
end
end
GetPurchasedUpgrades(upgradeId)
-- generate a list of upgrades that are reachable from this upgrade, but do not have this upgrade as a prerequisite
-- generate a list of upgrades that are reachable from this upgrade, but do not have this upgrade as a prerequisite
Line 209: Line 179:
-- find upgrades that are reachable from the current upgrades owned
-- find upgrades that are reachable from the current upgrades owned
local isNextUpgrade = true
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
-- upgrades with multiple prereqs are only accessible if we can reach all its prereqs
-- upgrades with multiple prereqs are only accessible if we can reach all its prereqs
-- if it is accessible, it'll be reached again on another recursion
-- if it is accessible, it'll be reached again on another recursion
if not (accessibleUpgrades[prereqId] or purchasedUpgrades[prereqId] or prereqId == "root") or prereqId == upgradeId then return end
if not (accessibleUpgrades[prereqId] or purchasedUpgrades[prereqId] or prereqId == "root") or prereqId == upgradeId then return end
if not (purchasedUpgrades[prereqId] or prereqId == "root") or purchasedUpgrades[myUpgradeId] then isNextUpgrade = nil end
end
end
nextUpgrades[myUpgradeId] = isNextUpgrade
if not purchasedUpgrades[myUpgradeId] then accessibleUpgrades[myUpgradeId] = true end
if not purchasedUpgrades[myUpgradeId] then accessibleUpgrades[myUpgradeId] = true end
Line 234: Line 200:
end
end
return GetTotalCosts(baseCost, purchasedUpgrades, accessibleUpgrades, nextUpgrades,
return GetTotalCosts(baseCost, purchasedUpgrades, accessibleUpgrades, upgradeId,
upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
end
end
Retrieved from "https://www.bloonswiki.com/Module:BATTD_costs"