working

1 files changed, 82 insertions, 316 deletions

diff --git a/scripts/movement.gd b/scripts/movement.gd
index 0b7726d..587b338 100644
--- a/scripts/movement.gd
+++ b/scripts/movement.gd
@@ -1,209 +1,132 @@
 extends KinematicBody
 
+var in_editor : bool = false
+
 var vel = Vector3()
 
-var _mouse = Vector2()
-var sensitivity_mouse = 0.1
+var camera = Camera
 
-var _camera : Camera
+var _mouse = Vector2()
+var sensitivity_mouse = 10
 
-var _normal = Vector3.ZERO
-var _colliding = false
-var _colliding_group = []
-var _colliding_node
-var _collision_point
+var placer : Spatial
 
 var _pivot
 var _pivot_dist
-var _pivot_rot
-var _pivot_look
+var _orbit_timer
 
-var _world
+var _world : VoxelMesh
 
-var _turret : PackedScene
-var _turret_holder
-var _turret_blues = []
+var _gui : Control
 
-var _attach_point
-var _attach_point_holder
+var _turret_holder : Node
+var _attach_point_holder : Node
+var path_holder : Node
+var load_turrets : Node
+var ptr : Node
 
-var _path_start
-var _path
-var _path_end
-var _path_holder
+var _enemies : Node
 
-var sel = 0;
-var sel_map = [ 
-	"turrets", "path start", "path", "path end", "attach point"
-]
+var sel = {
+	"type": "", 
+	"name": ""
+}
 
 func _ready():	
-	_camera = $Camera
+	camera = $camera
+	placer = $placer
 	
-	_world = self.get_parent().find_node("world")
-	_turret_holder = self.get_parent().find_node("turrets")
-	_path_holder = self.get_parent().find_node("path")
-	_attach_point_holder = self.get_parent().find_node("attach")
+	var root = get_tree().root.get_child(0)
 	
-	_turret = load("res://scenes/turret.tscn")
-	_path_start = load("res://scenes/path_start.tscn")
-	_path = load("res://scenes/path.tscn")
-	_path_end = load("res://scenes/path_end.tscn")
-	_attach_point = load("res://scenes/attach_point.tscn")
+	path_holder = root.get_node("path")
+	_gui = root.get_node("gui")
+	_enemies = root.get_node("enemies")
+	ptr = root.find_node("pointer");
 	
-	load_turrets()
+	var saveload = root.get_node("saveload")
+	load_turrets = saveload.get_node("load_turrets")
 	
-	#_save()
-	_load()
-
-func load_turrets():
-	_turret_blues = []
-	var dir = Directory.new()
-	dir.open("res://models/turrets")
-	dir.list_dir_begin(true)
-	var turr = dir.get_next()
-	while turr != "":
-		if (turr.ends_with(".glb")):
-			_turret_blues.append(load("res://models/turrets/" + turr))
-		turr = dir.get_next()
-
-func get_map_state ():
-	var state = {}
+	_gui.refresh(in_editor)
 	
-	state["voxels"] = []
-	for pos in _world.get_voxels():
-		var vox = { "pos": [pos.x, pos.y, pos.z], "id":_world.get_voxel_id(pos) }
-		state["voxels"] += [vox]
+	refresh_path()
 
-	state["path"] = []
-	for node in _path_holder.get_children():
-		var pos = node.transform.origin;
-		var rot = node.transform.basis.get_rotation_quat();
-		var pobj = { 
-			"pos": [pos.x, pos.y, pos.z], 
-			"rot": [rot.x, rot.y, rot.z, rot.w], 
-			"id": node.name
-		}
-		state["path"] += [pobj]
+func refresh_gui():
+	_gui.refresh(in_editor)
 
