initial commit: canny cat basic movement, bouncing, some gridmap tiles for levels

objects/canny_cat.gd

@@ -0,0 +1,117 @@
+extends CharacterBody3D
+
+
+@export var power_scale: float
+@export var power_sensitivity: float
+@export var power_threshold: float
+
+@export_group("Movement")
+@export var gravity: float
+@export var friction: float
+@export var stop_threshold: float
+
+@export_group("Camera", "camera_")
+@export_range(0,90,1,"radians_as_degrees") var camera_low_angle: float
+@export_range(0,90,1,"radians_as_degrees") var camera_high_angle: float
+@export_range(0,90,0.5,"radians_as_degrees") var camera_yaw_sensitivity: float
+@export_range(0,90,0.5,"radians_as_degrees") var camera_pitch_sensitivity: float
+
+@export_group("Node References")
+@export var state_chart: StateChart
+@export var power_indicator: Node3D
+@export var camera_arm: SpringArm3D
+@export var wall_detector: PhysicsBody3D
+
+
+var power: float = 0.0:
+	set(value):
+		power = clampf(value, 0.0, 1.0)
+
+var charging_power: bool = false
+var prev_velocity: Vector3 = Vector3.ZERO
+
+
+func _ready() -> void:
+	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
+
+
+func _physics_process(delta: float) -> void:
+	prev_velocity = velocity
+	move_and_slide()
+	state_chart.set_expression_property(&"velocity", velocity)
+
+
+func _unhandled_input(event: InputEvent) -> void:
+	if event.is_action_pressed(&"charge_shot"):
+		state_chart.send_event(&"charge_pressed")
+	if event.is_action_released(&"charge_shot"):
+		state_chart.send_event(&"charge_released")
+	
+	if event is InputEventMouseMotion:
+		camera_arm.rotate_y(event.screen_relative.x * camera_yaw_sensitivity)
+		
+		if charging_power:
+			power += event.screen_relative.y * power_sensitivity
+		else:
+			camera_arm.rotation.x -= event.screen_relative.y * camera_pitch_sensitivity
+			camera_arm.rotation.x = clampf(camera_arm.rotation.x, -camera_high_angle, -camera_low_angle)
+
+
+#region Charging
+func _start_charge() -> void:
+	charging_power = true
+	power_indicator.visible = true
+	power_indicator.scale.z = 0.0
+	power = 0.0
+
+func _update_charge(_delta: float) -> void:
+	power_indicator.scale.z = power
+	var camera_z = get_viewport().get_camera_3d().global_transform.basis.z
+	camera_z.y = 0.0
+	power_indicator.look_at(power_indicator.global_position + camera_z, Vector3.UP, true)
+
+func _end_charge() -> void:
+	charging_power = false
+	power_indicator.visible = false
+	if power >= power_threshold:
+		var camera_z = get_viewport().get_camera_3d().global_transform.basis.z
+		camera_z.y = 0.0
+		velocity = -camera_z.normalized() * power * power_scale
+		prev_velocity = velocity
+		_bounce_on_walls(1.0/60.0)
+#endregion
+
+
+#region Moving
+func _apply_gravity(delta: float) -> void:
+	velocity.y -= gravity * delta
+
+func _slow_to_stop(delta: float) -> void:
+	if is_on_floor():
+		var new_velocity = velocity
+		new_velocity.y = 0.0
+		new_velocity = new_velocity.move_toward(Vector3.ZERO, friction * delta)
+		if new_velocity.length_squared() <= stop_threshold * stop_threshold:
+			new_velocity = Vector3.ZERO
+		new_velocity.y = velocity.y
+		velocity = new_velocity
+
+func _bounce_on_walls(delta: float = 0.0) -> void:
+	var h_vel = (prev_velocity * Vector3(1.0, 0.0, 1.0))
+	var col = move_and_collide(h_vel * delta, true)
+	if col:
+		if col.get_angle() > floor_max_angle:
+			h_vel = h_vel.bounce(col.get_normal())
+			velocity.x = h_vel.x
+			velocity.z = h_vel.z
+	
+	#var h_vel = (prev_velocity * Vector3(1.0, 0.0, 1.0))
+	#if not h_vel.is_zero_approx():
+		#wall_detector.look_at(wall_detector.global_position - h_vel)
+		#wall_detector.force_shapecast_update()
+		#if wall_detector.is_colliding():
+			#for i in wall_detector.get_collision_count():
+				#h_vel = h_vel.bounce(wall_detector.get_collision_normal(i))
+			#velocity.x = h_vel.x
+			#velocity.z = h_vel.z
+#endregion