Add sleeping

scripts/bed.gd

@@ -0,0 +1,5 @@
+extends Area
+
+func on_player_interact(player: Spatial) -> bool:
+	player.sleep(true, $hop_position)
+	return true

scripts/cheat_menu.gd

@@ -31,9 +31,15 @@ func _on_clear_pressed():
 	if player.has_item():
 		player.drop_item_in_hand()
 
-
 func _on_random_damage_pressed():
 	var damageable = get_tree().get_nodes_in_group("damageable")
 	if damageable.empty():
 		return
 	damageable[randi() % damageable.size()].take_damage()
+
+
+func _on_timer_2_s_pressed():
+	var game_manager = get_tree().get_nodes_in_group("game_manager")[0]
+	var day_timer = game_manager.get_node("day_timer")
+	day_timer.start(2.0)
+	day_timer.wait_time = game_manager.time_per_day

scripts/dof_focus.gd

@@ -0,0 +1,14 @@
+extends WorldEnvironment
+
+export var target: NodePath
+export var size: float = 1.0
+onready var target_node: Spatial = get_node(target)
+
+func _ready():
+	environment.dof_blur_far_enabled = true
+	environment.dof_blur_near_enabled = true
+
+func _process(delta):
+	var dist := get_viewport().get_camera().global_transform.origin.distance_to(target_node.global_transform.origin)
+	environment.dof_blur_near_distance = dist - size / 2.0
+	environment.dof_blur_far_distance = dist + size / 2.0

scripts/game_manager.gd

@@ -26,15 +26,8 @@ func _on_player_starved_to_death():
 	get_tree().paused = false
 	get_tree().quit() # go back to main menu when such a thing exists
 
-func _on_day_timer_timeout():
-	player.health -= 1
-	if player.health <= 0:
-		_on_player_starved_to_death()
-		return
-	var node = Dialogic.start("day_end")
-	node.pause_mode = PAUSE_MODE_PROCESS
-	add_child(node)
-	get_tree().paused = true
-	yield(node, "timeline_end")
-	get_tree().paused = false
+func reset_day_timer():
+	day_timer.start()
 
+func _on_day_timer_timeout():
+	player.sleep(false, null)

scripts/oven/state/cooking.gd

@@ -16,12 +16,11 @@ func enter_from(state):
 	ctx.get_node("%item_holder").remove_enabled = false
 
 	ctx.get_node("cook_timer").start()
-	ctx.get_node("%coil").set_surface_material(0, mat)
 	ctx.get_node("status_light").light_color = Color.green
 	ctx.get_node("status_light").activate()
 
 func exit_to(state):
-	ctx.get_node("%coil").set_surface_material(0, null)
+	pass
 
 func on_coin_machine_coin_requirement_met(player):
 	assert(false, "coin machine should be disabled while growing")

scripts/player/player.gd

@@ -2,7 +2,10 @@ extends KinematicBody
 
 signal starved_to_death
 
-const EPSILON = 0.0001
+const StateDefault = preload("res://scripts/player/state/default.gd")
+const StateInteracting = preload("res://scripts/player/state/interacting.gd")
+const StateSleeping = preload("res://scripts/player/state/sleeping.gd")
+
 const SPEED = 10.0
 const MAX_HEALTH = 4
 
@@ -13,27 +16,31 @@ var health: int = 4 setget set_health
 var item_in_hand
 var move_enabled: bool = true
 
-onready var move_playback = $DungMan/AnimationTree["parameters/Move/playback"]
+onready var anim_tree = $model_transform/DungMan/AnimationTree
+onready var move_playback = anim_tree["parameters/Move/playback"]
 onready var hunger_timer = $"%hunger_timer"
 
-# Called when the node enters the scene tree for the first time.
+var state = null
+
 func _ready():
 	$hitbox.set_meta("owner", self)
 	move_playback.travel("idle")
 	hunger_timer.wait_time = hunger_tick_time
 	hunger_timer.start()
+	state = StateDefault.new()
+	state.ctx = self
+	state.enter_from(null)
+	print("player: NULL -> ", state.NAME)
+
+func change_state(new_state):
+	print("player: ", state.NAME, " -> ", new_state.NAME)
+	new_state.ctx = self
+	state.exit_to(new_state)
+	new_state.enter_from(state)
+	state = new_state
 
 func _physics_process(delta):
