You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
468 lines
22 KiB
468 lines
22 KiB
--[[ NOTE: The multiplayer support commnads are designed so that multiplayer mods can use them, but individuals can use use commands to to get multiplayer working without relying on mods.]]
|
|
|
|
remote.add_interface(
|
|
"space-exploration",
|
|
{
|
|
|
|
--/c remote.call("space-exploration", "lock_player_respawn_location", {player = game.player, position = game.player.position, zone_name = "Nauvis"})
|
|
-- or
|
|
--/c remote.call("space-exploration", "lock_player_respawn_location", {player = game.player, position = game.player.position, surface_name = "nauvis"})
|
|
lock_player_respawn_location = function(data)
|
|
if data.player and data.player.valid and data.position and data.position.x and data.position.y then
|
|
local playerdata = get_make_playerdata(data.player)
|
|
if data.zone_name then
|
|
local zone = Zone.from_name(data.zone_name)
|
|
if not zone then game.print("Invalid zone name: "..data.zone_name) return end
|
|
playerdata.lock_respawn = {zone_index = zone.index, position = data.position}
|
|
game.print(data.player.name.." respawn location locked")
|
|
elseif data.surface_name then
|
|
if not game.surfaces[data.surface_name] then game.print("Invalid surface name: "..data.surface_name) end
|
|
playerdata.lock_respawn = {surface_name = data.surface_name, position = data.position}
|
|
game.print(data.player.name.." respawn location locked")
|
|
end
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "unlock_player_respawn_location", {player = game.player})
|
|
unlock_player_respawn_location = function(data)
|
|
if data.player and data.player.valid then
|
|
local playerdata = get_make_playerdata(data.player)
|
|
playerdata.lock_respawn = nil
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "get_player_character", {player = game.player})
|
|
get_player_character = function(data)
|
|
if data.player and data.player.valid then
|
|
if data.player.character then return data.player.character end
|
|
local playerdata = get_make_playerdata(data.player)
|
|
return playerdata.character
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "spawn_small_resources", {surface = game.player.surface})
|
|
spawn_small_resources = function(data)
|
|
Zone.spawn_small_resources(data.surface)
|
|
end,
|
|
|
|
--Can multiply resources on nauvis. It should not be used unless you are sure the available resources on nauvis are insufficient to set up a few moon mining bases.
|
|
--/c remote.call("space-exploration", "multiply_nauvis_resource", {surface = game.player.surface, resource_name = "iron-ore", multiplier=0.9})
|
|
multiply_nauvis_resource = function(data)
|
|
if data.multiplier > 0 and data.multiplier ~= 1 and data.surface then
|
|
for _, entity in pairs(data.surface.find_entities_filtered{type = "resource", name=data.resource_name}) do
|
|
local amount = math.ceil(entity.amount * data.multiplier)
|
|
if amount > 0 then
|
|
entity.amount = amount
|
|
else
|
|
entity.destroy()
|
|
end
|
|
end
|
|
end
|
|
end,
|
|
|
|
-- Quick setup multiplayer test
|
|
--/c remote.call("space-exploration", "setup_multiplayer_test", { force_name = "player-2", players = {game.player}, match_nauvis_seed = false})
|
|
setup_multiplayer_test = function(data)
|
|
|
|
-- make the force
|
|
local force_name = data.force_name
|
|
if not game.forces[force_name] then
|
|
game.create_force(force_name)
|
|
end
|
|
if not game.forces[force_name] then
|
|
game.print("Error creating force with name: "..(force_name or "nil"))
|
|
return
|
|
end
|
|
|
|
-- select the planet
|
|
local planet
|
|
|
|
for _, star in pairs(global.universe.stars) do
|
|
if planet == nil then
|
|
if star.special_type == "homesystem" then
|
|
-- taken
|
|
else
|
|
for _, child in pairs(star.children) do
|
|
if child.type == "planet" and (not child.ruins) and (not child.interburbulator) and (not child.glyph) then
|
|
planet = child
|
|
game.print("Selected planet: "..child.name.." for homeworld.")
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if not planet then
|
|
game.print("Error finding a planet")
|
|
return
|
|
end
|
|
|
|
-- change the player forces
|
|
for _, player in pairs(data.players) do
|
|
player.force = game.forces[force_name]
|
|
end
|
|
|
|
local match_nauvis_seed = data.match_nauvis_seed == nil and true or data.match_nauvis_seed
|
|
-- make the homeworld
|
|
Zone.set_zone_as_homeworld({ zone_name = planet.name, match_nauvis_seed = match_nauvis_seed, reset_surface = true})
|
|
|
|
|
|
Zone.spawn_small_resources(Zone.get_surface(planet))
|
|
|
|
-- move the players
|
|
local surface = Zone.get_make_surface(planet)
|
|
for _, player in pairs(data.players) do
|
|
if player.character then
|
|
teleport_character_to_surface(player.character, surface, {0,0}) -- prevents overlapping players
|
|
else
|
|
player.teleport({0,0}, surface)
|
|
end
|
|
end
|
|
|
|
-- assign the force to the homeworld (a homeworld can have multiple forces)
|
|
-- also resets discoveries
|
|
set_force_homeworld({zone_name = planet.name, force_name = force_name, spawn_position = {x = 0, y = 0}, reset_discoveries = true})
|
|
|
|
-- TODO: trigger AAI crash sequence?
|
|
|
|
end,
|
|
|
|
-- set the target zone to be a homeworld
|
|
--/c remote.call("space-exploration", "set_zone_as_homeworld", {zone_name = "Arendel", match_nauvis_seed = false, reset_surface = true})
|
|
set_zone_as_homeworld = function(data)
|
|
return Zone.set_zone_as_homeworld(data)
|
|
end,
|
|
|
|
-- set a force's homeworld (needed for later functions) and sets their respawn location
|
|
--/c remote.call("space-exploration", "set_force_homeworld", {zone_name = "Arendel", force_name = "player-2", spawn_position = {x = 0, y = 0}, reset_discoveries = true})
|
|
set_force_homeworld = function(data)
|
|
return set_force_homeworld(data)
|
|
end,
|
|
|
|
-- reset a force's discovered locations.
|
|
--/c remote.call("space-exploration", "set_force_homeworld", { force_name = "player-2"})
|
|
force_reset_discoveries = function(data)
|
|
force_reset_discoveries(data.force_name)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_index", {})
|
|
get_zone_index = function(data)
|
|
local zone_index = {}
|
|
for i, zone in pairs(global.zone_index) do
|
|
table.insert(zone_index, Zone.export_zone(zone))
|
|
end
|
|
return zone_index
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_from_name", {zone_name = "Nauvis"})
|
|
get_zone_from_name = function(data) return Zone.export_zone(Zone.from_name(data.zone_name)) end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_from_zone_index", {zone_index = 2})
|
|
get_zone_from_zone_index = function(data) return Zone.export_zone(Zone.from_zone_index(data.zone_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_from_surface_index", {surface_index = game.player.surface.index})
|
|
get_zone_from_surface_index = function(data) return Zone.export_zone(Zone.from_surface_index(data.surface_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "get_surface_type", {surface_index = game.player.surface.index})
|
|
get_surface_type = function(data)
|
|
local surface = game.surfaces[data.surface_index]
|
|
local zone = Zone.from_surface(surface)
|
|
if zone then return zone.type end
|
|
-- vault?
|
|
local vault = Ancient.vault_from_surface(surface)
|
|
if vault then return "vault" end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_icon", {zone_index = remote.call("space-exploration", "get_zone_from_surface_index", {surface_index = game.player.surface.index}).index})
|
|
get_zone_icon = function(data) return Zone.get_icon(Zone.from_zone_index(data.zone_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_is_solid", {zone_index = remote.call("space-exploration", "get_zone_from_surface_index", {surface_index = game.player.surface.index}).index})
|
|
get_zone_is_solid = function(data) return Zone.is_solid(Zone.from_zone_index(data.zone_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "get_zone_is_space", {zone_index = remote.call("space-exploration", "get_zone_from_surface_index", {surface_index = game.player.surface.index}).index})
|
|
get_zone_is_space = function(data) return Zone.is_space(Zone.from_zone_index(data.zone_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "zone_get_surface", {zone_index = remote.call("space-exploration", "get_zone_from_name", {zone_name = "Arendel"}).index})
|
|
zone_get_surface = function(data) return Zone.get_surface(Zone.from_zone_index(data.zone_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "zone_get_make_surface", {zone_index = remote.call("space-exploration", "get_zone_from_name", {zone_name = "Arendel"}).index})
|
|
zone_get_make_surface = function(data) return Zone.get_make_surface(Zone.from_zone_index(data.zone_index)) end,
|
|
|
|
--/c remote.call("space-exploration", "get_cargo_loss", {force = game.player.force})
|
|
get_cargo_loss = function(data) return Launchpad.get_cargo_loss(data.force) end,
|
|
|
|
--/c remote.call("space-exploration", "get_reusability", {force = game.player.force})
|
|
get_reusability = function(data) return Launchpad.get_reusability(data.force) end,
|
|
|
|
--/c remote.call("space-exploration", "get_survivability_loss", {force = game.player.force})
|
|
--/c game.print(remote.call("space-exploration", "get_survivability_loss", {force = game.player.force}))
|
|
get_survivability_loss = function(data) return Launchpad.get_survivability_loss(data.force) end,
|
|
|
|
--/c game.print(remote.call("space-exploration", "get_rockets_launched", {force = game.player.force}))
|
|
get_rockets_launched = function(data) return global.forces[data.force.name].cargo_rockets_launched end,
|
|
|
|
--/c remote.call("space-exploration", "launch_satellite", {force_name = game.player.force.name, surface=game.player.surface, count=1})
|
|
launch_satellite = function(data)
|
|
local rep = data.count or 1
|
|
for i = 1, rep, 1 do
|
|
on_satellite_launched(data.force_name, data.surface)
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "build_satellite", {force_name = game.player.force.name})
|
|
build_satellite = function(data) build_satellite(data.force_name) end,
|
|
|
|
--/c remote.call("space-exploration", "build_ruin", {ruin_name = "satellite", surface_index = game.player.surface.index, position = game.player.position})
|
|
build_ruin = function(data)
|
|
Ruin.build(data)
|
|
end,
|
|
|
|
--/c pl = game.player p = pl.position remote.call("space-exploration", "ruin_log_tiles", {capture_name = "temp", surface = pl.surface, registration_point = p, left_top = {p.x - 11, p.y - 11}, right_bottom = {p.x + 11, p.y + 11}})
|
|
ruin_log_tiles = function(data)
|
|
Ruin.log_tiles(data)
|
|
end,
|
|
|
|
--/c pl = game.player p = pl.position remote.call("space-exploration", "ruin_log_entities", {capture_name = "temp", surface = pl.surface, registration_point = p, left_top = {p.x - 11, p.y - 11}, right_bottom = {p.x + 11, p.y + 11}})
|
|
ruin_log_entities = function(data)
|
|
Ruin.log_entities(data)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "ruin_replace_in_blueprint", {name="filename", blueprint="...", entities={{name="in-name", new_name="out-name", shift={0,0}}, tiles={["in_name"]="out-name"}})
|
|
ruin_replace_in_blueprint = function(data)
|
|
Ruin.replace_in_blueprint(data)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "make_interburbulator", {position = {x=game.player.position.x, y = game.player.position.y - 10}, zone_index = remote.call("space-exploration", "get_zone_from_surface_index", {surface_index = game.player.surface.index}).index})
|
|
make_interburbulator = function(data)
|
|
Interburbulator.make_interburbulator(Zone.from_zone_index(data.zone_index), data.position)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "discover_zone", {force_name = game.player.force.name, surface=game.player.surface, zone_name="Arendel"})
|
|
discover_zone = function(data)
|
|
if not global.forces[data.force_name].satellites_launched or global.forces[data.force_name].satellites_launched == 0 then
|
|
on_satellite_launched(data.force_name, data.surface)
|
|
end
|
|
Zone.discover(data.force_name, Zone.from_name(data.zone_name))
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "discover_zones_by_type", {force_name = game.player.force.name, types={"star", "planet", "moon"}})
|
|
discover_zones_by_type = function(data)
|
|
for _, zone in pairs(global.zone_index) do
|
|
if util.table_contains(data.types, zone.type) then
|
|
Zone.discover(data.force_name, zone)
|
|
end
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "show_all_zones", {})
|
|
show_all_zones = function(data)
|
|
global.debug_view_all_zones = true
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "unshow_all_zones", {})
|
|
unshow_all_zones = function(data)
|
|
global.debug_view_all_zones = false
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "debug_set_global", {debug_view_all_zones = true})
|
|
-- debug_set_global = function(data) for k, v in pairs(data) do global[k] = v end end,
|
|
|
|
--/c remote.call("space-exploration", "teleport_to_zone", {zone_name = "Nauvis", player=game.player})
|
|
teleport_to_zone = function(data)
|
|
local zone = Zone.from_name(data.zone_name)
|
|
if zone and data.player then
|
|
local surface = Zone.get_make_surface(zone)
|
|
if data.player.character then
|
|
teleport_character_to_surface(data.player.character, surface, {0,0})
|
|
else
|
|
data.player.teleport({0,0}, surface)
|
|
end
|
|
end
|
|
end,
|
|
|
|
-- /c remote.call("space-exploration", "remote_view_is_active", {player=game.player})
|
|
remote_view_is_active = function(data)
|
|
if data.player then
|
|
return RemoteView.is_active(data.player)
|
|
end
|
|
end,
|
|
|
|
-- /c remote.call("space-exploration", "remote_view_is_unlocked", {player=game.player})
|
|
remote_view_is_unlocked = function(data)
|
|
if data.player then
|
|
return RemoteView.is_unlocked(data.player)
|
|
end
|
|
end,
|
|
|
|
-- /c remote.call("space-exploration", "remote_view_start", {player=game.player, zone_name = "Nauvis", position={x=100,y=200}, location_name="Point of Interest", freeze_history=true})
|
|
remote_view_start = function(data)
|
|
local zone = Zone.from_name(data.zone_name)
|
|
if zone and data.player then
|
|
RemoteView.start(data.player, zone, data.position, data.location_name, data.freeze_history)
|
|
end
|
|
end,
|
|
|
|
-- /c remote.call("space-exploration", "remote_view_stop", {player=game.player})
|
|
remote_view_stop = function(data)
|
|
if data.player then
|
|
RemoteView.stop(data.player)
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "set_player_velocity", {player=game.player, velocity = {x = 0, y = 0}})
|
|
set_player_velocity = function(data)
|
|
if data.player and data.velocity and data.velocity.x and data.velocity.y then
|
|
local playerdata = get_make_playerdata(player)
|
|
if playerdata then
|
|
playerdata.velocity = data.velocity
|
|
end
|
|
end
|
|
end,
|
|
--/c remote.call("space-exploration", "begin_meteor_shower", {target_entity = game.player, meteors = 10})
|
|
--/c remote.call("space-exploration", "begin_meteor_shower", {target_entity = game.player.selected or game.player})
|
|
--/c remote.call("space-exploration", "begin_meteor_shower", {zone_name = "Nauvis", position = {x=0,y=0}, range = 1, meteors = 100})
|
|
--/c for i = 1, 10 do remote.call("space-exploration", "begin_meteor_shower", {target_entity = game.player, meteors = 100}) end
|
|
begin_meteor_shower = function(data)
|
|
local entity = data.target_entity
|
|
if entity then
|
|
local zone = Zone.from_surface(entity.surface)
|
|
if zone and zone.type ~= "spaceship" then
|
|
Meteor.begin_meteor_shower(zone, entity.position, data.range, data.meteors)
|
|
end
|
|
elseif data.zone_name then
|
|
local zone = Zone.from_name(data.zone_name)
|
|
if zone and zone.type ~= "spaceship" then
|
|
local position = data.position or {x = 0, y = 0}
|
|
Meteor.begin_meteor_shower(zone, position, data.range, data.meteors)
|
|
end
|
|
end
|
|
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "begin_solar_flare", {zone_name = "Nauvis", targeting="basic"})
|
|
begin_solar_flare = function(data)
|
|
if data.zone_name then
|
|
local zone = Zone.from_name(data.zone_name)
|
|
if zone and zone.type ~= "spaceship" then
|
|
SolarFlare.begin_flare(zone, data.targeting) -- zone, targeting, power_multiplier, delay, max_age
|
|
end
|
|
end
|
|
|
|
end,
|
|
|
|
|
|
--/c remote.call("space-exploration", "fuel_rocket_silos", {})
|
|
fuel_rocket_silos = function()
|
|
for _, launch_pad in pairs(global.rocket_launch_pads) do
|
|
launch_pad.lua_fuel = (launch_pad.lua_fuel or 0) + 100000000
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "get_known_zones", {force_name = game.player.force.name})
|
|
get_known_zones = function(data)
|
|
if data.force_name and global.forces[data.force_name] then
|
|
-- return a list of known zone indexes.
|
|
return global.forces[data.force_name].zones_discovered
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "show_only_zones", {zone_names = {"Nauvis", "Sandro", "Zomble", "Foenestra", "Kamsta"}})
|
|
show_only_zones = function(data)
|
|
for force_name, force_data in pairs(global.forces) do
|
|
force_data.zones_discovered = {}
|
|
force_data.zones_discovered_count = 0
|
|
force_data.satellites_launched = 1
|
|
for _, zone_name in pairs(data.zone_names) do
|
|
local zone = Zone.from_name(zone_name)
|
|
if zone then
|
|
Zone.discover(force_name, zone, "Command")
|
|
else
|
|
game.print("Invalid zone name: "..zone_name)
|
|
end
|
|
end
|
|
end
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "rebuild_surface_index", {})
|
|
rebuild_surface_index = Zone.rebuild_surface_index,
|
|
|
|
--/c remote.call("space-exploration", "rebuild_universe_resource_assignments", {})
|
|
rebuild_universe_resource_assignments = Universe.rebuild_resource_assignments,
|
|
|
|
get_on_cargo_rocket_launched_event = function() return Launchpad.on_cargo_rocket_launched_event end,
|
|
--/c remote.call("space-exploration", "get_on_player_respawned_event")
|
|
get_on_player_respawned_event = function() return Respawn.on_player_respawned_event end,
|
|
|
|
--/c remote.call("space-exploration", "planet_swap", {star="Calidus", add_planet="Sandro"})
|
|
robot_attrition_for_surface = function(data)
|
|
local surface_index = data.surface_index
|
|
local default_rate = data.default_rate
|
|
local zone = Zone.from_surface_index(surface_index)
|
|
return Zone.get_attrition(zone, default_rate)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "cancel_entity_creation", {entity=game.player.selected, player_index=1, message={"space-exploration.construction-denied"}})
|
|
cancel_entity_creation = function(data)
|
|
return cancel_entity_creation(data.entity, data.player_index, data.message)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "log_map_gen", {})
|
|
log_map_gen = Log.log_map_gen,
|
|
log_global = Log.log_global,
|
|
log_universe_simplified = Log.log_universe_simplified,
|
|
log_universe = Log.log_universe,
|
|
log_forces = Log.log_forces,
|
|
log_spaceships = Log.log_spaceships,
|
|
|
|
--/c remote.call("space-exploration", "ancient_make_gate", {})
|
|
ancient_make_gate = function(data)
|
|
Ancient.make_gate(Ancient.gate_default_position)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "ancient_gate_phase_2", {})
|
|
ancient_gate_phase_2 = function(data)
|
|
Ancient.gate_phase_2(global.gate)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "ancient_gate_phase_3", {})
|
|
ancient_gate_phase_3 = function(data)
|
|
Ancient.gate_phase_3(global.gate)
|
|
end,
|
|
|
|
--/c remote.call("space-exploration", "ancient_f6", {})
|
|
ancient_f6 = function(data)
|
|
Ancient.cryptf6()
|
|
end,
|
|
|
|
-- informatron implementation
|
|
informatron_menu = function(data)
|
|
return Informatron.menu(data.player_index)
|
|
end,
|
|
|
|
informatron_page_content = function(data)
|
|
return Informatron.page_content(data.page_name, data.player_index, data.element)
|
|
end,
|
|
|
|
informatron_page_content_update = function(data)
|
|
return Informatron.page_content_update(data.page_name, data.player_index, data.element)
|
|
end,
|
|
|
|
-- jetpack implementation
|
|
on_character_swapped = function(event)
|
|
if event.new_character and event.old_character then
|
|
for _, playerdata in pairs(global.playerdata) do
|
|
if playerdata.character == event.old_character then
|
|
playerdata.character = event.new_character
|
|
end
|
|
end
|
|
end
|
|
end,
|
|
|
|
on_entity_activated = function(event)
|
|
if mod ~= "space-exploration" then
|
|
Beacon.validate_entity(entity, ignore_count)
|
|
end
|
|
end
|
|
|
|
}
|
|
)
|
|
|