-	state["attach"] = []
-	for node in _attach_point_holder.get_children():
-		var pos = node.transform.origin;
-		var rot = node.transform.basis.get_rotation_quat();
-		var pobj = { 
-			"pos": [pos.x, pos.y, pos.z], 
-			"rot": [rot.x, rot.y, rot.z, rot.w], 
-			"id": node.name
-		}
-		state["attach"] += [pobj]
-		
-	return state
-	
-func set_map_state (state):
-	_world.erase_voxels()
-	for vox in state["voxels"]:
-		var vecpos = Vector3(vox.pos[0], vox.pos[1], vox.pos[2]);
-		_world.set_voxel(vecpos, vox.id)
-	_world.update_mesh()
+func gui_editor_toggle_event ():
+	in_editor = !in_editor
+	_gui.refresh(in_editor)
+	refresh_path()
 	
-	clear_children(_path_holder)
-	for pobj in state["path"]:
-		var blue = _path
-		if "start" in pobj.id:
-			blue = _path_start
-		if "end" in pobj.id:
-			blue = _path_end
-		var instance = blue.instance()
-		_path_holder.add_child(instance)
-		var vecpos = Vector3(pobj.pos[0], pobj.pos[1], pobj.pos[2]);
-		instance.transform.origin = vecpos;
-		var quat = Quat(pobj.rot[0], pobj.rot[1], pobj.rot[2], pobj.rot[3]);
-		instance.transform.basis = Basis(quat);
+func gui_start_wave_event ():
+	refresh_path()
+	_enemies.spawn()
+	_gui.refresh(in_editor)
 	
-	clear_children(_attach_point_holder)
-	for pobj in state["attach"]:
-		var blue = _attach_point
-		var instance = blue.instance()
-		_attach_point_holder.add_child(instance)
-		var vecpos = Vector3(pobj.pos[0], pobj.pos[1], pobj.pos[2]);
-		instance.transform.origin = vecpos;
-		var quat = Quat(pobj.rot[0], pobj.rot[1], pobj.rot[2], pobj.rot[3]);
-		instance.transform.basis = Basis(quat);
-		
-	
-func _save():
-	var save_game = File.new()
-	save_game.open("user://map0.json", File.WRITE)
-	save_game.store_string(to_json(get_map_state()))
-	save_game.close()
-	print("saved")
-
-func _load():
-	var save_game = File.new()
-	save_game.open("user://map0.json", File.READ)
-	var raw = save_game.get_as_text()
-	save_game.close()
-	
-	var state = parse_json(raw)
-	set_map_state(state)
-	print("loaded")
-
-func _process(delta):
-	if Input.is_action_just_released("save"):
-		_save()
-	if Input.is_action_just_released("load"):
-		_load()
-		
-func clear_children (node):
-	for n in node.get_children():
-		node.remove_child(n)
-		n.queue_free()
-
-func look_free (delta, m):
+func refresh_path():
+	if in_editor:
+		path_holder.show()
+	else:
+		var _res = path_holder.load_nodes()
+		path_holder.hide()
+	
+func selected_event (sel_name, sel_type):
+	sel.name = sel_name
+	sel.type = sel_type
+	_gui.refresh(in_editor)
+	
+	if sel_type == "turrets":
+		var info = load_turrets.info[sel.name]
+		var model = load_turrets.models[info.model_name]
+		var instance_model = model.instance()
+		instance_model.name = "preview"
+		ptr.add_child(instance_model)
+	elif sel_type != "":
+		ptr.get_node("base").visible = true
+
+func look_free (m):
 	self.transform.basis = self.transform.basis.rotated(Vector3.UP, m.x)
 	var rrrot = self.transform.basis.get_rotation_quat()
 	self.transform.basis = self.transform.basis.rotated(rrrot*Vector3.RIGHT, m.y)
 	
-func look_orbit(delta, m):
+func look_orbit(m):	
 	var diff : Vector3 = self.transform.origin - _pivot
+	_pivot_dist = diff.length()
 	var orbit : Basis = Transform.looking_at(diff, Vector3.UP).basis
 	orbit = orbit.rotated(Vector3.UP, m.x)
 	orbit = orbit.rotated(orbit.get_rotation_quat()*Vector3.RIGHT, -m.y)
