mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-24 03:47:58 +02:00
29b3a89b33
Fixed issue with determining if market is placeable Allow entities to be placed within the initial town square Fixed info to remove reference to small plane Fixed issue with no messages when can't place item due to building restrictions Fixed issue with inability to place new towns near enemy spawners or turrets Fixed issue with market listings breaking when special features disabled due to deprecation of computer item Fixed issue with mining sound missing for big-crash-site-# entities (in mod) Default to showing entity info for players (alt-info on chests)
296 lines
13 KiB
Lua
296 lines
13 KiB
Lua
local table_insert = table.insert
|
|
|
|
local Table = require 'modules.scrap_towny_ffa.table'
|
|
local Town_center = require 'modules.scrap_towny_ffa.town_center'
|
|
|
|
local upgrade_functions = {
|
|
-- Upgrade Town Center Health
|
|
[1] = function(town_center, player)
|
|
local market = town_center.market
|
|
local surface = market.surface
|
|
if town_center.max_health > 500000 then return end
|
|
town_center.health = town_center.health + town_center.max_health
|
|
town_center.max_health = town_center.max_health * 2
|
|
Town_center.set_market_health(market, 0)
|
|
surface.play_sound({ path = "utility/achievement_unlocked", position = player.position, volume_modifier = 1 })
|
|
end,
|
|
-- Upgrade Backpack
|
|
[2] = function(town_center, player)
|
|
local market = town_center.market
|
|
local force = market.force
|
|
local surface = market.surface
|
|
if force.character_inventory_slots_bonus > 100 then return end
|
|
force.character_inventory_slots_bonus = force.character_inventory_slots_bonus + 5
|
|
surface.play_sound({ path = "utility/achievement_unlocked", position = player.position, volume_modifier = 1 })
|
|
end,
|
|
-- Upgrade Mining Productivity
|
|
[3] = function(town_center, player)
|
|
local market = town_center.market
|
|
local force = market.force
|
|
local surface = market.surface
|
|
if town_center.upgrades.mining_prod >= 10 then return end
|
|
town_center.upgrades.mining_prod = town_center.upgrades.mining_prod + 1
|
|
force.mining_drill_productivity_bonus = force.mining_drill_productivity_bonus + 0.1
|
|
surface.play_sound({ path = "utility/achievement_unlocked", position = player.position, volume_modifier = 1 })
|
|
end,
|
|
-- Laser Turret Slot
|
|
[4] = function(town_center, player)
|
|
local market = town_center.market
|
|
local surface = market.surface
|
|
town_center.upgrades.laser_turret.slots = town_center.upgrades.laser_turret.slots + 1
|
|
surface.play_sound({ path = "utility/new_objective", position = player.position, volume_modifier = 1 })
|
|
end,
|
|
-- Set Spawn Point
|
|
[5] = function(town_center, player)
|
|
local ffatable = Table.get_table()
|
|
local market = town_center.market
|
|
local force = market.force
|
|
local surface = market.surface
|
|
local spawn_point = force.get_spawn_position(surface)
|
|
ffatable.spawn_point[player.name] = spawn_point
|
|
surface.play_sound({ path = "utility/scenario_message", position = player.position, volume_modifier = 1 })
|
|
end,
|
|
}
|
|
|
|
local function clear_offers(market)
|
|
for _ = 1, 256, 1 do
|
|
local a = market.remove_market_item(1)
|
|
if a == false then return end
|
|
end
|
|
end
|
|
|
|
local function set_offers(town_center)
|
|
local market = town_center.market
|
|
local force = market.force
|
|
|
|
local special_offers = {}
|
|
|
|
if town_center.max_health < 500000 then
|
|
special_offers[1] = { { { "coin", town_center.max_health * 0.1 } }, "Upgrade Town Center Health" }
|
|
else
|
|
special_offers[1] = { { { "coin", 1 } }, "Maximum Health upgrades reached!" }
|
|
end
|
|
if force.character_inventory_slots_bonus <= 100 then
|
|
special_offers[2] = { { { "coin", (force.character_inventory_slots_bonus / 5 + 1) * 50 } }, "Upgrade Backpack +5 Slot" }
|
|
else
|
|
special_offers[2] = { { { "coin", 1 } }, "Maximum Backpack upgrades reached!" }
|
|
end
|
|
if town_center.upgrades.mining_prod < 10 then
|
|
special_offers[3] = { { { "coin", (town_center.upgrades.mining_prod + 1) * 400 } }, "Upgrade Mining Productivity +10%" }
|
|
else
|
|
special_offers[3] = { { { "coin", 1 } }, "Maximum Mining upgrades reached!" }
|
|
end
|
|
local laser_turret = "Laser Turret Slot [#" .. tostring(town_center.upgrades.laser_turret.slots + 1) .. "]"
|
|
special_offers[4] = { { { "coin", 1000 + (town_center.upgrades.laser_turret.slots * 50) } }, laser_turret }
|
|
local spawn_point = "Set Spawn Point"
|
|
special_offers[5] = { { { "coin", 1 } }, spawn_point }
|
|
|
|
local market_items = {}
|
|
|
|
for _, v in pairs(special_offers) do
|
|
table_insert(market_items, { price = v[1], offer = { type = 'nothing', effect_description = v[2] } })
|
|
end
|
|
|
|
-- coin purchases
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'raw-fish', count = 1 } })
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'wood', count = 6 } })
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'iron-ore', count = 6 } })
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'copper-ore', count = 6 } })
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'stone', count = 6 } })
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'coal', count = 6 } })
|
|
table_insert(market_items, { price = { { 'coin', 1 } }, offer = { type = 'give-item', item = 'uranium-ore', count = 4 } })
|
|
table_insert(market_items, { price = { { 'coin', 300 } }, offer = { type = 'give-item', item = 'loader', count = 1 } })
|
|
table_insert(market_items, { price = { { 'coin', 600 } }, offer = { type = 'give-item', item = 'fast-loader', count = 1 } })
|
|
table_insert(market_items, { price = { { 'coin', 900 } }, offer = { type = 'give-item', item = 'express-loader', count = 1 } })
|
|
-- scrap selling
|
|
table_insert(market_items, { price = { { 'wood', 7 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'iron-ore', 7 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'copper-ore', 7 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'stone', 7 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'coal', 7 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'uranium-ore', 5 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'copper-cable', 12 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'iron-gear-wheel', 3 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'iron-stick', 12 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
table_insert(market_items, { price = { { 'empty-barrel', 1 } }, offer = { type = 'give-item', item = 'coin', count = 1 } })
|
|
|
|
for _, item in pairs(market_items) do
|
|
market.add_market_item(item)
|
|
end
|
|
end
|
|
|
|
local function refresh_offers(event)
|
|
local ffatable = Table.get_table()
|
|
local market = event.entity or event.market
|
|
if not market then return end
|
|
if not market.valid then return end
|
|
if market.name ~= "market" then return end
|
|
local town_center = ffatable.town_centers[market.force.name]
|
|
if not town_center then return end
|
|
clear_offers(market)
|
|
set_offers(town_center)
|
|
end
|
|
|
|
local function offer_purchased(event)
|
|
local ffatable = Table.get_table()
|
|
local player = game.players[event.player_index]
|
|
local market = event.market
|
|
local offer_index = event.offer_index
|
|
local count = event.count
|
|
if not upgrade_functions[offer_index] then return end
|
|
|
|
local town_center = ffatable.town_centers[market.force.name]
|
|
if not town_center then return end
|
|
|
|
upgrade_functions[offer_index](town_center, player)
|
|
|
|
if count > 1 then
|
|
local offers = market.get_market_items()
|
|
local price = offers[offer_index].price[1].amount
|
|
player.insert({ name = "coin", count = price * (count - 1) })
|
|
end
|
|
end
|
|
|
|
local function on_gui_opened(event)
|
|
local gui_type = event.gui_type
|
|
if gui_type ~= defines.gui_type.entity then return end
|
|
local entity = event.entity
|
|
if entity == nil or not entity.valid then return end
|
|
if entity.type == "market" then refresh_offers(event) end
|
|
end
|
|
|
|
local function on_market_item_purchased(event)
|
|
offer_purchased(event)
|
|
refresh_offers(event)
|
|
end
|
|
|
|
local function inside(pos, area)
|
|
return pos.x >= area.left_top.x and pos.x <= area.right_bottom.x and pos.y >= area.left_top.y and pos.y <= area.right_bottom.y
|
|
end
|
|
|
|
local function on_tick(_)
|
|
local ffatable = Table.get_table()
|
|
if not ffatable.town_centers then return end
|
|
local items = { "burner-inserter", "inserter", "long-handed-inserter", "fast-inserter",
|
|
"filter-inserter", "stack-inserter", "stack-filter-inserter",
|
|
"loader", "fast-loader", "express-loader" }
|
|
for _, town_center in pairs(ffatable.town_centers) do
|
|
local market = town_center.market
|
|
local offers = market.get_market_items()
|
|
if offers == nil then set_offers(town_center) end
|
|
local s = market.surface
|
|
local force = market.force
|
|
-- get the bounding box for the market
|
|
local bb = market.bounding_box
|
|
local area = { left_top = { bb.left_top.x - 2, bb.left_top.y - 2 }, right_bottom = { bb.right_bottom.x + 2, bb.right_bottom.y + 2 } }
|
|
local entities = s.find_entities_filtered({ area = area, name = items })
|
|
for _, e in pairs(entities) do
|
|
if e.name ~= "loader" and e.name ~= "fast-loader" and e.name ~= "express-loader" then
|
|
local ppos = e.pickup_position
|
|
local dpos = e.drop_position
|
|
-- pulling an item from the market
|
|
if inside(ppos, bb) and e.drop_target then
|
|
local stack = e.held_stack
|
|
local spos = e.held_stack_position
|
|
if inside(spos, bb) then
|
|
local filter
|
|
local filter_mode = e.inserter_filter_mode
|
|
if filter_mode ~= nil then
|
|
for i = 1, e.filter_slot_count do
|
|
if e.get_filter(i) ~= nil then
|
|
filter = e.get_filter(i)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if (filter_mode == "whitelist" and filter == "coin") or (filter_mode == "blacklist" and filter == nil) or (filter_mode == nil) then
|
|
if stack.valid and town_center.coin_balance > 0 then
|
|
-- pull coins
|
|
stack.set_stack({ name = "coin", count = 1 })
|
|
town_center.coin_balance = town_center.coin_balance - 1
|
|
Town_center.update_coin_balance(force)
|
|
end
|
|
else
|
|
if filter_mode == "whitelist" and filter ~= nil and stack.valid then
|
|
-- purchased and pull items if output buffer is empty
|
|
-- buffer the output in a item buffer since the stack might be too small
|
|
-- output items are shared among the output
|
|
for _, trade in ipairs(offers) do
|
|
local type = trade.offer.type
|
|
local item = trade.offer.item
|
|
local count = trade.offer.count or 1
|
|
local cost = trade.price[1].amount
|
|
if type == "give-item" and item == filter then
|
|
if town_center.output_buffer[item] == nil then town_center.output_buffer[item] = 0 end
|
|
if town_center.output_buffer[item] == 0 then
|
|
-- fill buffer
|
|
if town_center.coin_balance >= cost then
|
|
town_center.coin_balance = town_center.coin_balance - cost
|
|
Town_center.update_coin_balance(force)
|
|
town_center.output_buffer[item] = town_center.output_buffer[item] + count
|
|
--log("output_buffer[" .. item .. "] = " .. town_center.output_buffer[item])
|
|
end
|
|
end
|
|
if town_center.output_buffer[item] > 0 and not stack.valid_for_read then
|
|
-- output the item
|
|
local amount = 1
|
|
if stack.can_set_stack({ name = item, count = amount }) then
|
|
town_center.output_buffer[item] = town_center.output_buffer[item] - amount
|
|
stack.set_stack({ name = item, count = amount })
|
|
--log("output_buffer[" .. item .. "] = " .. town_center.output_buffer[item])
|
|
end
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- pushing an item to the market (coins or scrap)
|
|
if e.pickup_target and inside(dpos, bb) then
|
|
local stack = e.held_stack
|
|
local spos = e.held_stack_position
|
|
if stack.valid_for_read and inside(spos, bb) then
|
|
local name = stack.name
|
|
local amount = stack.count
|
|
if name == "coin" then
|
|
-- push coins
|
|
e.remove_item(stack)
|
|
town_center.coin_balance = town_center.coin_balance + amount
|
|
Town_center.update_coin_balance(force)
|
|
else
|
|
-- push items to turn into coin
|
|
for _, trade in ipairs(offers) do
|
|
local type = trade.offer.type
|
|
local item = trade.price[1].name
|
|
local count = trade.price[1].amount
|
|
local cost = trade.offer.count
|
|
if type == "give-item" and name == item and item ~= "coin" then
|
|
e.remove_item(stack)
|
|
-- buffer the input in an item buffer that can be sold
|
|
if town_center.input_buffer[item] == nil then town_center.input_buffer[item] = 0 end
|
|
town_center.input_buffer[item] = town_center.input_buffer[item] + amount
|
|
--log("input_buffer[" .. item .. "] = " .. town_center.input_buffer[item])
|
|
if town_center.input_buffer[item] >= count then
|
|
town_center.input_buffer[item] = town_center.input_buffer[item] - count
|
|
town_center.coin_balance = town_center.coin_balance + cost
|
|
Town_center.update_coin_balance(force)
|
|
--log("input_buffer[" .. item .. "] = " .. town_center.input_buffer[item])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local Event = require 'utils.event'
|
|
Event.add(defines.events.on_tick, on_tick)
|
|
Event.add(defines.events.on_gui_opened, on_gui_opened)
|
|
Event.add(defines.events.on_market_item_purchased, on_market_item_purchased)
|
|
|