166 lines
4.3 KiB
GDScript
166 lines
4.3 KiB
GDScript
tool
|
|
extends Node2D
|
|
|
|
class_name GameMap
|
|
|
|
signal map_received()
|
|
|
|
var ship_direction = 0
|
|
var ship_speed = 0
|
|
|
|
var current_ship_position = Vector2.ZERO
|
|
var current_ship_target = Vector2.ZERO
|
|
|
|
var current_ship_direction = 0
|
|
var current_ship_speed = 0
|
|
|
|
const SPEED_EASE = 0.5
|
|
const DIRECTION_EASE = 0.5
|
|
const EPSILON = 0.01
|
|
|
|
const ProbeElectricity = preload("res://Actors/Systems/Electricity/ElectricProbe.tscn")
|
|
|
|
onready var tilemaps = [ $base, $cables, $floor, $walls ]
|
|
|
|
onready var pois = $pois
|
|
|
|
export var unlit = false setget set_unlit
|
|
onready var darkness = $darkness
|
|
|
|
export var shadow_intensity = 0.2
|
|
|
|
func _ready():
|
|
if Engine.editor_hint:
|
|
return
|
|
$editor.queue_free()
|
|
set_unlit(true)
|
|
|
|
if not is_network_master():
|
|
return
|
|
|
|
# Run special tiling
|
|
$walls.run_conversions()
|
|
|
|
# Electricity setup
|
|
make_electric_probes($cables, "Wire")
|
|
|
|
print(serialize())
|
|
|
|
func _process(delta: float):
|
|
if Engine.editor_hint:
|
|
return
|
|
|
|
# Ease ship speed/direction changes
|
|
if abs(ship_direction - current_ship_direction) < EPSILON:
|
|
current_ship_direction = ship_direction
|
|
else:
|
|
current_ship_direction = lerp(current_ship_direction, ship_direction, delta * DIRECTION_EASE)
|
|
if abs(ship_speed - current_ship_speed) < EPSILON:
|
|
current_ship_speed = ship_speed
|
|
else:
|
|
current_ship_speed = lerp(current_ship_speed, ship_speed, delta * SPEED_EASE)
|
|
set_engine_strength(current_ship_speed)
|
|
$deepspace.rotation = current_ship_direction-PI/2
|
|
$deepspace.region_rect.position += Vector2(sin(current_ship_direction), cos(current_ship_direction)) * current_ship_speed * delta
|
|
|
|
# Serialization / Deserialization
|
|
|
|
func serialize() -> Dictionary:
|
|
# Get tilemap data
|
|
var tilemapdata = {}
|
|
for tilemap in tilemaps:
|
|
var data = []
|
|
for cell in tilemap.get_used_cells():
|
|
data.append([cell, tilemap.get_cellv(cell)])
|
|
tilemapdata[tilemap.name] = data
|
|
|
|
# Get objects
|
|
var engines = serialize_children($engines)
|
|
var objects = serialize_children($objects)
|
|
var lights = serialize_children($lights)
|
|
var pois = serialize_children($pois)
|
|
|
|
return {
|
|
"tilemaps": tilemapdata,
|
|
"engines": engines,
|
|
"objects": objects,
|
|
"lights": lights,
|
|
"pois": pois
|
|
}
|
|
|
|
func deserialize(data: Dictionary) -> void:
|
|
for tilemap in data["tilemaps"]:
|
|
var tilemap_node = get_node(tilemap) as TileMap
|
|
for tile in data["tilemaps"][tilemap]:
|
|
tilemap_node.set_cellv(tile[0], tile[1])
|
|
tilemap_node.update_bitmask_region()
|
|
tilemap_node.update_dirty_quadrants()
|
|
deserialize_children($engines, data["engines"])
|
|
deserialize_children($objects, data["objects"])
|
|
deserialize_children($lights, data["lights"])
|
|
deserialize_children($pois, data["pois"])
|
|
$walls.run_conversions()
|
|
|
|
master func send_data(id: int) -> void:
|
|
rpc_id(id, "receive_data", serialize())
|
|
|
|
puppet func receive_data(data: Dictionary) -> void:
|
|
deserialize(data)
|
|
print("Received map data from master")
|
|
emit_signal("map_received")
|
|
|
|
func serialize_children(node: Node) -> Dictionary:
|
|
var data = {}
|
|
for child in node.get_children():
|
|
data[child.name] = {
|
|
"filename": child.filename,
|
|
"data": child.serialize(),
|
|
"transform": child.transform
|
|
}
|
|
return data
|
|
|
|
func deserialize_children(node: Node, data: Dictionary) -> void:
|
|
for node_name in data:
|
|
var node_data = data[node_name] as Dictionary
|
|
var node_scene = load(node_data.filename).instance()
|
|
node_scene.name = node_name
|
|
node_scene.transform = node_data.transform
|
|
node_scene.deserialize(node_data.data)
|
|
node.add_child(node_scene, true)
|
|
|
|
# Lighting
|
|
|
|
func set_unlit(val: bool):
|
|
unlit = val
|
|
if darkness:
|
|
darkness.visible = not val
|
|
|
|
# Engine related functions
|
|
|
|
func set_engine_strength(val: float):
|
|
# Set energy strength to current speed
|
|
for child in $engines.get_children():
|
|
if child is GameObjectEngine:
|
|
var engine = child as GameObjectEngine
|
|
engine.strength = val
|
|
|
|
# Tileset related functions
|
|
|
|
func make_electric_probes(tilemap: TileMap, tile_name: String):
|
|
var tile_id = tilemap.tile_set.find_tile_by_name(tile_name)
|
|
for cell in tilemap.get_used_cells_by_id(tile_id):
|
|
var coord = tilemap.map_to_world(cell)
|
|
var probe = ProbeElectricity.instance()
|
|
probe.position = coord
|
|
tilemap.add_child(probe)
|
|
|
|
func get_pois(type_filter, class_filter) -> Array:
|
|
var filtered = []
|
|
for child in $pois.get_children():
|
|
if type_filter != null and child.poitype != type_filter:
|
|
continue
|
|
if class_filter != null and child.poiclass != class_filter:
|
|
continue
|
|
filtered.append(child)
|
|
return filtered
|