Phazorknight · nvvtype · Aug 14, 2024 · Aug 14, 2024 · Aug 14, 2024 · Aug 14, 2024
diff --git a/COGITO/CogitoObjects/cogito_object.gd b/COGITO/CogitoObjects/cogito_object.gd
@@ -8,13 +8,28 @@ var interaction_nodes : Array[Node]
 var cogito_properties : CogitoProperties = null
 var properties : int
 
+var submerged := false
+
+
+var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")
 
 func _ready():
 	self.add_to_group("interactable")
-	self.add_to_group("Persist") #Adding object to group for persistence
+	self.add_to_group("Persist")  # Adding object to group for persistence
+
 	find_interaction_nodes()
 	find_cogito_properties()
 
+	# hacky solution of getting the properties of a RigidBody3D when applicable.
+	# this is necessary for object floating because of how the fluid_interactor handles checking if an object should float or not.
+	if use_collision_shapes and self.has_method("get_shape_owners"):
+		for owner_id in self.call("get_shape_owners"):
+			var collision = self.call("shape_owner_get_owner", owner_id)
+			# Ensure that the collision is of type CollisionShape3D
+			if collision is CollisionShape3D:
+				fluid_interactor.add_collision_shape(collision)
+
+
 
 # Future method to set object state when a scene state file is loaded.
 func set_state():	
@@ -63,3 +78,68 @@ func _on_body_exited(body: Node) -> void:
 	# Using this check to only call interactions on other Cogito Objects. #TODO: could be a better check...
 	if body.has_method("save") and cogito_properties:
 		cogito_properties.check_for_reaction_timer_interrupt(body)
+
+var in_fluid := false
+@export var can_float : bool = false
+signal entered_to_fluid(Vector3)
+signal exited_to_fluid(Vector3)
+@export var use_collision_shapes := true
+@export var fluid_damp := 4.0
+@onready var fluid_interactor := FluidInteractor3D.new()
+
+func fluid_area_enter(fluid):
+	self.linear_velocity = self.linear_velocity.lerp(Vector3.ZERO, 0.2)
+	fluid_interactor.fluid_area_enter(fluid)
+	in_fluid = true
+	self.linear_velocity = self.linear_velocity / 4
+	# Apply damping to reduce excessive movement
+	self.linear_velocity = self.linear_velocity.lerp(Vector3.ZERO, 0.2)
+
+func fluid_area_exit(fluid):
+	fluid_interactor.fluid_area_exit(fluid)
+	in_fluid = false
+
+@export var fluid_damping_factor: float = 0.1  # Adjust for more gradual damping
+var buoyancy_smooth_factor : float = 0.5
+
+func _physics_process(delta: float) -> void:
+	if !in_fluid:
+		#if we're not in water, exit to prevent running unncessary code.
+		return
+
+	# Again, all of this is a very hacky solution to grab the functions and variables inherit to RigidBody3Ds that may not be present
+	# in Node3D, which CogitoObject needs to be or it breaks stuff I learned (the fun way).
+	if self.has_method("apply_force"): #we're just checking to see if it's a RigidBody3D, which apply_force() can be called in
+		var linear_velocity = self.get("linear_velocity") #this is the strategy for getting RigidBody3D specific variables and functions.
+
+		if !can_float:
+			# this is another early exit.  If the object can't float, apply a sinking effect to it.
+			# this line of code is honestly MAGIC.
+			linear_velocity = linear_velocity.lerp(Vector3.ZERO, 0.2)
+			self.set("linear_velocity", linear_velocity)
+			return
+		# if it can float, we do the floating calculations.  This stuff all uses the floatable_body addon because trying to figure out
+		# how to code all that was killing me.
+		# the first argument of process requires a Transform3D.  So if global_transform.basis isn't working, try just global_transform.
+		# you can add some print statements into process to figure out what the problem is.  Usually it's the Transform3D is returning a position that's 
+		# too high for the top of the "water"
+		fluid_interactor.process(self.global_transform.basis, self.get("mass"), gravity)
+
+		for floater in fluid_interactor.get_floaters():
+			if floater.is_just_entered_to_fluid():
+				entered_to_fluid.emit(floater.position)
+			if floater.is_just_exited_from_fluid():
+				exited_to_fluid.emit(floater.position)
+
+		if not fluid_interactor.float_force.is_zero_approx():
+			var current_force = self.get("linear_velocity")
+			var desired_force = fluid_interactor.float_force
+			var smoothed_force = current_force.lerp(desired_force, buoyancy_smooth_factor)
+			self.call("apply_force", smoothed_force, fluid_interactor.float_position)
+
+			# Apply gradual damping
+			self.set("linear_damp", fluid_damping_factor)
+			self.set("angular_damp", fluid_damping_factor)
+		else:
+			self.set("linear_damp", 0.0)
+			self.set("angular_damp", 0.0)
diff --git a/COGITO/CogitoObjects/cogito_player.gd b/COGITO/CogitoObjects/cogito_player.gd
@@ -21,7 +21,7 @@ var is_showing_ui : bool
 ## Damage the player takes if falling from great height. Leave at 0 if you don't want to use this.
 @export var fall_damage : int
 ## Fall velocity at which fall damage is triggered. This is negative y-Axis. -5 is a good starting point but might be a bit too sensitive.
