mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-24 03:47:58 +02:00
338 lines
16 KiB
Lua
338 lines
16 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)
|