brody/FirstPersonKit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Second pass on basic first-person player modifier

Browse Source
This commit is contained in:
Brody Brooks
2025-08-02 20:55:04 -07:00
parent 069fa5a5a9
commit 8a719e48ae
1 changed files with 88 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
assets/system/first_person_player.modifier.wren
View File

@ -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: io" for IO
import "luxe: assets" for Strings import "luxe: assets" for Strings
import "luxe: input" for Input
import "luxe: world" for Entity, World, Transform import "luxe: world" for Entity, World, Transform
import "luxe.project/asset" for Asset
import "luxe: math" for Math 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/character3D.modifier" for Character3D
import "luxe: system/physics/physics3D.modifier" for Physics3D
#block = data #block = data
class 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 #hidden
var decelleration: Num = 0.6 var input_target: Float3 = [0, 0, 0]
var ground_check_dist: Num = 0.15
var jump_impulse: Num = 2.25 #hidden
var jump_force: Num = 1.0 var target_speed: Num = 0
var jump_force_falloff: Num = 0.3
#hidden
var time_since_grounded: Num = 0
#hidden #hidden
var is_grounded: Bool = false var is_grounded: Bool = false
#hidden #hidden
var target_input: Float3 = [0, 0, 0] var movement_active: Bool = true
} }
#api #api
#display = "First-Person Player" #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" #icon = "luxe: image/modifier/modifier.svg"
class FirstPersonPlayer is API { class PlayerInput is API {
//add public facing API here set_movement_active(entity: Entity, active: Bool) {
system(entity).movement_active = active
}
} }
#system #system
#phase(on, tick) #phase(on, tick)
class System is Modifier { class System is Modifier {
// A common tiny value to check against
EPSILON { 0.001 }
//required atm //required atm
construct new(world: World) { super(world) } construct new(world: World) { super(world) }
init(world: World) { init(world: World) {
_world = world
Log.print("init `%(This)` in world `%(world)`") Log.print("init `%(This)` in world `%(world)`")
Physics3D.create_in(world)
_camera = Entity.get_named(world, "app.camera")
_world = world
} }
#hidden #hidden
attach(entity: Entity, data: Data) { attach(player: Entity, data: Data) {
Log.print("attached to `%(Strings.get(Entity.get_name(entity)))` `%(entity)` - `%(This)`") if (!Character3D.has(player)) return
Character3D.set.speed(player, data.speed_walk)
if (data.camera == null) { data.target_speed = data.speed_walk
data.camera = Entity.get_named(world, "app.camera")
}
} }
#hidden #hidden
tick(delta: Num) { tick(delta: Num) {
var fore = Input.event_active("up", "game") ? -1 : 0 each {|player: Entity, data: Data|
var back = Input.event_active("down", "game") ? 1 : 0 if (!Character3D.has(player)) return
var left = Input.event_active("left", "game") ? -1 : 0
var right = Input.event_active("right", "game") ? 1 : 0
each {|entity: Entity, data: Data| // Update grounded state
if (data.camera == null) return var now_grounded = check_grounded(player, data)
if (!Character3D.has(entity)) return
target_input = Transform.local_vector_to_world(data.camera, right + left, 0, fore + back) if (data.is_grounded && !now_grounded && data.time_since_grounded < data.jump_grace_time) {
target_input.y = 0 data.time_since_grounded = data.time_since_grounded + delta
Math.normalize(target_input)
target_input.y = Input.event_began("jump", "game") && data.is_grounded ? data.jump_impulse : 0
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 { if (!data.is_grounded && now_grounded && Character3D.get.velocity(player).y <= 0) {
var half_height: Num = Character3D.get.height(player) * 0.5 data.is_grounded = true
var padding: Num = Character3D.get.character_padding(player) }
var dist = half_height + padding + data.ground_check_dist
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))
} }
} }