-@export var fall_damage_threshold : float = -5
+@export var fall_damage_threshold : float = -10
 
 ## Inventory resource that stores the player inventory.
 @export var inventory_data : CogitoInventory
@@ -114,6 +114,11 @@ var gravity_vec : Vector3 = Vector3.ZERO
 var head_offset : Vector3 = Vector3.ZERO
 var is_jumping : bool = false
 var is_in_air : bool = false
+var is_in_water : bool = false
+var was_in_water_recently : bool = false
+#this timer is for the fall damage, to kind of give a bit of a safety net for players falling too fast out of water.
+var was_in_water_timer : float = 0.0
+var was_in_water_timer_reset : float = 0.5
 
 var joystick_h_event
 var joystick_v_event
@@ -148,12 +153,15 @@ var slide_audio_player : AudioStreamPlayer3D
 @onready var neck: Node3D = $Body/Neck
 @onready var head: Node3D = $Body/Neck/Head
 @onready var eyes: Node3D = $Body/Neck/Head/Eyes
+@onready var hand_location = $Body/Neck/Head/Eyes/Camera/HandLocation
+
 @onready var camera: Camera3D = $Body/Neck/Head/Eyes/Camera
 @onready var animationPlayer: AnimationPlayer = $Body/Neck/Head/Eyes/AnimationPlayer
 
 @onready var standing_collision_shape: CollisionShape3D = $StandingCollisionShape
 @onready var crouching_collision_shape: CollisionShape3D = $CrouchingCollisionShape
 @onready var crouch_raycast: RayCast3D = $CrouchRayCast
+#@onready var staircheck_ray_cast_3d = %StaircheckRaycast
 @onready var sliding_timer: Timer = $SlidingTimer
 @onready var jump_timer: Timer = $JumpCooldownTimer
 
@@ -196,8 +204,6 @@ func _ready():
 		health_attribute.death.connect(_on_death)
 	# Save reference to stamina attribute for movements that require stamina checks (null if not found)
 	stamina_attribute = player_attributes.get("stamina")
-	# Save reference to visibilty attribute for that require visibility checks (null if not found)
-	visibility_attribute = player_attributes.get("visibility")
 	# Hookup sanity attribute to visibility attribute
 	var sanity_attribute = player_attributes.get("sanity")
 	if sanity_attribute and visibility_attribute:
@@ -411,15 +417,31 @@ func _process_on_ladder(_delta):
 
 var jumped_from_slide = false
 
