Blooncyclopedia

Module:BATTD costs: Difference between revisions

← Older edit
Polavux (talk | contribs)
Bureaucrats, Interface administrators, Administrators
60,678 edits
mNo edit summary
mNo edit summary
 
(16 intermediate revisions by the same user not shown)
Line 1: Line 1:
local p = {}
local p = {}


-- LOCAL FUNCTIONS
-- helper functions


local function GetTotalCosts(baseCost, initialPurchasedUpgrades, accessibleUpgrades, upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
local function GetTotalCosts(baseCost, initialPurchasedUpgrades, accessibleUpgrades, startingUpgrade,
upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
local sFormat = string.format
local sFormat = string.format
local tConcat = table.concat
local tConcat = table.concat
local sGsub = string.gsub
local sGsub = string.gsub
-- create the table headers
local headerRow = {"{|class=\"wikitable sortable\" style=\"text-align:center\"\n!Total cost!!Sell value"}
local headerRow = {"{|class=\"wikitable sortable\" style=\"text-align:center\"\n!Total cost!!Sell value"}
Line 29: Line 31:
end
end
local function GetPurchasedAndAvailableUpgrades(purchasedUpgrades, availableUpgradeId)
local function RecursiveGetTotalCosts(currentCost, purchasedUpgrades, myUpgradeId)
-- skip this upgrade if we don't have all the prereqs
-- skip this upgrade if we don't have all the prereqs
if upgradePrereqsById[availableUpgradeId] then
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
for _, prereqId in ipairs(upgradePrereqsById[availableUpgradeId]) do
if not purchasedUpgrades[prereqId] then return false end
if prereqId ~= "root" and not purchasedUpgrades[prereqId] then
end
return nil, nil
end
-- skip this upgrade if it's locked by an already purchased upgrade
end
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
if upgradeLocksById[purchasedUpgradeId][myUpgradeId] then return false end
end
end
-- shallow copy purchasedUpgrades and availableUpgrades
--upgradeLocksById[startingUpgrade][myUpgradeId] = true
local purchasedUpgradesNext = {}
local availableUpgradesNext = {}
-- shallow copy purchasedUpgrades but with this upgrade included in it now
local purchasedUpgradesNext = { [myUpgradeId] = true }
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
if upgradeLocksById[purchasedUpgradeId] and upgradeLocksById[purchasedUpgradeId][availableUpgradeId] then
return nil, nil
end
purchasedUpgradesNext[purchasedUpgradeId] = true
purchasedUpgradesNext[purchasedUpgradeId] = true
for _, nextUpgradeId in ipairs(upgradePrereqsOfById[purchasedUpgradeId]) do
if not purchasedUpgrades[nextUpgradeId] then availableUpgradesNext[nextUpgradeId] = true end
end
end
end
purchasedUpgradesNext[availableUpgradeId] = true
-- add row to output
row = {sFormat("|-\n|$%s||$%s", FormatNum(currentCost), FormatNum(currentCost*0.7))}
return purchasedUpgradesNext, availableUpgradesNext
end
local function RecursiveGetTotalCosts(currentCost, purchasedUpgrades, availableUpgrades)
row = {sFormat("\n|-\n|$%s||$%s", FormatNum(currentCost), FormatNum(currentCost*0.7))}
mw.logObject(purchasedUpgrades)
for accessibleUpgradeId, _ in pairs(accessibleUpgrades) do
mw.logObject(availableUpgrades)
row[#row+1] = sFormat("||%s", purchasedUpgradesNext[accessibleUpgradeId] and Y or N)
for upgradeId, _ in pairs(accessibleUpgrades) do
row[#row+1] = sFormat("||%s", purchasedUpgrades[upgradeId] and Y or N)
end
end
outputTable[#outputTable+1] = tConcat(row, "")
outputTable[#outputTable+1] = tConcat(row, "")
for availableUpgradeId, _ in pairs(availableUpgrades) do
-- depth first
if upgradePrereqsOfById[availableUpgradeId] then
for _, prereqOfId in ipairs(upgradePrereqsOfById[myUpgradeId]) do
local purchasedUpgradesNext, availableUpgradesNext = GetPurchasedAndAvailableUpgrades(purchasedUpgrades, availableUpgradeId)
RecursiveGetTotalCosts(currentCost + upgradesById[prereqOfId].cost, purchasedUpgradesNext, prereqOfId)
end
if purchasedUpgradesNext and availableUpgradesNext then
purchasedUpgradesNext[availableUpgradeId] = true
if #outputTable == 10 then return end
-- breadth next
RecursiveGetTotalCosts(currentCost + upgradesById[availableUpgradeId].cost, purchasedUpgradesNext, availableUpgradesNext)
for purchasedUpgradeId, _ in pairs(purchasedUpgrades) do
end
for _, prereqOfId in ipairs(upgradePrereqsOfById[purchasedUpgradeId]) do
--RecursiveGetTotalCosts(currentCost + upgradesById[prereqOfId].cost, purchasedUpgradesNext, prereqOfId)
end
end
end
end
return true
end
end
local rootUpgrades = {}
RecursiveGetTotalCosts(baseCost, initialPurchasedUpgrades, startingUpgrade)
for _, upgradeId in ipairs(upgradePrereqsOfById.root) do
if not initialPurchasedUpgrades[upgradeId] then rootUpgrades[upgradeId] = true end
end
RecursiveGetTotalCosts(baseCost, initialPurchasedUpgrades, rootUpgrades)
outputTable[#outputTable+1] = "\n|}"
outputTable[#outputTable+1] = "|}"
return tConcat(outputTable, "")
return tConcat(outputTable, "\n")
end
end


local function Upgrade(towerName, upgradeName, Y, N)
local function SetUpTables(towerName)
local sFormat = string.format
local sFormat = string.format
local query = mw.ext.cargo.query
local query = mw.ext.cargo.query
local outputTable = {}
local upgradesById = { root = {} } -- key:value table  - upgrade:upgrade data
local upgradeId = ""
local upgradeLocksById = { root = {} } -- key:values table - upgrades:upgrades that this upgrade locks
local upgradePrereqsById = { root = {} } -- key:values table - upgrade:prerequisites to purchase this upgrade
local upgradePrereqsOfById = { root = {} } -- key:values table - upgrades:upgrades this is a prerequisite of
local upgradesById = {} -- key:value table  - upgrade:upgrade data
-- tower cost + total cost of this upgrade and all its prereqs
local upgradeLocksById = {} -- key:values table - upgrades:upgrades that this upgrade locks
local baseCost = tonumber(query("battd_characters", "cost", {
local upgradePrereqsById = {} -- key:values table - upgrade:prerequisites to purchase this upgrade
where=sFormat("name='%s'", towerName)
local upgradePrereqsOfById = { -- key:values table - upgrades:upgrades this is a prerequisite of
})[1].cost)
root = {}
}
local purchasedUpgrades = {}
local accessibleUpgrades = {} -- list of upgrades that we can get from this upgrade
-- cargo queries for data
-- cargo queries for data
Line 132: 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] = {}
end
end


Line 145: Line 127:
end
end
else
else
-- if this upgrade is a root upgrade
-- if this upgrade has no prereqs, give it a fake upgrade called "root" as a prereq
upgradePrereqsOfById["root"][#upgradePrereqsOfById["root"]+1] = upgrade.thisId
upgradePrereqsOfById["root"][#upgradePrereqsOfById["root"]+1] = upgrade.thisId
upgradePrereqsById[upgrade.thisId] = {"root"}
upgradePrereqsById[upgrade.thisId] = {"root"}
Line 159: Line 141:


-- build upgradeLocksById
-- build upgradeLocksById
for i, upgrade in ipairs(upgradeLocks) do
for _, upgrade in ipairs(upgradeLocks) do
if upgrade.lockId then
if upgrade.lockId then
if upgradeLocksById[upgrade.thisId] then
upgradeLocksById[upgrade.thisId][upgrade.lockId] = true
upgradeLocksById[upgrade.thisId][upgrade.lockId] = true
else
upgradeLocksById[upgrade.thisId] = {[upgrade.lockId] = true}
end
end
end
end
end
return upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost
end
local function Upgrade(towerName, upgradeId, Y, N)
local upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost = SetUpTables(towerName)
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 by some route
-- build purchasedUpgrades
-- build purchasedUpgrades recursively
local function GetPurchasedUpgrades(myUpgradeId)
local function GetPurchasedUpgrades(myUpgradeId)
local cost = 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 cost = cost + GetPurchasedUpgrades(prereqId) end
if prereqId ~= "root" then GetPurchasedUpgrades(prereqId) end
purchasedUpgrades[prereqId] = true
end
end
return cost
end
end
-- tower cost + total cost of this upgrade and all its prereqs
GetPurchasedUpgrades(upgradeId)
local baseCost = GetPurchasedUpgrades(upgradeId) + query("battd_characters", "cost", {
where=sFormat("name='%s'", towerName)
})[1].cost
local function GetAccessibleUpgrades(myUpgradeId)
-- generate a list of upgrades that are reachable from this upgrade, but do not have this upgrade as a prerequisite
for _, upgrade in ipairs(upgradePrereqsOfById[myUpgradeId]) do
-- also generate a list of upgrades that are immediately reachable from this upgrade
if not purchasedUpgrades[upgrade] then
local function DetermineAccessibility(myUpgradeId)
-- ignore locked upgrades
if myUpgradeId == upgradeId then return end
if upgradeLocksById[upgrade] then
for _, upgradeLock in ipairs(upgradeLocksById[upgrade]) do
-- if this upgrade is locked by an already purchased upgrade, then it is inaccessible
if purchasedUpgrades[upgradeLock] then return end
for _, upgradeLock in ipairs(upgradeLocksById[myUpgradeId]) do
end
if purchasedUpgrades[upgradeLock] then return end
end
end
-- upgrades with multiple prereqs are only accessible if we can reach all prereqs
-- find upgrades that are reachable from the current upgrades owned
for _, prereqId in ipairs(upgradePrereqsById[upgrade]) do
for _, prereqId in ipairs(upgradePrereqsById[myUpgradeId]) do
if not accessibleUpgrades[prereqId] and prereqId ~= "root" then return end
-- upgrades with multiple prereqs are only accessible if we can reach all its prereqs
end
-- 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
accessibleUpgrades[upgrade] = true
end
if upgradePrereqsOfById[upgrade] then GetAccessibleUpgrades(upgrade) end
if not purchasedUpgrades[myUpgradeId] then accessibleUpgrades[myUpgradeId] = true end
-- determine accessibility of next upgrades
if upgradePrereqsOfById[myUpgradeId] then  
for _, prereqOfId in ipairs(upgradePrereqsOfById[myUpgradeId]) do
DetermineAccessibility(prereqOfId)
end
end
end
end
end
-- start with the root
for _, prereqOfId in ipairs(upgradePrereqsOfById.root) do
DetermineAccessibility(prereqOfId)
end
end
GetAccessibleUpgrades("root")
return GetTotalCosts(baseCost, purchasedUpgrades, accessibleUpgrades, upgradeId,
return GetTotalCosts(baseCost, purchasedUpgrades, accessibleUpgrades, upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, Y, N)
end
end


Line 213: Line 207:


p["tower"] = function(frame)
p["tower"] = function(frame)
return ""
local upgradesById, upgradeLocksById, upgradePrereqsById, upgradePrereqsOfById, baseCost = SetUpTables(frame.args[1])
end
end


p["upgrade"] = function(frame)
p["upgrade"] = function(frame)
--return upgrade(frame.args[1], frame.args[2], frame:expandTemplate{title = "Y", args = {}}, frame:expandTemplate{title = "N", args = {}})
return Upgrade(frame.args[1], frame.args[2], frame:expandTemplate{title = "Y", args = {}}, frame:expandTemplate{title = "N", args = {}})
return Upgrade(frame.args[1], frame.args[2], "Y", "N")
--return Upgrade(frame.args[1], frame.args[2], "Y", "N")
end
end


return p
return p
Retrieved from "https://www.bloonswiki.com/Module:BATTD_costs"