Second pass on basic first-person player modifier

assets/system/first_person_player.modifier.wren

@@ -1,88 +1,130 @@
-import "fpkit: system/first_person_player.modifier.api" for API, Modifier, APIGet, APISet, Wire, Fields, State, Op
+import "system/first_person_player.modifier.api" for API, Modifier, APIGet, APISet, Wire, Fields, State, Op
 import "luxe: io" for IO
 import "luxe: assets" for Strings
+import "luxe: input" for Input
 import "luxe: world" for Entity, World, Transform
-import "luxe.project/asset" for Asset
 import "luxe: math" for Math
-import "luxe: system/physics/physics3D.modifier" for Phyiscs3D
+import "luxe.project/asset" for Asset
 import "luxe: system/physics/character3D.modifier" for Character3D
+import "luxe: system/physics/physics3D.modifier" for Physics3D
 
 #block = data
 class Data {
-	var camera: Link
+  var acceleration: Num = 0.9
+  var decelleration: Num = 0.5
+  var speed_run: Num = 25.0
+  var speed_walk: Num = 15.0
+  var ground_check_dist: Num = 0
+  var jump_impulse: Num = 20
+  var jump_grace_time: Num = 0.1
 
-	var acceleration: Num = 0.6
-	var decelleration: Num = 0.6
-	var ground_check_dist: Num = 0.15
+  #hidden
+  var input_target: Float3 = [0, 0, 0]
 
-	var jump_impulse: Num = 2.25
-	var jump_force: Num = 1.0
-	var jump_force_falloff: Num = 0.3
+  #hidden
+  var target_speed: Num = 0
+
+  #hidden
+  var time_since_grounded: Num = 0
 
   #hidden
   var is_grounded: Bool = false
 
   #hidden
-	var target_input: Float3 = [0, 0, 0]
+  var movement_active: Bool = true
 }
 
 #api
 #display = "First-Person Player"
-#desc = "**A new modifier**. You should update this description" 
+#desc = "**Player movement system**. Takes the player's input and moves the player's character." 
 #icon = "luxe: image/modifier/modifier.svg"
-class FirstPersonPlayer is API {
-	//add public facing API here
+class PlayerInput is API {
+  set_movement_active(entity: Entity, active: Bool) {
+	system(entity).movement_active = active
+  }
 }
 
 #system
 #phase(on, tick)
 class System is Modifier {
+	// A common tiny value to check against
+	EPSILON { 0.001 }
 
 	//required atm
 	construct new(world: World) { super(world) }
 
 	init(world: World) {
-		_world = world
 		Log.print("init `%(This)` in world `%(world)`")
-		Physics3D.create_in(world)
+
+		_camera = Entity.get_named(world, "app.camera")
+		_world = world
 	}
 
 	#hidden
-	attach(entity: Entity, data: Data) {
-		Log.print("attached to `%(Strings.get(Entity.get_name(entity)))` `%(entity)` - `%(This)`")
-
-		if (data.camera == null) {
-			data.camera = Entity.get_named(world, "app.camera")
-		}
+	attach(player: Entity, data: Data) {
+		if (!Character3D.has(player)) return
+		Character3D.set.speed(player, data.speed_walk)
+		data.target_speed = data.speed_walk
 	}
  
 	#hidden
 	tick(delta: Num) {
-		var fore = Input.event_active("up", "game") ? -1 : 0
-		var back = Input.event_active("down", "game") ? 1 : 0
-		var left = Input.event_active("left", "game") ? -1 : 0
-		var right = Input.event_active("right", "game") ? 1 : 0
+		each {|player: Entity, data: Data|
+			if (!Character3D.has(player)) return
 
-		each {|entity: Entity, data: Data|
-			if (data.camera == null) return
-			if (!Character3D.has(entity)) return
+			// Update grounded state
+			var now_grounded = check_grounded(player, data)
 
-			target_input = Transform.local_vector_to_world(data.camera, right + left, 0, fore + back)
-			target_input.y = 0
-			Math.normalize(target_input)
-			target_input.y = Input.event_began("jump", "game") && data.is_grounded ? data.jump_impulse : 0
+			if (data.is_grounded && !now_grounded && data.time_since_grounded < data.jump_grace_time) {
+				data.time_since_grounded = data.time_since_grounded + delta
 
-			Character3D.set.input(entity, input)
+				if (data.time_since_grounded >= data.jump_grace_time) {
+					data.is_grounded = false
 				}
 			}
 			
-	check_if_grounded(player: Entity, data: Data): Bool {
-		var half_height: Num = Character3D.get.height(player) * 0.5
-		var padding: Num = Character3D.get.character_padding(player)
-		var dist = half_height + padding + data.ground_check_dist
+			if (!data.is_grounded && now_grounded && Character3D.get.velocity(player).y <= 0) {
+				data.is_grounded = true
+			}
 
-		var result = Physics3D.cast_ray_closest(_world, Transform.get_pos_world(player), [0,-1,0], dist)
+			// Turn this into a Float3 of (Left/Right, 0, Forward/Backward) that is relative to the player's facing direction
+			data.input_target = Math.normalized(Math.mult(Transform.local_dir_to_world(_camera, right + left, 0, fore + back), [1, 0, 1]))
+			data.input_target = move_toward_vec(Character3D.get.input(player), data.input_target, data, delta * 6)
 
-		return result != null
+			if (data.is_grounded) Character3D.set.speed(player, Input.event_active("run", "game") ? data.speed_run : data.speed_walk)
+
+			if (Input.event_began("jump", "game") && data.is_grounded) {
+				data.time_since_grounded = 0
+				data.input_target = Math.add(data.input_target, [0, data.jump_impulse / Character3D.get.speed(player), 0])
+				data.is_grounded = false
+
+				Transform.translate(player, 0, data.ground_check_dist + this.EPSILON, 0)
+			} else {
+				data.input_target = [data.input_target.x, 0, data.input_target.z]
+			}
+			
+			Character3D.set.input(player, data.input_target)
+		}
+	}
+
+	check_grounded(player: Entity, data: Data): Bool {
+		var height = Character3D.get.height(player) * 0.5
+		return Physics3D.cast_ray_closest(_world, Transform.get_pos_world(player), [0,-1,0], height + data.ground_check_dist) != null
+	}
+
+	// Utility Methods
+		move_toward_num(from: Num, to: Num, data: Data, delta: Num) {
+			if (from < to) {
+				return Math.min(Math.lerp(from, to, delta * data.acceleration), to)
+			} else if (from > to) {
+				return Math.max(Math.lerp(from, to, delta * data.decelleration), to)
+			}
+		}
+
+		move_toward_vec(from: Float3, to: Float3, data: Data, delta: Num) {
+			var pos_delta: Float3 = Math.sub(to, from)
+			var pos_len: Num = Math.length(pos_delta)
+			var speed = Math.length(from) < Math.length(to) ? delta * data.acceleration : delta * data.decelleration
+			return pos_len <= delta || pos_len < this.EPSILON ? to : Math.add(from, Math.scale(Math.div(pos_delta, pos_len), speed))
 		}
 }