+func water_check() -> bool:
+	if get_tree().get_nodes_in_group("water_area").all(func(area): return !area.overlaps_body(self)):
+		return false
+	else:
+		return true
+
 func _physics_process(delta):
 	#if is_movement_paused:
 		#return
-
+
+	if is_climbing:
+		if climb_unstuck_timer > 0.0:
+			climb_unstuck_timer -= delta
+		else:
+			is_climbing = false
+
 	if on_ladder:
 		_process_on_ladder(delta)
 		return
+
+
+
 
 	# Getting input direction
+
 	var input_dir
 	if !is_movement_paused:
 		input_dir = Input.get_vector("left", "right", "forward", "back")
@@ -447,8 +469,29 @@ func _physics_process(delta):
 		stand_after_roll = false
 
 	var crouched_jump = false
+
+
+		#hacked in solution for swimming using WaterMaker3D's built in water area.
+	if water_check():
+		is_in_water = true
+		_handle_water_physics(delta)
+		return
+	if is_in_water:
+		is_in_water = false
+		was_in_water_recently = true
+		was_in_water_timer = was_in_water_timer_reset
+
+	if is_climbing:
+		return
+	if was_in_water_recently :
+		if was_in_water_timer > 0.0:
+			was_in_water_timer -= delta
+		else:
+			was_in_water_recently = false
+
 	if is_on_floor():
 		# reset our slide-jump state
+		reset_water_gravity = false
 		jumped_from_slide = false
 	else:
 		# if we're jumping from a pure crouch (no slide), then we want to lock our crouch state
@@ -580,7 +623,7 @@ func _physics_process(delta):
 			animationPlayer.play("landing")
 
 		# Taking fall damage
-		if fall_damage > 0 and last_velocity.y <= fall_damage_threshold:
+		if fall_damage > 0 and last_velocity.y <= fall_damage_threshold and !(is_in_water or was_in_water_recently):
 			#health_component.subtract(fall_damage)
 			decrease_attribute("health",fall_damage)
 
@@ -862,3 +905,94 @@ class StepResult:
 	var normal: Vector3 = Vector3.ZERO
 	var is_step_up: bool = false
 
