creatura/methods.lua

676 lines
20 KiB
Lua
Raw Normal View History

2022-02-10 16:32:53 -08:00
-------------
-- Methods --
-------------
local pi = math.pi
local abs = math.abs
local ceil = math.ceil
2023-01-26 14:35:09 -08:00
local max = math.max
2022-02-10 16:32:53 -08:00
local random = math.random
local atan2 = math.atan2
local sin = math.sin
local cos = math.cos
2022-02-10 16:32:53 -08:00
local function diff(a, b) -- Get difference between 2 angles
return atan2(sin(b - a), cos(b - a))
2022-02-10 16:32:53 -08:00
end
local function clamp(val, _min, _max)
if val < _min then
val = _min
elseif _max < val then
val = _max
2022-02-10 16:32:53 -08:00
end
return val
end
local vec_add = vector.add
2022-07-24 21:15:06 -07:00
local vec_normal = vector.normalize
local vec_len = vector.length
2022-07-04 15:27:17 -07:00
local vec_dist = vector.distance
2022-02-10 16:32:53 -08:00
local vec_dir = vector.direction
local vec_dot = vector.dot
2022-02-10 16:32:53 -08:00
local vec_multi = vector.multiply
local vec_sub = vector.subtract
2022-02-10 16:32:53 -08:00
local yaw2dir = minetest.yaw_to_dir
local dir2yaw = minetest.dir_to_yaw
--[[local function debugpart(pos, time, tex)
minetest.add_particle({
pos = pos,
texture = tex or "creatura_particle_red.png",
2022-09-08 01:51:12 -07:00
expirationtime = time or 0.1,
glow = 16,
2022-10-12 14:37:44 -07:00
size = 24
})
end]]
2022-02-10 16:32:53 -08:00
---------------------
-- Local Utilities --
---------------------
local get_node_def = creatura.get_node_def
2022-10-12 14:37:44 -07:00
--local get_node_height = creatura.get_node_height_from_def
2023-01-14 00:11:45 -08:00
function creatura.get_collision(self, dir, range)
local pos, yaw = self.object:get_pos(), self.object:get_yaw()
2022-09-08 01:51:12 -07:00
if not pos then return end
2023-01-26 14:35:09 -08:00
local width, height = self.width or 0.5, self.height or 1
dir = dir or yaw2dir(yaw)
pos.x = pos.x + dir.x * width
pos.z = pos.z + dir.z * width
2023-01-14 00:11:45 -08:00
local cos_yaw = cos(yaw)
local sin_yaw = sin(yaw)
2023-01-14 00:11:45 -08:00
2023-01-26 14:35:09 -08:00
local width_i = width / ceil(width)
local height_i = height / ceil(height)
2023-01-14 00:11:45 -08:00
local pos_x, pos_y, pos_z = pos.x, pos.y, pos.z
local dir_x, dir_y, dir_z = dir.x, dir.y, dir.z
2023-01-26 14:35:09 -08:00
local pos2 = {x = pos_x, y = pos_y, z = pos_z}
local collision
2023-01-14 00:11:45 -08:00
2023-01-26 14:35:09 -08:00
pos.y = pos.y + height * 0.5
range = range or 4
local low_score
for _ = 0, range do
if collision then return collision end
pos_x = pos_x + dir_x
pos_y = pos_y + dir_y
pos_z = pos_z + dir_z
2023-01-14 00:11:45 -08:00
2023-01-26 14:35:09 -08:00
pos2.y = pos_y
for x = -width, width, width_i do
pos2.x = cos_yaw * ((pos_x + x) - pos_x) + pos_x
pos2.z = sin_yaw * ((pos_x + x) - pos_x) + pos_z
2023-01-14 00:11:45 -08:00
2023-01-26 14:35:09 -08:00
for y = height, 0, -height_i do
if y < self.stepheight or 1.1 then break end
pos2.y = pos_y + y
2023-01-14 00:11:45 -08:00
2023-01-26 14:35:09 -08:00
if get_node_def(pos2).walkable then
local score = abs(pos.y - pos2.y) * vec_dot(dir, vec_dir(pos, pos2))
if not low_score
or score < low_score then
low_score = score
2023-01-14 00:11:45 -08:00
collision = pos2
end
2022-09-08 01:51:12 -07:00
end
end
end
end
end
2023-01-14 00:11:45 -08:00
creatura.get_collision_ranged = creatura.get_collision
2022-08-09 15:18:47 -07:00
local get_collision = creatura.get_collision
2022-07-06 15:58:19 -07:00
local function get_avoidance_dir(self)
2022-06-21 09:44:10 -07:00
local pos = self.object:get_pos()
2022-07-04 15:27:17 -07:00
if not pos then return end
2022-08-08 15:52:48 -07:00
local _, col_pos = get_collision(self)
if col_pos then
2022-07-24 21:15:06 -07:00
local vel = self.object:get_velocity()
2022-08-09 15:18:47 -07:00
vel.y = 0
local vel_len = vec_len(vel) * (1 + (self.step_delay or 0))
local ahead = vec_add(pos, vec_normal(vel))
2022-10-12 14:37:44 -07:00
local avoidance_force = vec_sub(ahead, col_pos)
avoidance_force.y = 0
avoidance_force = vec_multi(vec_normal(avoidance_force), (vel_len > 1 and vel_len) or 1)
2022-07-24 21:15:06 -07:00
return vec_dir(pos, vec_add(ahead, avoidance_force))
2022-06-21 09:44:10 -07:00
end
end
2023-01-14 00:11:45 -08:00
local function get_collision_single(pos, water)
local pos2 = {x = pos.x, y = pos.y, z = pos.z}
local n_def = get_node_def(pos2)
if n_def.walkable
or (water and (n_def.groups.liquid or 0) > 0) then
pos2.y = pos.y + 1
n_def = get_node_def(pos2)
local col_max = n_def.walkable or (water and (n_def.groups.liquid or 0) > 0)
pos2.y = pos.y - 1
local col_min = col_max and (n_def.walkable or (water and (n_def.groups.liquid or 0) > 0))
if col_min then
return pos
else
pos2.y = pos.y + 1
return pos2
end
end
end
2023-01-26 14:35:09 -08:00
function creatura.get_avoidance_lift(self, pos2, range)
range = ceil(max(range or 1, 0.5))
local height_half = (self.height or 1) * 0.5
local center_y = pos2.y + height_half
local check_pos = {x = pos2.x, y = center_y, z = pos2.z}
-- Find ceiling and floor collisions
local def
2023-01-26 14:35:09 -08:00
local ceil_pos
local floor_pos
for i = 1, range, 0.5 do -- 0.5 increment increases accuracy
if ceil_pos and floor_pos then break end
check_pos.y = center_y + i
def = creatura.get_node_def(check_pos)
2023-01-26 14:35:09 -08:00
if not ceil_pos
and (def.walkable
or minetest.get_item_group(def.name, "liquid") > 0) then
2023-01-26 14:35:09 -08:00
ceil_pos = check_pos
end
check_pos.y = center_y - i
def = creatura.get_node_def(check_pos)
2023-01-26 14:35:09 -08:00
if not floor_pos
and (def.walkable
or minetest.get_item_group(def.name, "liquid") > 0) then
2023-01-26 14:35:09 -08:00
floor_pos = check_pos
end
end
-- Calculate direction to average point of collisions
check_pos.y = center_y
local offset = {x = 0, y = height_half + range, z = 0}
if not ceil_pos then ceil_pos = vec_add(check_pos, offset) end
if not floor_pos then floor_pos = vec_sub(check_pos, offset) end
local dist_up = ceil_pos.y - center_y
local dist_down = floor_pos.y - center_y
local altitude = (dist_up + dist_down) / 2
return ((check_pos.y + altitude) - center_y) / range * 2
end
function creatura.get_avoidance_lift_aquatic(self, pos2, range)
range = ceil(max(range or 1, 0.5))
local height_half = (self.height or 1) * 0.5
local center_y = pos2.y + height_half
local check_pos = {x = pos2.x, y = center_y, z = pos2.z}
-- Find ceiling and floor collisions
local ceil_pos
local floor_pos
for i = 1, range, 0.5 do -- 0.5 increment increases accuracy
if ceil_pos and floor_pos then break end
check_pos.y = center_y + i
if not ceil_pos
and minetest.get_item_group(creatura.get_node_def(check_pos).name, "liquid") < 1 then
ceil_pos = check_pos
end
check_pos.y = center_y - i
if not floor_pos
and minetest.get_item_group(creatura.get_node_def(check_pos).name, "liquid") < 1 then
floor_pos = check_pos
end
end
-- Calculate direction to average point of collisions
check_pos.y = center_y
local offset = {x = 0, y = height_half + range, z = 0}
if not ceil_pos then ceil_pos = vec_add(check_pos, offset) end
if not floor_pos then floor_pos = vec_sub(check_pos, offset) end
local dist_up = ceil_pos.y - center_y
local dist_down = floor_pos.y - center_y
local altitude = (dist_up + dist_down) / 2
return ((check_pos.y + altitude) - center_y) / range * 2
end
2023-01-14 00:11:45 -08:00
----------------------------
-- Context Based Steering --
----------------------------
local steer_directions = {
vec_normal({x = 1, y = 0, z = 0}),
vec_normal({x = 1, y = 0, z = 1}),
vec_normal({x = 0, y = 0, z = 1}),
vec_normal({x = -1, y = 0, z = 0}),
vec_normal({x = -1, y = 0, z = -1}),
vec_normal({x = 0, y = 0, z = -1}),
vec_normal({x = 1, y = 0, z = -1}),
vec_normal({x = -1, y = 0, z = 1})
}
2023-01-14 00:11:45 -08:00
-- Context Methods
function creatura.get_context_default(self, goal, steer_dir, interest, danger, range)
local pos = self.object:get_pos()
if not pos then return end
2023-01-26 14:35:09 -08:00
local width, height = self.width or 0.5, self.height or 1
local y_offset = math.min(self.stepheight or 1.1, height)
2023-01-14 00:11:45 -08:00
pos.y = pos.y + y_offset
local collision
local ray = minetest.raycast(pos, vec_add(pos, vec_multi(steer_dir, width + range)), false, false)
local pointed = ray:next()
if pointed
and pointed.type == "node"
and creatura.get_node_def(pointed.under).walkable then
collision = pointed.under
end
if collision then
local dir2goal = vec_normal(vec_dir(pos, goal))
local dir2col = vec_normal(vec_dir(pos, collision))
local dist2col = vec_dist(pos, collision) - width
local dot_score = vec_dot(dir2col, dir2goal)
local dist_score = (range - dist2col) / range
interest = interest - dot_score
danger = dist_score
end
return interest, danger
end
function creatura.get_context_large(self, goal, steer_dir, interest, danger, range)
local pos = self.object:get_pos()
if not pos then return end
2023-01-26 14:35:09 -08:00
local width, height = self.width or 0.5, self.height or 1
2023-01-14 00:11:45 -08:00
local y_offset = math.min(self.stepheight or height)
pos.y = pos.y + y_offset
local collision = creatura.get_collision(self, steer_dir, range)
if collision then
local dir2goal = vec_normal(vec_dir(pos, goal))
local dir2col = vec_normal(vec_dir(pos, collision))
local dist2col = vec_dist(pos, collision) - width
local dot_score = vec_dot(dir2col, dir2goal)
local dist_score = (range - dist2col) / range
interest = interest - dot_score
danger = dist_score
end
return interest, danger
end
function creatura.get_context_small(self, goal, steer_dir, interest, danger, range)
local pos = self.object:get_pos()
if not pos then return end
pos = vector.round(pos)
2023-01-26 14:35:09 -08:00
local width = self.width or 0.5
2023-01-14 00:11:45 -08:00
local collision = get_collision_single(vec_add(pos, steer_dir))
if collision then
local dir2goal = vec_normal(vec_dir(pos, goal))
local dir2col = vec_normal(vec_dir(pos, collision))
local dist2col = vec_dist(pos, collision) - width
local dot_score = vec_dot(dir2col, dir2goal)
local dist_score = (range - dist2col) / range
interest = interest - dot_score
danger = dist_score
end
return interest, danger
end
function creatura.get_context_small_aquatic(self, goal, steer_dir, interest, danger, range)
local pos = self.object:get_pos()
if not pos then return end
pos = vector.round(pos)
2023-01-26 14:35:09 -08:00
local width = self.width or 0.5
local pos2 = vec_add(pos, steer_dir)
local collision = minetest.get_item_group(get_node_def(pos2).name, "liquid") < 1 and pos2
2023-01-14 00:11:45 -08:00
if collision then
local dir2goal = vec_normal(vec_dir(pos, goal))
local dir2col = vec_normal(vec_dir(pos, collision))
local dist2col = vec_dist(pos, collision) - width
local dot_score = vec_dot(dir2col, dir2goal)
local dist_score = (range - dist2col) / range
interest = interest - dot_score
danger = dist_score
end
return interest, danger
end
-- Calculate Steering
function creatura.calc_steering(self, goal, get_context, range)
if not goal then return end
get_context = get_context or creatura.get_context_default
local pos, yaw = self.object:get_pos(), self.object:get_yaw()
if not pos or not yaw then return end
range = math.max(range or 2, 2)
local dir2goal = vec_normal(vec_dir(pos, goal))
local output_dir = {x = 0, y = dir2goal.y, z = 0}
2023-01-14 00:11:45 -08:00
-- Cached variables
local dir
for _, _dir in ipairs(steer_directions) do
2023-01-14 00:11:45 -08:00
dir = {x = _dir.x, y = dir2goal.y, z = _dir.z}
local score = vec_dot(dir2goal, dir)
local interest = clamp(score, 0, 1)
local danger = 0
2023-01-14 00:11:45 -08:00
if interest > 0 then -- Direction is within 90 degrees of goal
interest, danger = get_context(self, goal, dir, interest, danger, range)
end
2023-01-14 00:11:45 -08:00
score = interest - danger
output_dir = vector.add(output_dir, vector.multiply(dir, score))
end
2023-01-14 00:11:45 -08:00
return vec_normal(output_dir)
end
2022-10-12 14:37:44 -07:00
2023-01-14 00:11:45 -08:00
-- DEPRECATED
function creatura.get_context_steering(self, goal, range, water)
local context = creatura.get_context_default
local width, height = self.width, self.height
if width > 0.5
or height > 1 then
context = creatura.get_context_large
elseif water then
context = creatura.get_context_small_aquatic
2022-10-12 14:37:44 -07:00
end
2023-01-14 00:11:45 -08:00
return creatura.calc_steering(self, goal, context, range)
2022-10-12 14:37:44 -07:00
end
2022-02-10 16:32:53 -08:00
-------------
-- Actions --
-------------
-- Actions are more specific behaviors used
-- to compose a Utility.
2022-07-04 15:27:17 -07:00
-- Move
2022-02-10 16:32:53 -08:00
2022-06-21 09:44:10 -07:00
function creatura.action_move(self, pos2, timeout, method, speed_factor, anim)
local timer = timeout or 4
local function func(_self)
timer = timer - _self.dtime
2022-06-21 09:44:10 -07:00
self:animate(anim or "walk")
local safe = true
if _self.max_fall
and _self.max_fall > 0 then
local pos = self.object:get_pos()
if not pos then return end
safe = _self:is_pos_safe(pos2)
end
if timer <= 0
or not safe
2022-06-21 09:44:10 -07:00
or _self:move_to(pos2, method or "creatura:obstacle_avoidance", speed_factor or 0.5) then
return true
end
end
self:set_action(func)
2022-02-10 16:32:53 -08:00
end
2022-07-04 15:27:17 -07:00
creatura.action_walk = creatura.action_move -- Support for outdated versions
2022-02-10 16:32:53 -08:00
-- Idle
function creatura.action_idle(self, time, anim)
local timer = time
local function func(_self)
_self:set_gravity(-9.8)
_self:halt()
_self:animate(anim or "stand")
timer = timer - _self.dtime
if timer <= 0 then
return true
end
end
self:set_action(func)
2022-02-10 16:32:53 -08:00
end
-- Rotate on Z axis in random direction until 90 degree angle is reached
function creatura.action_fallover(self)
local zrot = 0
local init = false
local dir = 1
2022-10-14 20:07:51 -07:00
local rot = self.object:get_rotation()
local function func(_self)
2022-02-10 16:32:53 -08:00
if not init then
_self:animate("stand")
if random(2) < 2 then
dir = -1
end
2022-02-10 16:32:53 -08:00
init = true
end
2022-10-14 20:07:51 -07:00
rot = _self.object:get_rotation()
local goal = (pi * 0.5) * dir
2022-10-14 20:07:51 -07:00
local step = _self.dtime
if step > 0.5 then step = 0.5 end
zrot = zrot + (pi * dir) * step
_self.object:set_rotation({x = rot.x, y = rot.y, z = zrot})
2022-02-10 16:32:53 -08:00
if (dir > 0 and zrot >= goal)
or (dir < 0 and zrot <= goal) then return true end
2022-02-10 16:32:53 -08:00
end
self:set_action(func)
end
----------------------
-- Movement Methods --
----------------------
-- Pathfinding
2023-01-14 09:39:19 -08:00
--[[local function trim_path(pos, path)
2022-07-24 21:15:06 -07:00
if #path < 2 then return end
local trim = false
local closest
for i = #path, 1, -1 do
if not path[i] then break end
2022-07-24 21:15:06 -07:00
if (closest
and vec_dist(pos, path[i]) > vec_dist(pos, path[closest]))
or trim then
table.remove(path, i)
trim = true
else
closest = i
end
end
return path
2023-01-14 09:39:19 -08:00
end]]
2022-07-24 21:15:06 -07:00
2023-01-14 00:11:45 -08:00
creatura.register_movement_method("creatura:theta_pathfind", function(self)
2022-06-21 09:44:10 -07:00
local path = {}
2022-07-04 15:27:17 -07:00
local box = clamp(self.width, 0.5, 1.5)
2022-07-06 15:58:19 -07:00
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
2022-06-21 09:44:10 -07:00
if not pos then return end
2023-01-14 00:11:45 -08:00
pos.y = pos.y + 0.5
2022-06-21 09:44:10 -07:00
-- Return true when goal is reached
2022-07-04 15:27:17 -07:00
if vec_dist(pos, goal) < box * 1.33 then
2022-07-06 15:58:19 -07:00
_self:halt()
2022-06-21 09:44:10 -07:00
return true
end
2022-08-12 21:59:32 -07:00
self:set_gravity(-9.8)
2022-06-21 09:44:10 -07:00
-- Get movement direction
2023-01-14 00:11:45 -08:00
local steer_to = get_avoidance_dir(_self, goal)
2022-06-21 09:44:10 -07:00
local goal_dir = vec_dir(pos, goal)
2023-01-14 00:11:45 -08:00
if steer_to then
2022-07-06 15:58:19 -07:00
goal_dir = steer_to
2023-01-14 00:11:45 -08:00
if #path < 1 then
path = creatura.find_theta_path(_self, pos, goal, _self.width, _self.height, 300) or {}
2022-07-24 21:15:06 -07:00
end
2023-01-14 00:11:45 -08:00
end
if #path > 0 then
goal_dir = vec_dir(pos, path[2] or path[1])
if vec_dist(pos, path[1]) < box then
2022-07-04 15:27:17 -07:00
table.remove(path, 1)
end
2022-06-21 09:44:10 -07:00
end
2022-07-06 15:58:19 -07:00
local yaw = _self.object:get_yaw()
2022-06-21 09:44:10 -07:00
local goal_yaw = dir2yaw(goal_dir)
2022-07-06 15:58:19 -07:00
local speed = abs(_self.speed or 2) * speed_factor or 0.5
local turn_rate = abs(_self.turn_rate or 5)
2022-06-21 09:44:10 -07:00
-- Movement
local yaw_diff = abs(diff(yaw, goal_yaw))
2022-07-04 15:27:17 -07:00
if yaw_diff < pi * 0.25
2022-07-06 15:58:19 -07:00
or steer_to then
_self:set_forward_velocity(speed)
2022-06-21 09:44:10 -07:00
else
2022-07-06 15:58:19 -07:00
_self:set_forward_velocity(speed * 0.33)
2022-06-21 09:44:10 -07:00
end
if yaw_diff > 0.1 then
2022-07-06 15:58:19 -07:00
_self:turn_to(goal_yaw, turn_rate)
end
end
2022-06-21 09:44:10 -07:00
return func
end)
2022-02-10 16:32:53 -08:00
2023-01-14 00:11:45 -08:00
creatura.register_movement_method("creatura:pathfind", function(self)
2022-06-21 09:44:10 -07:00
local path = {}
2023-01-14 00:11:45 -08:00
local steer_to
local steer_int = 0
self:set_gravity(-9.8)
2022-07-06 15:58:19 -07:00
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
2023-01-14 00:11:45 -08:00
if not pos or not goal then return end
if vec_dist(pos, goal) < clamp(self.width, 0.5, 1) then
2022-07-06 15:58:19 -07:00
_self:halt()
2022-07-04 15:27:17 -07:00
return true
2022-06-21 09:44:10 -07:00
end
2023-01-14 00:11:45 -08:00
-- Calculate Movement
local turn_rate = abs(_self.turn_rate or 5)
local speed = abs(_self.speed or 2) * speed_factor or 0.5
steer_int = (not steer_to and steer_int > 0 and steer_int - _self.dtime) or 1 / math.max(speed, 1)
steer_to = (steer_int <= 0 and creatura.calc_steering(_self, goal)) or steer_to
2022-07-06 15:58:19 -07:00
if steer_to then
2023-01-26 14:35:09 -08:00
path = creatura.find_lvm_path(_self, pos, goal, _self.width, _self.height, 400) or {}
2023-01-14 00:11:45 -08:00
if #path > 0 then
steer_to = vec_dir(pos, path[2] or path[1])
2022-07-04 15:27:17 -07:00
end
end
2023-01-14 00:11:45 -08:00
-- Apply Movement
_self:turn_to(dir2yaw(steer_to or vec_dir(pos, goal)), turn_rate)
_self:set_forward_velocity(speed)
end
return func
end)
-- Steering
creatura.register_movement_method("creatura:steer_small", function(self)
local steer_to
local steer_int = 0
self:set_gravity(-9.8)
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
if not pos or not goal then return end
if vec_dist(pos, goal) < clamp(self.width, 0.5, 1) then
_self:halt()
return true
2022-06-21 09:44:10 -07:00
end
2023-01-14 00:11:45 -08:00
-- Calculate Movement
2022-07-06 15:58:19 -07:00
local turn_rate = abs(_self.turn_rate or 5)
2023-01-14 00:11:45 -08:00
local speed = abs(_self.speed or 2) * speed_factor or 0.5
steer_int = (steer_int > 0 and steer_int - _self.dtime) or 1 / math.max(speed, 1)
steer_to = (steer_int <= 0 and creatura.calc_steering(_self, goal)) or steer_to
-- Apply Movement
_self:turn_to(dir2yaw(steer_to or vec_dir(pos, goal)), turn_rate)
_self:set_forward_velocity(speed)
end
return func
end)
creatura.register_movement_method("creatura:steer_large", function(self)
local steer_to
local steer_int = 0
self:set_gravity(-9.8)
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
if not pos or not goal then return end
if vec_dist(pos, goal) < clamp(self.width, 0.5, 1) then
_self:halt()
return true
2022-06-21 09:44:10 -07:00
end
2023-01-14 00:11:45 -08:00
-- Calculate Movement
local turn_rate = abs(_self.turn_rate or 5)
local speed = abs(_self.speed or 2) * speed_factor or 0.5
steer_int = (steer_int > 0 and steer_int - _self.dtime) or 1 / math.max(speed, 1)
steer_to = (steer_int <= 0 and creatura.calc_steering(_self, goal, creatura.get_context_large)) or steer_to
-- Apply Movement
_self:turn_to(dir2yaw(steer_to or vec_dir(pos, goal)), turn_rate)
_self:set_forward_velocity(speed)
end
2022-06-21 09:44:10 -07:00
return func
end)
2022-02-10 16:32:53 -08:00
2023-01-26 14:35:09 -08:00
creatura.register_movement_method("creatura:walk_simple", function(self)
self:set_gravity(-9.8)
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
if not pos or not goal then return end
if vec_dist(pos, goal) < clamp(self.width, 0.5, 1) then
_self:halt()
return true
end
-- Calculate Movement
local turn_rate = abs(_self.turn_rate or 5)
local speed = abs(_self.speed or 2) * speed_factor or 0.5
-- Apply Movement
_self:turn_to(dir2yaw(vec_dir(pos, goal)), turn_rate)
_self:set_forward_velocity(speed)
end
return func
end)
2023-01-14 00:11:45 -08:00
-- Deprecated
creatura.register_movement_method("creatura:context_based_steering", function(self)
local steer_to
local steer_int = 0
self:set_gravity(-9.8)
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
if not pos or not goal then return end
if vec_dist(pos, goal) < clamp(self.width, 0.5, 1) then
_self:halt()
return true
end
-- Calculate Movement
local turn_rate = abs(_self.turn_rate or 5)
local speed = abs(_self.speed or 2) * speed_factor or 0.5
steer_int = (steer_int > 0 and steer_int - _self.dtime) or 1 / math.max(speed, 1)
steer_to = (steer_int <= 0 and creatura.calc_steering(_self, goal, creatura.get_context_large)) or steer_to
-- Apply Movement
_self:turn_to(dir2yaw(steer_to or vec_dir(pos, goal)), turn_rate)
_self:set_forward_velocity(speed)
end
return func
end)
2022-02-10 16:32:53 -08:00
2022-07-06 15:58:19 -07:00
creatura.register_movement_method("creatura:obstacle_avoidance", function(self)
2022-07-04 15:27:17 -07:00
local box = clamp(self.width, 0.5, 1.5)
2022-08-12 21:59:32 -07:00
local steer_to
2022-09-08 01:51:12 -07:00
local steer_timer = 0.25
2022-07-06 15:58:19 -07:00
local function func(_self, goal, speed_factor)
local pos = _self.object:get_pos()
2022-06-21 09:44:10 -07:00
if not pos then return end
2022-08-12 21:59:32 -07:00
self:set_gravity(-9.8)
2022-07-04 15:27:17 -07:00
-- Return true when goal is reached
if vec_dist(pos, goal) < box * 1.33 then
2022-07-06 15:58:19 -07:00
_self:halt()
2022-07-04 15:27:17 -07:00
return true
end
2022-09-08 01:51:12 -07:00
steer_timer = (steer_timer > 0 and steer_timer - _self.dtime) or 0.25
2022-06-21 09:44:10 -07:00
-- Get movement direction
2022-09-08 01:51:12 -07:00
steer_to = (steer_timer > 0 and steer_to) or (steer_timer <= 0 and get_avoidance_dir(_self))
2022-08-12 21:59:32 -07:00
local goal_dir = steer_to or vec_dir(pos, goal)
2022-08-13 20:06:48 -07:00
pos.y = pos.y + goal_dir.y
2022-07-06 15:58:19 -07:00
local yaw = _self.object:get_yaw()
2022-06-21 09:44:10 -07:00
local goal_yaw = dir2yaw(goal_dir)
2022-07-06 15:58:19 -07:00
local speed = abs(_self.speed or 2) * speed_factor or 0.5
local turn_rate = abs(_self.turn_rate or 5)
2022-07-04 15:27:17 -07:00
-- Movement
local yaw_diff = abs(diff(yaw, goal_yaw))
if yaw_diff < pi * 0.25
or steer_to then
2022-07-06 15:58:19 -07:00
_self:set_forward_velocity(speed)
2022-07-04 15:27:17 -07:00
else
2022-07-06 15:58:19 -07:00
_self:set_forward_velocity(speed * 0.33)
2022-06-21 09:44:10 -07:00
end
_self:turn_to(goal_yaw, turn_rate)
end
2022-06-21 09:44:10 -07:00
return func
end)
2023-01-14 00:11:45 -08:00