-	if not move_enabled:
-		return
-	var input = Vector3(Input.get_axis("left", "right"), 0.0, Input.get_axis("up", "down"))
-	var motion = Plane.PLANE_XZ.project(get_viewport().get_camera().global_transform.basis.xform(input)).normalized() * SPEED
-	if motion.length_squared() > EPSILON:
-		$DungMan.look_at(global_transform.origin - motion, Vector3.UP)
-		move_playback.travel("run")
-	else:
-		move_playback.travel("idle")
-	move_and_slide(motion)
+	state.physics_process(delta)
 
 func _on_hunger_timer_timeout():
 	set_health(health - 1)
@@ -81,32 +88,8 @@ func modify_inventory(item_name, item_amount):
 	return true
 
 func _unhandled_input(event):
-	if event.is_action_pressed("action"):
-		$DungMan/AnimationTree["parameters/Activate/active"] = true
-		move_enabled = false
-		yield(get_tree().create_timer(0.2), "timeout")
-		for area in $"%TriggerVolume".get_overlapping_areas():
-			if try_trigger_interact(area):
-				break
-		move_enabled = true
+	state.unhandled_input(event)
 
-func try_trigger_interact(area):
-	var owner = area
-	if area.has_meta("owner"):
-		owner = area.get_meta("owner")
-	
-	if not owner.has_method("on_player_interact"):
-		return false
-		
-	var result = owner.on_player_interact(self)
-
-	if not result:
-		print("player failed to interacted with ", owner)
-		return
-
-	print("player interacted with ", owner)
-	return true
-	
 func drop_item_in_hand():
 	print("player dropped ", item_in_hand.item_name)
 	var item_dropped = item_in_hand
@@ -132,7 +115,10 @@ func get_item_in_hand():
 		item_to_return = drop_item_in_hand()
 	return item_to_return
 
-
 func _on_blink_timer_timeout():
-	$DungMan/AnimationTree["parameters/Blink/active"] = true
-	$DungMan/blink_timer.wait_time = rand_range(0.5, 3.0)
+	anim_tree["parameters/Blink/active"] = true
+	$"%blink_timer".wait_time = rand_range(0.5, 3.0)
+
+func sleep(made_it_to_bed: bool, hop_position: Spatial):
+	state.on_sleep(made_it_to_bed, hop_position)
+

scripts/player/state/default.gd

@@ -0,0 +1,36 @@
+extends Reference
+
+const NAME = "default"
+const EPSILON = 0.0001
+
+var ctx = null
+var anim_tree: AnimationTree
+var move_playback
+
+func _init():
+	pass
+
+func enter_from(state):
+	anim_tree = ctx.get_node("model_transform/DungMan/AnimationTree")
+	move_playback = anim_tree["parameters/Move/playback"]
+
+func exit_to(state):
+	pass
+
+func physics_process(delta):
+	var input = Vector3(Input.get_axis("left", "right"), 0.0, Input.get_axis("up", "down"))
+	var motion = Plane.PLANE_XZ.project(ctx.get_viewport().get_camera().global_transform.basis.xform(input)).normalized() * ctx.SPEED
+	if motion.length_squared() > EPSILON:
+		ctx.get_node("model_transform").look_at(ctx.global_transform.origin - motion, Vector3.UP)
+		ctx.move_playback.travel("run")
+	else:
+		ctx.move_playback.travel("idle")
+	ctx.move_and_slide(motion)
+
+func unhandled_input(event):
+	if event.is_action_pressed("action"):
+		ctx.get_tree().set_input_as_handled()
+		ctx.change_state(ctx.StateInteracting.new())
+
+func on_sleep(made_it_to_bed: bool, hop_position: Spatial):
+	ctx.change_state(ctx.StateSleeping.new(made_it_to_bed, hop_position))

scripts/player/state/interacting.gd

@@ -0,0 +1,54 @@
+extends Reference
+
+const NAME = "interacting"
+
+var ctx: KinematicBody = null
+var anim_tree: AnimationTree
+var timer: SceneTreeTimer
+
+func _init():
+	pass
+
+func enter_from(state):
+	anim_tree = ctx.get_node("model_transform/DungMan/AnimationTree")
+	anim_tree["parameters/Move/playback"].travel("idle")
+	anim_tree["parameters/Activate/active"] = true
+	timer = ctx.get_tree().create_timer(0.2)
+	timer.connect("timeout", self, "_on_timeout", [], CONNECT_ONESHOT)
+
+func exit_to(state):
+	pass
+
+func physics_process(delta):
+	pass
+
+func unhandled_input(event):
+	pass
+
+func _on_timeout():
+	for area in ctx.get_node("%TriggerVolume").get_overlapping_areas():
+		if try_trigger_interact(area):
+			break
+	if ctx.state == self:
+		ctx.change_state(ctx.StateDefault.new())
+
+func try_trigger_interact(area) -> bool:
+	var owner = area
+	if area.has_meta("owner"):
+		owner = area.get_meta("owner")
+	
+	if not owner.has_method("on_player_interact"):
+		return false
+		
+	var result = owner.on_player_interact(ctx)
+
+	if not result:
+		print("player failed to interacted with ", owner)
+		return false
+
+	print("player interacted with ", owner)
+	return true
+
+func on_sleep(made_it_to_bed: bool, hop_position: Spatial):
+	timer.disconnect("timeout", self, "_on_timeout")
+	ctx.change_state(ctx.StateSleeping.new(made_it_to_bed, hop_position))

