diff options
Diffstat (limited to 'scripts/movement.gd')
| -rw-r--r-- | scripts/movement.gd | 385 |
1 files changed, 385 insertions, 0 deletions
diff --git a/scripts/movement.gd b/scripts/movement.gd new file mode 100644 index 0000000..1601053 --- /dev/null +++ b/scripts/movement.gd @@ -0,0 +1,385 @@ +extends KinematicBody + +var vel = Vector3() +var rot = Quat() +var rotx = Quat() +var roty = Quat() + +var sensitivity_mouse = 0.1 + +var ray + +var _normal = Vector3.ZERO +var _colliding = false +var _colliding_group = [] +var _colliding_node + +var _world + +var _turret : PackedScene +var _turret_holder +var _turret_blues = [] + +var _attach_point +var _attach_point_holder + +var _path_start +var _path +var _path_end +var _path_holder + +var sel = 0; +var sel_map = [ + "turrets", "path start", "path", "path end", "attach point" +] + +func _ready(): + ray = find_node("RayCast") + + ray.enabled = true + ray.collide_with_areas = false + + Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) + + _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") + + _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") + + 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 = {} + + 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] + + 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] + + 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() + + 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); + + 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() + +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() + + print(raw) + var state = parse_json(raw) + set_map_state(state) + +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 _move_input(delta): + var dir = Vector3() + + var input_movement_vector = Vector3() + if Input.is_action_pressed("movement_forward"): + input_movement_vector.z -= 1 + if Input.is_action_pressed("movement_backward"): + input_movement_vector.z += 1 + if Input.is_action_pressed("movement_left"): + input_movement_vector.x -= 1 + if Input.is_action_pressed("movement_right"): + input_movement_vector.x += 1 + if Input.is_action_pressed("movement_up"): + input_movement_vector.y += 1 + if Input.is_action_pressed("movement_down"): + input_movement_vector.y -= 1 + input_movement_vector = input_movement_vector.normalized() + + if Input.is_action_just_pressed("ui_cancel"): + if Input.get_mouse_mode() == Input.MOUSE_MODE_VISIBLE: + Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) + else: + Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) + + dir = rot * input_movement_vector + + vel += dir * delta; + vel *= 0.8 + + var collision = self.move_and_collide(vel) + 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 + + if "path" in sel_map[sel]: + ray.collision_mask = 3 + else: + ray.collision_mask = 1 + + _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 place_turret (): + var ptr = self.get_parent().find_node("pointer"); + if Input.is_action_just_pressed("use"): + if _colliding && "attach" in _colliding_group: + if !check_overlap_pointer(): + var instance = _turret.instance() + _turret_holder.add_child(instance) + instance.transform.origin = ptr.transform.origin; + instance.transform.basis = Basis(ptr.transform.basis.get_rotation_quat()); + instance.refresh_normal() + var instance_model = _turret_blues[0].instance() + instance_model.name = "model" + instance.add_child(instance_model) + instance.refresh_model() + + if Input.is_action_just_pressed("cancel"): + if _colliding && "turrets" in _colliding_group: + _colliding_node.queue_free() + +func place_start_path (): + var ptr = self.get_parent().find_node("pointer"); + if Input.is_action_just_pressed("use"): + if _colliding && "voxels" in _colliding_group: + if !check_overlap_pointer(): + var instance = _path_start.instance() + _path_holder.add_child(instance) + instance.transform.origin = ptr.transform.origin + _normal * 0.25; + instance.transform.basis = Basis(ptr.transform.basis.get_rotation_quat()); + + if Input.is_action_just_pressed("cancel"): + if _colliding && "path" in _colliding_group: + _colliding_node.queue_free() + +func place_path (): + var ptr = self.get_parent().find_node("pointer"); + if Input.is_action_just_pressed("use"): + if _colliding && "path" in _colliding_group: + if !check_overlap_pointer(): + var instance = _path.instance() + _path_holder.add_child(instance) + instance.transform.origin = ptr.transform.origin + _normal * 0.25; + instance.transform.basis = Basis(ptr.transform.basis.get_rotation_quat()); + instance.set_name("path") + + _colliding_node.transform.basis = Basis(ptr.transform.basis.get_rotation_quat()); + + if Input.is_action_just_pressed("cancel"): + if _colliding && "path" in _colliding_group: + _colliding_node.queue_free() + +func place_path_end (): + var ptr = self.get_parent().find_node("pointer"); + if Input.is_action_just_pressed("use"): + if _colliding && "path" in _colliding_group: + if !check_overlap_pointer(): + var instance = _path_end.instance() + _path_holder.add_child(instance) + instance.transform.origin = ptr.transform.origin + _normal * 0.25 + instance.transform.basis = Basis(ptr.transform.basis.get_rotation_quat()); + + if Input.is_action_just_pressed("cancel"): + if _colliding && "path" in _colliding_group: + _colliding_node.queue_free() + +func place_attach (): + var ptr = self.get_parent().find_node("pointer"); + if Input.is_action_just_pressed("use"): + if _colliding && "voxels" in _colliding_group: + if !check_overlap_pointer(): + var instance = _attach_point.instance() + _attach_point_holder.add_child(instance) + instance.transform.origin = ptr.transform.origin; + instance.transform.basis = Basis(ptr.transform.basis.get_rotation_quat()); + + if Input.is_action_just_pressed("cancel"): + if _colliding && "attach" in _colliding_group: + _colliding_node.queue_free() + +func _pointer (): + var ptr = self.get_parent().find_node("pointer"); + + match sel: + 0: + place_turret() + 1: + place_start_path() + 2: + place_path() + 3: + place_path_end() + 4: + place_attach() + + var from = self.transform.origin + var to = from + (rot * Vector3.FORWARD) * 5 + + ptr.transform.origin = to + + if ray.is_colliding(): + _colliding = true + _normal = ray.get_collision_normal().normalized(); + var pos = ray.get_collision_point() + + var node = ray.get_collider().get_parent() + _colliding_node = node + _colliding_group = node.get_groups() + + if ("voxels" in _colliding_group or "path" in _colliding_group): + var _cursor_position = ray.get_collision_point() - _normal * (0.5 / 2) + var tran = 0.5 *_cursor_position + tran += Vector3.ONE * (0.5 / 2) + _normal* (0.5 / 2) + pos = tran + + if ("attach" in _colliding_group): + pos = 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 = pos + else: + _colliding = false + _colliding_group = [] + +func _input(event): + if event is InputEventMouseMotion: + var mouse = Vector2( + deg2rad(event.relative.x) * -1, + deg2rad(event.relative.y) * -1) + mouse *= sensitivity_mouse + rotx *= Quat(Vector3(0, mouse.x, 0)) + roty *= Quat(Vector3(mouse.y, 0, 0)) + + rot = (rotx * roty).normalized() + self.transform.basis = Basis(rot) |