+var cam_aligned_wish_dir := Vector3.ZERO
+
+var swim_up_speed : float = 10.0
+var ledge_climb_height : float = 0.5
+var ledge_climb_offset : float = 0.75
+
+@onready var underwatercast = %Mouth
+
+
+func _handle_water_physics(delta) -> void:
+	is_climbing = false
+	var input_dir: Vector2
+	if !is_movement_paused:
+		input_dir = Input.get_vector("left", "right", "forward", "back")
+	else:
+		input_dir = Vector2.ZERO
+	input_dir = -input_dir
+
+	var look_vector = camera.get_camera_transform().basis
+	var direction = (look_vector * Vector3(input_dir.x, 0, input_dir.y)).normalized()
+
+	if not is_on_floor():
+		if !reset_water_gravity:
+			velocity.y -= gravity * 0.1 * delta  # Less gravity effect in water
+		else:
+			reset_water_gravity = false
+
+	# Apply directional movement with water resistance
+	velocity -= direction * WALKING_SPEED * delta
+
+	# Handle swimming upwards when the jump button is pressed
+	if Input.is_action_pressed("jump"):
+		if ledge_raycast.is_colliding():
+			var collider = ledge_raycast.get_collider()
+			if collider != WaterMaker3D and !underwatercast.is_colliding():
+				var ledge_position = detect_ledge()
+				if ledge_position != Vector3.INF:
+					ledge_climb(ledge_position)
+				else:
+					velocity.y += swim_up_speed * delta
+			else:
+				velocity.y += swim_up_speed * delta
+		else:
+			velocity.y += swim_up_speed * delta
+
+	# Dampen velocity to simulate water resistance, but maintain some consistent movement
+	velocity = velocity.lerp(Vector3.ZERO, delta * 2)
+	move_and_slide()
+
+var is_climbing : bool = false
+var reset_water_gravity : bool = false
+var climb_unstuck_timer : float = 0.0
+
+func ledge_climb(place_to_land: Vector3):
+	# Set climbing state to prevent other movements
+	is_climbing = true
+	climb_unstuck_timer = 0.5
+	# Create a Tween for smooth movement
+	var tween = get_tree().create_tween()
+
+	# Vertical movement (climb up)
+	var vertical_climb = Vector3(global_transform.origin.x, place_to_land.y + 1.0, global_transform.origin.z)
+	tween.tween_property(self, "global_transform:origin", vertical_climb, 0.4)
+
+	# Wait for the vertical climb to complete
+	await tween.finished
+	tween.stop()
+
+	# Forward movement (move onto the ledge)
+	var forward = global_transform.origin + (-global_transform.basis.z * 1.1)
+	tween.tween_property(self, "global_transform:origin", forward, 0.3)
+
+	# Wait for the forward movement to complete
+	await tween.finished
+	tween.stop()
+
+	# Reset climbing state
+	reset_water_gravity = true
+	is_climbing = false
+
+
+@onready var ledge_raycast = %LedgeRayCast3D
+
+func detect_ledge() -> Vector3:
+	# Cast the ray downwards to detect the top of the object
+	ledge_raycast.force_raycast_update()
+	if ledge_raycast.is_colliding():
+		var collision_point = ledge_raycast.get_collision_point()
+		return collision_point  # This is where the player should move to
+	else:
+		return Vector3.INF
diff --git a/COGITO/Components/Attributes/BreathAttribute.tscn b/COGITO/Components/Attributes/BreathAttribute.tscn
@@ -0,0 +1,12 @@
+[gd_scene load_steps=3 format=3 uid="uid://tdontgpampvk"]
+
+[ext_resource type="Script" path="res://COGITO/Components/Attributes/cogito_breath_attribute.gd" id="1_5aiua"]
+[ext_resource type="Texture2D" uid="uid://bi27fw31w4ssi" path="res://addons/cyclops_level_builder/art/icons/select_face.svg" id="2_ia6uq"]
+
+[node name="CogitoBreathAttribute" type="Node"]
+script = ExtResource("1_5aiua")
+attribute_name = "breath"
+attribute_display_name = "Oxygen"
+attribute_color = Color(0.457334, 0.630597, 1, 1)
+attribute_icon = ExtResource("2_ia6uq")
+value_max = 100.0
diff --git a/COGITO/Components/Attributes/cogito_breath_attribute.gd b/COGITO/Components/Attributes/cogito_breath_attribute.gd
@@ -0,0 +1,36 @@
+extends CogitoAttribute
+
+# amount of damage received when breath is empty
+@export var suffocation_damage : float = 1.0 
+var player : CogitoPlayer
+
+# how frequently the player takes ticks of suffocation damage
+@export var suffocation_damage_timer : float = 1.5
+var suffocation_timer_current : float
+# how fast oxygen regenerates in breathable areas
+@export var breath_regen_speed : float = 0.5
+
+func _ready():
+	player = get_parent()
+	suffocation_timer_current = suffocation_damage_timer
+
+func out_of_breath(delta : float):
+	if suffocation_timer_current <= 0.0:
+		player.decrease_attribute("health", suffocation_damage)
+		suffocation_timer_current = suffocation_damage_timer
+	else:
+		suffocation_timer_current -= delta
+
+func check_breath():
+	if !player.is_head_submerged():
+		if suffocation_timer_current < suffocation_damage_timer:
+			# just make sure the timer resets for consistency underwater
+			suffocation_timer_current = suffocation_damage_timer
+		player.increase_attribute("breath", breath_regen_speed, ConsumableItemPD.ValueType.CURRENT)
+	else:
+		player.decrease_attribute("breath", breath_regen_speed / 4)
+
+func _process(delta):
+	check_breath()
+	if value_current <= 0:
+		out_of_breath(delta)