269 lines
11 KiB
Lua
269 lines
11 KiB
Lua
love.window.setMode(960, 540)
|
|
local screen_width, screen_height = love.graphics.getDimensions()
|
|
math.randomseed(os.time())
|
|
|
|
-- returns selected_object, distance_squared_to_object (if object_list is empty, returns nil, math.huge)
|
|
local function get_closest_object(object_list, current_object)
|
|
local selected_object, distance_squared_to_object = nil, math.huge
|
|
for i = 1, #object_list do
|
|
local function compare_object()
|
|
local comparison_object = object_list[i]
|
|
if comparison_object == current_object then
|
|
return
|
|
end
|
|
local comparison_distance_squared = (current_object.position_x - comparison_object.position_x)^2 + (current_object.position_y - comparison_object.position_y)^2
|
|
if comparison_distance_squared < distance_squared_to_object then
|
|
selected_object = comparison_object
|
|
distance_squared_to_object = comparison_distance_squared
|
|
end
|
|
end
|
|
compare_object()
|
|
end
|
|
|
|
return selected_object, distance_squared_to_object
|
|
end
|
|
|
|
-- source_object and destination_object can be nil to create/delete resources
|
|
-- returns cargo_amount (actual amount transferred)
|
|
local function transfer_cargo(source_object, destination_object, cargo_type, cargo_amount)
|
|
if not source_object then
|
|
source_object = { cargo_contents = { [cargo_type] = math.huge }, cargo_free_space = 0, }
|
|
end
|
|
if not destination_object then
|
|
destination_object = { cargo_contents = {}, cargo_free_space = math.huge, }
|
|
end
|
|
|
|
if not source_object.cargo_contents[cargo_type] then
|
|
return 0
|
|
end
|
|
if not destination_object.cargo_contents[cargo_type] then
|
|
destination_object.cargo_contents[cargo_type] = 0
|
|
end
|
|
|
|
if cargo_amount > source_object.cargo_contents[cargo_type] then
|
|
cargo_amount = source_object.cargo_contents[cargo_type]
|
|
end
|
|
if cargo_amount > destination_object.cargo_free_space then
|
|
cargo_amount = destination_object.cargo_free_space
|
|
end
|
|
|
|
destination_object.cargo_contents[cargo_type] = destination_object.cargo_contents[cargo_type] + cargo_amount
|
|
destination_object.cargo_free_space = destination_object.cargo_free_space - cargo_amount
|
|
source_object.cargo_contents[cargo_type] = source_object.cargo_contents[cargo_type] - cargo_amount
|
|
source_object.cargo_free_space = source_object.cargo_free_space + cargo_amount
|
|
|
|
if source_object.cargo_contents[cargo_type] <= 0 then
|
|
source_object.cargo_contents[cargo_type] = nil
|
|
end
|
|
|
|
return cargo_amount
|
|
end
|
|
|
|
local function check_cargo_amount(source_object, cargo_type, cargo_amount)
|
|
if not source_object.cargo_contents[cargo_type] then
|
|
return false
|
|
end
|
|
if source_object.cargo_contents[cargo_type] >= cargo_amount then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
local ore_types = { "iron ore", "copper ore", "warp fuel", }
|
|
-- local cargo_types = {}
|
|
-- for i = 1, #ore_types do
|
|
-- cargo_types[#cargo_types + 1] = ore_types[i]
|
|
-- end
|
|
-- for i = 1, #cargo_types do
|
|
-- cargo_types[cargo_types[i]] = i
|
|
-- end
|
|
|
|
-- TODO review my previous orbits code to add extremely slow background orbits to this
|
|
-- planets/stars/stations always have fixed orbits; ships have a fixed orbital acceleration but have their own additional
|
|
-- the "zero relative velocity" key will be a burn whatever amount of fuel/acceleration necessary to match local acceleration
|
|
-- which.. since the currently stored velocity is a COMPLETELY SEPARATE SYSTEM - is literally just zeroing velocity which makes it even simpler to execute
|
|
local player_ship = {
|
|
position_x = screen_width / 2,
|
|
position_y = screen_height / 2,
|
|
velocity_x = 0,
|
|
velocity_y = 0,
|
|
acceleration = 100,
|
|
|
|
radar_size = 10,
|
|
|
|
cargo_max_space = 100,
|
|
cargo_free_space = 75,
|
|
cargo_contents = {
|
|
["warp fuel"] = 25,
|
|
},
|
|
cargo_fill_speed = 10,
|
|
|
|
-- TODO fuel capacity and use (idle and while acceleration)
|
|
-- TODO cargo / mass affects acceleration
|
|
}
|
|
|
|
local resource_points = {} -- NOTE they're "planets" but I intend for them to be multiple things tbh
|
|
local function add_resource_points(point_count)
|
|
for i = 1, point_count do
|
|
local function make_resource_point()
|
|
local current_point = {
|
|
position_x = math.random() * screen_width,
|
|
position_y = math.random() * screen_height,
|
|
radar_size = 10,
|
|
|
|
cargo_max_space = 100000,
|
|
cargo_free_space = 100000,
|
|
cargo_contents = {},
|
|
}
|
|
|
|
-- NOTE can select literally anything
|
|
local selected_type = ore_types[math.random(#ore_types)]
|
|
local cargo_amount = math.random() * 10000
|
|
transfer_cargo(nil, current_point, selected_type, cargo_amount)
|
|
|
|
local closest_object, distance_squared_to_object = get_closest_object(resource_points, current_point)
|
|
if closest_object and distance_squared_to_object <= (closest_object.radar_size^2 + current_point.radar_size^2) * 1.5 then
|
|
return
|
|
end
|
|
|
|
table.insert(resource_points, current_point)
|
|
return true
|
|
end
|
|
|
|
if not make_resource_point() then
|
|
i = i - 1
|
|
end
|
|
end
|
|
end
|
|
add_resource_points(math.random(5))
|
|
|
|
local last_message = ""
|
|
function love.update(dt)
|
|
-- NOTE this control scheme makes diagonal travel faster than horizontal/vertical
|
|
if love.keyboard.isDown("w") or love.keyboard.isDown("up") then
|
|
player_ship.velocity_y = player_ship.velocity_y - player_ship.acceleration * dt
|
|
end
|
|
if love.keyboard.isDown("a") or love.keyboard.isDown("left") then
|
|
player_ship.velocity_x = player_ship.velocity_x - player_ship.acceleration * dt
|
|
end
|
|
if love.keyboard.isDown("s") or love.keyboard.isDown("down") then
|
|
player_ship.velocity_y = player_ship.velocity_y + player_ship.acceleration * dt
|
|
end
|
|
if love.keyboard.isDown("d") or love.keyboard.isDown("right") then
|
|
player_ship.velocity_x = player_ship.velocity_x + player_ship.acceleration * dt
|
|
end
|
|
|
|
-- NOTE this zeros out diagonal velocities faster than horizontal/vertical
|
|
if love.keyboard.isDown("lshift") or love.keyboard.isDown("rshift") then
|
|
if player_ship.velocity_x > 0 then
|
|
player_ship.velocity_x = math.max(0, player_ship.velocity_x - player_ship.acceleration * dt)
|
|
elseif player_ship.velocity_x < 0 then
|
|
player_ship.velocity_x = math.min(0, player_ship.velocity_x + player_ship.acceleration * dt)
|
|
end
|
|
|
|
if player_ship.velocity_y > 0 then
|
|
player_ship.velocity_y = math.max(0, player_ship.velocity_y - player_ship.acceleration * dt)
|
|
elseif player_ship.velocity_y < 0 then
|
|
player_ship.velocity_y = math.min(0, player_ship.velocity_y + player_ship.acceleration * dt)
|
|
end
|
|
end
|
|
|
|
player_ship.position_x = player_ship.position_x + player_ship.velocity_x * dt
|
|
player_ship.position_y = player_ship.position_y + player_ship.velocity_y * dt
|
|
|
|
-- TODO make this toggleable instead of requiring holding a key
|
|
if love.keyboard.isDown("space") then
|
|
local function collect_resource()
|
|
local closest_object, distance_squared_to_object = get_closest_object(resource_points, player_ship)
|
|
-- TODO ideally, there should be an indicator that you're close enough instead of relying on messages (to be fair, the radius is the indicator)
|
|
if distance_squared_to_object > closest_object.radar_size^2 then
|
|
last_message = "Too far to pick up cargo."
|
|
return
|
|
end
|
|
if player_ship.cargo_free_space <= 0 then
|
|
last_message = "No cargo space left."
|
|
return
|
|
end
|
|
-- TODO allow selecting cargo type
|
|
local cargo_type = next(closest_object.cargo_contents)
|
|
if not cargo_type then
|
|
last_message = "There is nothing here."
|
|
return
|
|
end
|
|
local cargo_amount = math.min(player_ship.cargo_fill_speed * dt, closest_object.cargo_contents[cargo_type])
|
|
if cargo_amount <= 0 then
|
|
last_message = "There is no cargo to pick up."
|
|
return
|
|
end
|
|
|
|
cargo_amount = transfer_cargo(closest_object, player_ship, cargo_type, cargo_amount)
|
|
last_message = "Transfered " .. math.floor(cargo_amount * 100) / 100 .. " " .. cargo_type .. "."
|
|
end
|
|
collect_resource()
|
|
end
|
|
end
|
|
|
|
local font = love.graphics.getFont()
|
|
local font_height = font:getHeight()
|
|
function love.draw()
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
|
|
love.graphics.rectangle("line", player_ship.position_x - player_ship.radar_size / 2, player_ship.position_y - player_ship.radar_size / 2, player_ship.radar_size, player_ship.radar_size)
|
|
|
|
for i = 1, #resource_points do
|
|
local resource_point = resource_points[i]
|
|
love.graphics.circle("line", resource_point.position_x, resource_point.position_y, resource_point.radar_size)
|
|
end
|
|
|
|
love.graphics.print(last_message, 1, 1)
|
|
|
|
local inventory_status = {}
|
|
for cargo_type, cargo_amount in pairs(player_ship.cargo_contents) do
|
|
table.insert(inventory_status, { cargo_type = cargo_type, cargo_amount = cargo_amount })
|
|
end
|
|
table.sort(inventory_status, function(A, B) return A.cargo_amount > B.cargo_amount end)
|
|
for i = 1, #inventory_status do
|
|
inventory_status[i] = inventory_status[i].cargo_type .. ": " .. math.floor(inventory_status[i].cargo_amount * 10) / 10
|
|
end
|
|
local cargo_message = "Cargo: " .. math.min(math.floor((player_ship.cargo_max_space - player_ship.cargo_free_space) * 10) / 10, player_ship.cargo_max_space) .. "/" .. player_ship.cargo_max_space .. ". " .. table.concat(inventory_status, ", ")
|
|
love.graphics.print(cargo_message, 1, screen_height - font_height - 1)
|
|
end
|
|
|
|
function love.keypressed(key)
|
|
if key == "escape" then
|
|
love.event.quit()
|
|
elseif key == "1" then
|
|
-- 25x iron ore -> 5 cargo space
|
|
if not check_cargo_amount(player_ship, "iron ore", 25) then
|
|
last_message = "You do not have enough iron ore to upgrade your cargo space. (need 25)"
|
|
return
|
|
end
|
|
last_message = "Cargo space increased by 5."
|
|
transfer_cargo(player_ship, nil, "iron ore", 25)
|
|
player_ship.cargo_max_space = player_ship.cargo_max_space + 5
|
|
player_ship.cargo_free_space = player_ship.cargo_free_space + 5
|
|
elseif key == "2" then
|
|
-- 25x copper ore -> 1.1x acceleration
|
|
if not check_cargo_amount(player_ship, "copper ore", 25) then
|
|
last_message = "You do not have enough copper ore to upgrade your acceleration. (need 25)"
|
|
return
|
|
end
|
|
last_message = "Acceleration increased by 10%."
|
|
transfer_cargo(player_ship, nil, "copper ore", 25)
|
|
player_ship.acceleration = player_ship.acceleration * 1.1
|
|
elseif key == "return" or key == "kpenter" then
|
|
-- NOTE soft lock is possible when no warp fuel is generated / left / you use it all up without realizing
|
|
if not check_cargo_amount(player_ship, "warp fuel", 5) then
|
|
last_message = "You do not have enough warp fuel to go to a new system. (need 5)"
|
|
return
|
|
end
|
|
-- TODO require not being moving to warp
|
|
last_message = "Warped to new system!"
|
|
transfer_cargo(player_ship, nil, "warp fuel", 5)
|
|
player_ship.position_x = screen_width / 2
|
|
player_ship.position_y = screen_height / 2
|
|
resource_points = {}
|
|
add_resource_points(math.random(5))
|
|
end
|
|
end
|