Doors platforms triggers

quake1_example/class/_ambient.gd

@@ -6,8 +6,6 @@ var props : Dictionary
 func _qmapbsp_is_brush_visible() -> bool : return false
 func _get_properties(dict : Dictionary) : props = dict
 
-signal emit_message_state(m : String, show : bool)
-
 func _show_message_start(msg : String) : return
 func _show_message_end() : return
 

quake1_example/class/_func.gd

@@ -1,14 +1,61 @@
 extends AnimatableBody3D
 class_name QmapbspQuakeFunctionBrush
 
+# Spawnflags:
+# 256 = Not on Easy
+# 512 = Not on Normal
+# 1024 = Not on Hard
+# 2048 = Not in Deathmatch
+const NOT_IN_EASY : int = 256
+const NOT_IN_NORMAL : int = 512
+const NOT_IN_HARD : int = 1024
+const NOT_IN_DM : int = 2048
+
 var props : Dictionary
+var aabb : AABB
+
+
 func _get_properties(dict : Dictionary) : props = dict
 
-var aabb : AABB
+
+func _flag(spawnflag : int) -> bool :
+	if not props.has('spawnflags') : 
+		printerr('Missing Spawnflags! ', spawnflag, ' ', self)
+		return false
+	var result : bool = _prop('spawnflags', 0) & spawnflag
+	return result
+
+
+func _prop(name : String, def) :
+	var result = props.get(name, def)
+	if typeof(result) == typeof(def) : return result
+	match typeof(def) :
+		TYPE_NIL:
+			result = def
+		TYPE_BOOL:
+			result = result.to_bool()
+		TYPE_INT:
+			result = result.to_int()
+		TYPE_FLOAT:
+			result = result.to_float()
+		TYPE_STRING:
+			result = str(result)
+		_ :
+			result = def
+	return result
+
 
 func _gen_aabb() :
-	#aabb.position = global_position
 	for m in get_children() :
 		if m is GeometryInstance3D :
 			aabb = aabb.merge(m.get_aabb())
 	aabb.position += global_position
+
+
+func _touch_vertical(nor : Vector3) -> bool :
+	return (abs(nor.x) > 0.9 || abs(nor.z) > 0.9)
+
+
+func _touch_horizontal(nor : Vector3) -> bool :
+	return abs(nor.y) > 0.9
+

quake1_example/class/_trigger.gd

@@ -1,53 +1,114 @@
 extends Area3D
 class_name QmapbspQuakeTrigger
+
 var props : Dictionary
 var v : QmapbspQuakeViewer
+var blocked : bool = false
+
+signal emit_message_state(m : String, show : bool)
+
+
 func _qmapbsp_is_brush_visible() -> bool : return false
 func _get_properties(dict : Dictionary) : props = dict
 
-signal emit_message_state(m : String, show : bool)
+
+func _flag(spawnflag : int) -> bool :
+	if not props.has('spawnflags') : 
+		printerr('Missing Spawnflags! ', spawnflag, ' ', self)
+		return false
+	var result : bool = _prop('spawnflags', 0) & spawnflag
+	return result
+
+
+func _prop(name : String, def) :
+	var result = props.get(name, def)
+	if typeof(result) == typeof(def) : return result
+	match typeof(def) :
+		TYPE_NIL:
+			result = def
+		TYPE_BOOL:
+			result = result.to_bool()
+		TYPE_INT:
+			result = result.to_int()
+		TYPE_FLOAT:
+			result = result.to_float()
+		TYPE_STRING:
+			result = str(result)
+		_ :
+			result = def
+	return result
+
 
 func _show_message_start(msg : String) :
 	emit_message_state.emit(msg, true)
 
+
 func _show_message_end() :
 	emit_message_state.emit('', false)
 
+
 func _init() -> void :
 	monitorable = false
 	collision_layer = 0b1000
 	collision_mask = 0b1000
 
+
 func _ready() :
 	v = get_meta(&'viewer')
 	body_entered.connect(_bo_en)
 	body_exited.connect(_bo_ex)
 
+
 func _bo_en(b : Node3D) :
-	_message()
+	if b == self : return
+	blocked = true
 	_trigger(b)
+	_message()
+
 
 func _bo_ex(b : Node3D) :
+	if b == self : return
+	blocked = false
+	_trigger_exit(b)
 	_show_message_end()
 
-func _message() :
-	var message = props.get('message', null)
-	if message is StringName :
+
+func _message(msg : String = '') :
+	var message = _prop('message', msg)
+	if not message.is_empty() :
 		_show_message_start(message)
 
+
 func _trigger(b : Node3D) :
-	var delay : float = props.get('delay', '0').to_float()
+	var delay : float = _prop('delay', 0)
 	if delay > 0 :
 		get_tree().create_timer(delay, false).timeout.connect(
 			_trigger_now.bind(b)
 		)
 	else :
 		_trigger_now(b)
 
+
+func _trigger_exit(b : Node3D) :
+	var delay : float = _prop('delay', 0)
+	if delay > 0 :
+		get_tree().create_timer(delay, false).timeout.connect(
+			_trigger_exit_now.bind(b)
+		)
+	else :
+		_trigger_exit_now(b)
+
+
 func _trigger_now(b : Node3D) :