-	self.transform.basis = self.transform.basis.rotated(Vector3.UP, m.x)
-	var rrrot = self.transform.basis.get_rotation_quat()
-	self.transform.basis = self.transform.basis.rotated(rrrot*Vector3.RIGHT, m.y)
 	
-	var normdiff = diff.normalized()
 	self.transform.origin = _pivot - orbit.z * _pivot_dist
+	
+	diff = self.transform.origin - _pivot
+	self.transform.basis = self.transform.basis.slerp( \
+		Transform.looking_at(-diff, Vector3.UP).basis, _orbit_timer)
+	
 
 func _move_input(delta):
-	var dir = Vector3()
-		
 	var m = _mouse
+	m *= delta
 	_mouse = Vector2()
-	
-	var orbiting = false
 
 	if Input.is_action_just_pressed("orbit"):
-		if _colliding:
-			_pivot = _collision_point
+		if placer.colliding:
+			_pivot = placer.collision_point
 			var diff : Vector3 = self.transform.origin - _pivot
-			_pivot_rot = Transform.looking_at(diff, Vector3.UP).basis.get_rotation_quat()
 			_pivot_dist = diff.length()
-			_pivot_look = Transform(Basis(), _collision_point)
+			_orbit_timer = 0
 		else: _pivot = null
 		
+	Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+	
 	if Input.is_action_pressed("orbit"):
+		Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
 		if _pivot != null:
-			orbiting = true
-			look_orbit(delta, m)
+			_orbit_timer = min(1, _orbit_timer+delta * 2)
+			look_orbit(m)
 		else:
-			look_free(delta, m)
-		
-	Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
-		
-	if Input.is_action_pressed("look"):
-		look_free(delta, m)
+			look_free(m)
+	elif Input.is_action_pressed("look"):
+		look_free(m)
 		Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
 
 	var input_movement_vector = Vector3()
@@ -221,7 +144,7 @@ func _move_input(delta):
 		input_movement_vector.y -= 1
 	input_movement_vector = input_movement_vector.normalized()
 	
-	dir = self.transform.basis.get_rotation_quat() * input_movement_vector
+	var dir : Vector3 = self.transform.basis.get_rotation_quat() * input_movement_vector
 	
 	vel += dir * delta;
 	vel *= 0.8
@@ -230,164 +153,7 @@ func _move_input(delta):
 	if collision: vel = Vector3(0, 0, 0)
 
 func _physics_process(delta):
-	if Input.is_action_just_released("cycle_forward"):
-		sel += 1
-		if sel >= len(sel_map):
-			sel = len(sel_map)-1
-	if Input.is_action_just_released("cycle_backward"):
-		sel -= 1
-		if sel < 0:
-			sel = 0
-			
 	_move_input(delta)
