130 lines
4.0 KiB
Plaintext
130 lines
4.0 KiB
Plaintext
import "system/player_input.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: math" for Math
|
|
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 acceleration: Num = 2.0
|
|
var decelleration: Num = 3.0
|
|
var speed_run: Num = 25.0
|
|
var speed_walk: Num = 15.0
|
|
var ground_check_dist: Num = 0.05
|
|
var jump_impulse: Num = 20
|
|
var jump_grace_time: Num = 0.1
|
|
|
|
#hidden
|
|
var input_target: Float3 = [0, 0, 0]
|
|
|
|
#hidden
|
|
var target_speed: Num = 0
|
|
|
|
#hidden
|
|
var time_since_grounded: Num = 0
|
|
|
|
#hidden
|
|
var is_grounded: Bool = false
|
|
}
|
|
|
|
#api
|
|
#display = "Player Input"
|
|
#desc = "**A new modifier**. You should update this description"
|
|
#icon = "luxe: image/modifier/modifier.svg"
|
|
class PlayerInput is API {
|
|
//add public facing API here
|
|
}
|
|
|
|
#system
|
|
#phase(on, tick)
|
|
class System is Modifier {
|
|
EPSILON { 0.001 }
|
|
|
|
//required atm
|
|
construct new(world: World) { super(world) }
|
|
|
|
init(world: World) {
|
|
Log.print("init `%(This)` in world `%(world)`")
|
|
|
|
_camera = Entity.get_named(world, "app.camera")
|
|
_world = world
|
|
}
|
|
|
|
#hidden
|
|
attach(player: Entity, data: Data) {
|
|
Log.print("Attached!")
|
|
if (!Character3D.has(player)) return
|
|
Character3D.set.speed(player, data.speed_walk)
|
|
data.target_speed = data.speed_walk
|
|
}
|
|
|
|
#hidden
|
|
tick(delta: Num) {
|
|
each {|player: Entity, data: Data|
|
|
if (!Character3D.has(player)) return
|
|
|
|
// Update grounded state
|
|
var now_grounded = check_grounded(player, data)
|
|
|
|
if (data.is_grounded && !now_grounded && data.time_since_grounded < data.jump_grace_time) {
|
|
data.time_since_grounded = data.time_since_grounded + delta
|
|
|
|
if (data.time_since_grounded >= data.jump_grace_time) {
|
|
data.is_grounded = false
|
|
}
|
|
}
|
|
|
|
if (!data.is_grounded && now_grounded && Character3D.get.velocity(player).y <= 0) {
|
|
data.is_grounded = true
|
|
}
|
|
|
|
// Update movement input
|
|
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
|
|
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)
|
|
|
|
var sprint: Bool =
|
|
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
|
|
}
|
|
|
|
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))
|
|
}
|
|
|
|
} |