-	var target : String = props.get("target", '')
+	var target : String = _prop('target', '')
 	if !target.is_empty() :
 		v.trigger_targets(target, b)
-	var killtarget : String = props.get("killtarget", '')
+	var killtarget : String = _prop('killtarget', '')
 	if !killtarget.is_empty() :
 		v.killtarget(killtarget)
+
+
+func _trigger_exit_now(b: Node3D) :
+	var target : String = _prop('target', '')
+	if !target.is_empty() :
+		v.trigger_targets_exit(target, b)

quake1_example/class/func_button.gd

@@ -1,29 +1,142 @@
-extends QmapbspQuakeFunctionDoor
+extends QmapbspQuakeFunctionBrush
 class_name QmapbspQuakeFunctionButton
 
-func _motion_f(destroy_tween : bool = false) :
-	super(destroy_tween)
+# Properties default:
+const SPEED : int = 40
+const LIP : int = 4
+const WAIT : int = 1
+const ANGLE : int = 0
+
+# 0 : "Steam metal"
+# 1 : "Wooden clunk"
+# 2 : "Metallic clink"
+# 3 : "In-out"
+const audio_paths := [
+	"buttons/airbut1.wav",
+	"buttons/switch21.wav",
+	"buttons/switch02.wav",
+	"buttons/switch04.wav"
+]
+
+var tween : Tween
+var add : Vector3
+var dura : float
+var wait : int
+var noise : String
+var viewer : QmapbspQuakeViewer
+var open : bool = false
+var open_pos : Vector3
+var close_pos : Vector3
+var init_pos : Vector3
+
+var player : AudioStreamPlayer3D
+var player_end : bool = false
+var links : Array[QmapbspQuakeFunctionDoor]
+var trigger : QmapbspQuakeTrigger
+
+signal emit_message_once(m : String)
+
+
+func _map_ready() :
+	init_pos = position
+	add_to_group(&'buttons')
+	_gen_aabb()
+	_calc_add()
+	_calc_anim_pos()
+	_get_sounds()
+
+
+func _calc_add() :
+	viewer = get_meta(&'viewer')
+	wait = _prop('wait', WAIT)
+	var s : float = get_meta('scale', 32.0)
+	var angle : int = _prop('angle', ANGLE)
+	var speed : int = _prop('speed', SPEED) / s
+	var lip : float = _prop('lip', LIP) / s
+	if angle == -1 :
+		add = Vector3(0.0, aabb.size.y - lip, 0.0)
+	elif angle == -2 :
+		add = Vector3(0.0, -aabb.size.y + lip, 0.0)
+	else :
+		var rot := (angle / 180.0) * PI
+		var lip_v := Vector3(lip, lip, lip)
+		add = Vector3.BACK.rotated(Vector3.UP, rot) * (aabb.size - (aabb.size + lip_v))
+	dura = add.length() / speed
+
+
+func _calc_anim_pos() :
+	open_pos = position + add
+	close_pos = position 
+
+
+func _target_pos() -> Vector3 : 
+	if open : return close_pos
+	else : return open_pos
+
+
+func _move() :
+	if tween : return
+
+	tween = create_tween()
+	if not open : tween.tween_callback(_play_snd)
+	tween.tween_property(self, ^'position', _target_pos(), dura)
+	tween.finished.connect(_move_end)
+	if wait > 0 and not open : tween.tween_interval(wait)
+
+	open = !open
+
+
+func _move_end() :
+	tween.kill()
+	tween = null
+
+	if wait == -1 : return # stay open
+
+	if open : _move() # close
+
+
+func _player_touch(p : QmapbspQuakePlayer, pos : Vector3, nor : Vector3) :
+	_trigger(p)
+
+
+func _trigger(b : Node3D) :
+	if tween : return
+	if open : return
+
+	_move()
+
+	var delay : float = _prop('delay', 0.0)
+	if delay > 0 :
+		get_tree().create_timer(delay, false).timeout.connect(
+			_trigger_now.bind(b)
+		)
+	else :
+		_trigger_now(b)
+
+
+func _trigger_now(b: Node3D) :
+	if not props.has('target') : return
 	for t in get_tree().get_nodes_in_group(
-		'T_' + props.get('target')
+		'T_' + _prop('target', '')
 	) :
 		if !t : continue
 		if !t.has_method(&'_trigger') : continue
 		t._trigger(self)
 
-func _def_lip() -> String : return '4'
-func _def_wait() -> String : return '1'
-func _no_linking() -> bool : return true
 
-func _play_snd(idx : int) :
-	if open : super(idx)
+func _get_sounds() :
+	noise = audio_paths[_prop('sounds', 0)]
 
-func _get_sounds(sounds : int) :
-	if sounds == 0 :
-		streams = [
-			'buttons/airbut1.wav', ''
-		]
-	else :
-		super(sounds)
 
-func _player_touch(p : QmapbspQuakePlayer, pos : Vector3, nor : Vector3) :
-	_trigger(p)
+func _make_player() :
+	player = AudioStreamPlayer3D.new()
+	add_child(player)
+
+
+func _play_snd(interrupt : bool = false) :
+	if !player : _make_player()
+	if player.is_playing() and not interrupt : return
+	if noise.is_empty() : return
+	player.stream = viewer.hub.load_audio(noise)
+	player.play()
+