scripts/player/state/sleeping.gd

@@ -0,0 +1,99 @@
+extends Reference
+
+const NAME = "sleeping"
+
+var ctx: KinematicBody = null
+var hop_position: Spatial
+var made_it_to_bed: bool
+var model_transform: Spatial
+var anim_player: AnimationPlayer
+var old_model_origin: Vector3
+
+var waiting := false
+
+func _init(p_made_it_to_bed: bool, p_hop_position: Spatial = null):
+	hop_position = p_hop_position
+	made_it_to_bed = p_made_it_to_bed
+
+func enter_from(state):
+	hop_position = hop_position if hop_position else ctx.get_tree().get_nodes_in_group("bed_hop_position")[0]
+	model_transform = ctx.get_node("model_transform")
+	anim_player = ctx.get_node("model_transform/node_animations")
+
+	# Pause everything but the player
+	ctx.get_tree().paused = true
+	ctx.get_node("hunger_timer").pause_mode = ctx.PAUSE_MODE_STOP
+	ctx.pause_mode = ctx.PAUSE_MODE_PROCESS
+	
+	# Drop any carried item
+	if ctx.has_item():
+		ctx.drop_item_in_hand()
+
+	# Prepare to play animation
+
+	if made_it_to_bed:
+		# Slide the player to the front of the bed
+		old_model_origin = model_transform.global_transform.origin
+		var tween = model_transform.create_tween()
+		tween.tween_property(model_transform, "global_transform:origin", hop_position.global_transform.origin, .1)
+		yield(tween, "finished")
+		# Warp the player to the right position & orientation
+		model_transform.global_transform = hop_position.global_transform
+	else:
+		# Harm the player and show message
+		ctx.set_health(ctx.health - 1)
+		var node = Dialogic.start("day_end")
+		node.pause_mode = ctx.PAUSE_MODE_PROCESS
+		ctx.add_child(node)
+		yield(node, "timeline_end")
+		# Warp the player to the right position & orientation
+		ctx.global_transform.origin = hop_position.global_transform.origin
+		model_transform.global_transform = hop_position.global_transform
+		old_model_origin = model_transform.global_transform.origin
+
+
+	# Play hop animation
+	ctx.get_node("model_transform/DungMan/AnimationTree")["parameters/Move/playback"].travel("idle")
+	anim_player.call_deferred("play", "hop_into_bed")
+	yield(anim_player, "animation_finished")
+	waiting = true
+
+	# Reset the day timer
+	for game_manager in ctx.get_tree().get_nodes_in_group("game_manager"):
+		game_manager.reset_day_timer()
+
+func exit_to(state):
+	ctx.pause_mode = ctx.PAUSE_MODE_INHERIT
+	ctx.get_node("hunger_timer").pause_mode = ctx.PAUSE_MODE_INHERIT
+	ctx.get_tree().paused = false
+
+func physics_process(delta):
+	pass
+
+func unhandled_input(event: InputEvent):
+	if not waiting:
+		return
+	if not event.is_action_pressed("action"):
+		return
+
+	ctx.get_tree().set_input_as_handled()
+
+	# Play hop out animation
+	anim_player.call_deferred("play", "hop_out_of_bed")
+	yield(anim_player, "animation_finished")
+
+	# Slide the player back to the front of the bed
+	var tween = model_transform.create_tween()
+	tween.tween_property(model_transform, "global_transform:origin", old_model_origin, .1)
+	yield(tween, "finished")
+	
+	# Show message
+	var node = Dialogic.start("wake_up")
+	node.pause_mode = ctx.PAUSE_MODE_PROCESS
+	ctx.add_child(node)
+	yield(node, "timeline_end")
+
+	ctx.change_state(ctx.StateDefault.new())
+
+func on_sleep(made_it_to_bed: bool, hop_position: Spatial):
+	assert(false, "shouldn't be able to sleep while sleeping")