-	_pointer()
-	
-func check_overlap_pointer():
-	var ptr = self.get_parent().find_node("pointer");
-	
-	var overlap = false
-	var space = get_world().direct_space_state
-
-	var center = ptr.transform.origin + _normal*0.25
-	
-	var shape: = BoxShape.new()
-	shape.extents = Vector3(0.24, 0.24, 0.24)
-	
-	var params: = PhysicsShapeQueryParameters.new()
-	params.set_shape(shape)
-	params.collision_mask = 3
-	params.transform = Transform.IDENTITY
-	params.transform.origin = center
-	
-	var result = space.intersect_shape(params)
-	for body in result:
-		if !body.collider.get_parent().is_in_group("attach"): 
-			overlap = true
-			break
-	
-	for pos in _world.get_voxels():
-		var wpos = pos * 0.5
-		wpos += Vector3.ONE * (0.5 / 2)
-		var dist = (wpos - center).length_squared()
-		if dist < 0.1:
-			overlap = true
-			break
-			
-	for node in _path_holder.get_children():
-		var pos = node.transform.origin
-		var dist = (pos - center).length_squared()
-		if dist < 0.1:
-			overlap = true
-			break
-			
-	return overlap
-	
-func _inst_turret (pos, rot):
-	var instance = _turret.instance()
-	_turret_holder.add_child(instance)
-	instance.transform.origin = pos;
-	instance.transform.basis = Basis(rot);
-	instance.refresh_normal()
-	var instance_model = _turret_blues[0].instance()
-	instance_model.name = "model"
-	instance.add_child(instance_model)
-	instance.refresh_model()
-	
-func _inst_path_start (pos, rot):
-	var instance = _path_start.instance()
-	_path_holder.add_child(instance)
-	instance.transform.origin = pos + _normal * 0.25;
-	instance.transform.basis = Basis(rot);
-	
-func _inst_path (pos, rot):
-	var instance = _path.instance()
-	_path_holder.add_child(instance)
-	instance.transform.origin = pos + _normal * 0.25;
-	instance.transform.basis = Basis(rot);
-	instance.set_name("path")
-	_colliding_node.transform.basis = Basis(rot);
-	
-func _inst_path_end (pos, rot):
-	var instance = _path_end.instance()
-	_path_holder.add_child(instance)
-	instance.transform.origin = pos + _normal * 0.25
-	instance.transform.basis = Basis(rot);
-	
-func _inst_attach (pos, rot):
-	var instance = _attach_point.instance()
-	_attach_point_holder.add_child(instance)
-	instance.transform.origin = pos;
-	instance.transform.basis = Basis(rot);
-	
-func place (group, inst : FuncRef):
-	var ptr = self.get_parent().find_node("pointer");
-	if Input.is_action_just_pressed("use"):
-		if _colliding && group in _colliding_group:
-			if !check_overlap_pointer():
-				inst.call_func(ptr.transform.origin, ptr.transform.basis.get_rotation_quat())
-				
-func delete (group):
-	if Input.is_action_just_pressed("cancel"):
-		if _colliding && group in _colliding_group:
-			_colliding_node.queue_free()
-	
-func _pointer ():
-	var ptr = self.get_parent().find_node("pointer");
-	
-	var space: PhysicsDirectSpaceState = get_world().direct_space_state as PhysicsDirectSpaceState
-	var mouse2d = get_viewport().get_mouse_position()
-	var from = _camera.project_ray_origin(mouse2d)
-	var to = (from + _camera.project_ray_normal(mouse2d) * 5)
-	
-	ptr.transform.origin = to
-	
-	var mask = 1
-	if sel in [1, 2, 3]: mask = 3 
-	var result = space.intersect_ray(from, to, [], mask)
-	if result.size() > 0:
-		ptr.get_child(0).visible = true
-		
-		_colliding = true
-		_normal = result.normal;
-		_collision_point = result.position
-		
-		var node = result.collider.get_parent()
-		_colliding_node = node
-		_colliding_group = node.get_groups()
-		
-		if ("voxels" in _colliding_group or "path" in _colliding_group):
-			var cpos = result.position - _normal * (0.5 / 2)
-			var _cursor_position = (cpos / 0.5).floor() * 0.5
-			_cursor_position += Vector3.ONE * (0.5 / 2) + _normal * (0.5 / 2)
-			_collision_point = _cursor_position
-		
-		if ("attach" in _colliding_group):
-			_collision_point = node.global_transform.origin;
-			_normal = (node.global_transform.basis.get_rotation_quat() * Vector3.UP).normalized();
-		
-		ptr.transform.basis = Basis(Utils.quat_look(_normal, Vector3.UP))
-		ptr.transform.origin = _collision_point
-	else:
-		_colliding = false
-		_colliding_group = []
-		ptr.get_child(0).visible = false
-	
-	match sel:
-		0:
-			place("attach", funcref(self, "_inst_turret"))
-			delete("turret")
-		1:
-			place("voxels", funcref(self, "_inst_path_start"))
-			delete("path")
-		2:
-			place("path", funcref(self, "_inst_path"))
-			delete("path")
-		3:
-			place("path", funcref(self, "_inst_path_end"))
-			delete("path")
-		4:
-			place("voxels", funcref(self, "_inst_attach"))
-			delete("attach")
 
 func _input(event):
 	if event is InputEventMouseMotion: