Luanti/EinsDreiDreiSieben
Luanti/EinsDreiDreiSieben
2
0
Fork 0
Code Issues 4 Pull requests Projects Releases Wiki Activity

Noch mehr mods

Browse source
This commit is contained in:
N-Nachtigal 2025-05-18 04:02:23 +02:00
parent a063db5d3b
commit cf017b2ca1
527 changed files with 21113 additions and 181 deletions
Download patch file Download diff file Expand all files Collapse all files

167
mods/airutils/lib_copter/control.lua Normal file
View file

@ -0,0 +1,167 @@
--[[airutils.rudder_limit = 30
airutils.elevator_limit = 40]]--
local S = airutils.S
dofile(minetest.get_modpath("airutils") .. DIR_DELIM .. "lib_planes" .. DIR_DELIM .. "utilities.lua")
local function set_yaw_by_mouse(self, dir)
local rotation = self.object:get_rotation()
local rot_y = math.deg(rotation.y)
local total = math.abs(math.floor(rot_y/360))
if rot_y < 0 then rot_y = rot_y + (360*total) end
if rot_y > 360 then rot_y = rot_y - (360*total) end
if rot_y >= 270 and dir <= 90 then dir = dir + 360 end
if rot_y <= 90 and dir >= 270 then dir = dir - 360 end
local intensity = self._yaw_intensity / 10
local command = (rot_y - dir) * intensity
if command < -90 then command = -90
elseif command > 90 then command = 90 end
--minetest.chat_send_all("rotation y: "..rot_y.." - dir: "..dir.." - command: "..command)
self._rudder_angle = (-command * self._rudder_limit)/90
end
local function set_yaw(self, dir, dtime)
local yaw_factor = self._yaw_intensity or 25
if dir == 1 then
self._rudder_angle = math.max(self._rudder_angle-(yaw_factor*dtime),-self._rudder_limit)
elseif dir == -1 then
self._rudder_angle = math.min(self._rudder_angle+(yaw_factor*dtime),self._rudder_limit)
end
end
function airutils.heli_control(self, dtime, hull_direction, longit_speed, longit_drag, nhdir,
later_speed, later_drag, accel, player, is_flying)
--if self.driver_name == nil then return end
local retval_accel = accel
local stop = false
local ctrl
local time_correction = (dtime/airutils.ideal_step)
if time_correction < 1 then time_correction = 1 end
self._vehicle_acc = self._vehicle_acc or 0
-- player control
if player then
ctrl = player:get_player_control()
if self._last_time_command > 0.5 then
self._last_time_command = 0.5
end
if not self._acceleration then self._acceleration = 0 end
if not self._lat_acceleration then self._lat_acceleration = 0 end
if self._engine_running then
--control lift
local collective_up_max = 1.2
local min_angle = self._min_collective
local collective_up = collective_up_max / 10
if ctrl.jump then
self._wing_configuration = self._wing_configuration + collective_up
--end
self._is_going_up = true
elseif ctrl.sneak then
self._wing_configuration = self._wing_configuration - collective_up
--end
else
self._wing_configuration = self._stable_collective
end
if self._wing_configuration < min_angle then self._wing_configuration = min_angle end
local up_limit = (self._wing_angle_of_attack+collective_up_max)
if self._wing_configuration > up_limit then self._wing_configuration = up_limit end
--end lift
else
self._wing_configuration = self._stable_collective or 1
end
local yaw_cmd = 0
if is_flying or self.wheels then
local acc_fraction = (self._max_engine_acc / 40)*time_correction
if ctrl.up then
if longit_speed < self._max_speed then
self._acceleration = self._acceleration + acc_fraction
else
self._acceleration = 0
end
elseif ctrl.down then
if longit_speed > -self._max_speed then
self._acceleration = self._acceleration + (-acc_fraction)
else
self._acceleration = 0
end
else
self._acceleration = 0
end
self._acceleration = math.min(self._acceleration,self._max_engine_acc)
self._acceleration = math.max(self._acceleration,-self._max_engine_acc)
if is_flying then --why double check? because I dont want lateral movement when landed
if ctrl.right then
yaw_cmd = 1
if later_speed < self._max_speed and self._yaw_by_mouse then
self._lat_acceleration = self._lat_acceleration + acc_fraction
else
self._lat_acceleration = 0
end
elseif ctrl.left then
yaw_cmd = -1
if later_speed > -self._max_speed and self._yaw_by_mouse then
self._lat_acceleration = self._lat_acceleration + (-acc_fraction)
else
self._lat_acceleration = 0
end
else
self._lat_acceleration = 0
end
end
else
self._acceleration = 0
self._lat_acceleration = 0
self.object:set_velocity({x=0,y=self.object:get_velocity().y,z=0})
end
self._vehicle_acc = math.min(self._acceleration, self._max_engine_acc)
self._vehicle_acc = math.max(self._acceleration,-self._max_engine_acc)
self._lat_acc = math.min(self._lat_acceleration, self._max_engine_acc)
local hull_acc = vector.multiply(hull_direction,self._vehicle_acc)
local lat_hull_acc = vector.multiply(nhdir,self._lat_acc)
--colocar aceleração lateral aqui
retval_accel=vector.add(retval_accel,hull_acc)
retval_accel=vector.add(retval_accel,lat_hull_acc)
-- yaw
if self._yaw_by_mouse then
local rot_y = math.deg(player:get_look_horizontal())
set_yaw_by_mouse(self, rot_y)
else
set_yaw(self, yaw_cmd, dtime)
end
--I'm desperate, center all!
if ctrl.right and ctrl.left then
self._wing_configuration = self._stable_collective
end
if ctrl.up and ctrl.down and self._last_time_command >= 0.5 then
self._last_time_command = 0
local name = player:get_player_name()
if self._yaw_by_mouse == true then
minetest.chat_send_player(name, core.colorize('#0000ff', S(" >>> Mouse control disabled.")))
self._yaw_by_mouse = false
else
minetest.chat_send_player(name, core.colorize('#0000ff', S(" >>> Mouse control enabled.")))
self._yaw_by_mouse = true
end
end
end
return retval_accel, stop
end

382
mods/airutils/lib_copter/entities.lua Normal file
View file

@ -0,0 +1,382 @@
dofile(minetest.get_modpath("airutils") .. DIR_DELIM .. "lib_planes" .. DIR_DELIM .. "global_definitions.lua")
local function engineSoundPlay(self, increment, base)
increment = increment or 0.0
--sound
if self.sound_handle then minetest.sound_stop(self.sound_handle) end
if self.object then
local base_pitch = base
local pitch_adjust = base_pitch + increment
self.sound_handle = minetest.sound_play({name = self._engine_sound},
{object = self.object, gain = 2.0,
pitch = pitch_adjust,
max_hear_distance = 32,
loop = true,})
end
end
local function engine_set_sound_and_animation(self, is_flying, newpitch, newroll)
is_flying = is_flying or false
if self._engine_running then --engine running
if not self.sound_handle then
engineSoundPlay(self, 0.0, 0.9)
end
--self._cmd_snd
if self._snd_last_cmd ~= self._cmd_snd then
local increment
self._snd_last_cmd = self._cmd_snd
if self._cmd_snd then increment = 0.1 else increment = 0.0 end
engineSoundPlay(self, increment, 0.9)
end
self.object:set_animation_frame_speed(100)
else
if is_flying then --autorotation here
if self._snd_last_cmd ~= self._cmd_snd then
local increment
self._snd_last_cmd = self._cmd_snd
if self._cmd_snd then increment = 0.1 else increment = 0.0 end
engineSoundPlay(self, increment, 0.6)
end
self.object:set_animation_frame_speed(70)
else --stop all
if self.sound_handle then
self._snd_last_roll = nil
self._snd_last_pitch = nil
minetest.sound_stop(self.sound_handle)
self.sound_handle = nil
self.object:set_animation_frame_speed(0)
end
end
end
end
function airutils.logic_heli(self)
local velocity = self.object:get_velocity()
local curr_pos = self.object:get_pos()
self._curr_pos = curr_pos --shared
self._last_accel = self.object:get_acceleration()
self._last_time_command = self._last_time_command + self.dtime
if self._last_time_command > 1 then self._last_time_command = 1 end
local player = nil
if self.driver_name then player = minetest.get_player_by_name(self.driver_name) end
local co_pilot = nil
if self.co_pilot and self._have_copilot then co_pilot = minetest.get_player_by_name(self.co_pilot) end
--test collision
airutils.testImpact(self, velocity, curr_pos)
local ctrl = nil
if player then
ctrl = player:get_player_control()
---------------------
-- change the driver
---------------------
if co_pilot and self._have_copilot and self._last_time_command >= 1 then
if self._command_is_given == true then
if ctrl.sneak or ctrl.jump or ctrl.up or ctrl.down or ctrl.right or ctrl.left then
self._last_time_command = 0
--take the control
airutils.transfer_control(self, false)
end
else
if ctrl.sneak == true and ctrl.jump == true then
self._last_time_command = 0
--trasnfer the control to student
airutils.transfer_control(self, true)
end
end
end
end
if not self.object:get_acceleration() then return end
local accel_y = self.object:get_acceleration().y
local rotation = self.object:get_rotation()
local yaw = rotation.y
local newyaw=yaw
local roll = rotation.z
local hull_direction = airutils.rot_to_dir(rotation) --minetest.yaw_to_dir(yaw)
local nhdir = {x=hull_direction.z,y=0,z=-hull_direction.x} -- lateral unit vector
local longit_speed = vector.dot(velocity,hull_direction)
self._longit_speed = longit_speed
local longit_drag = vector.multiply(hull_direction,longit_speed*
longit_speed*self._longit_drag_factor*-1*airutils.sign(longit_speed))
local later_speed = airutils.dot(velocity,nhdir)
--minetest.chat_send_all('later_speed: '.. later_speed)
local later_drag = vector.multiply(nhdir,later_speed*later_speed*
self._later_drag_factor*-1*airutils.sign(later_speed))
local accel = vector.add(longit_drag,later_drag)
local stop = false
local is_flying = true
if self.colinfo then
is_flying = (not self.colinfo.touching_ground)
end
if self.isinliquid == true then
is_flying = false
end
--if self.isonground then is_flying = false end
--if is_flying then minetest.chat_send_all('is flying') end
local is_attached = airutils.checkAttach(self, player)
if self._indicated_speed == nil then self._indicated_speed = 0 end
if not is_attached then
-- for some engine error the player can be detached from the machine, so lets set him attached again
airutils.checkattachBug(self)
end
if self._custom_step_additional_function then
self._custom_step_additional_function(self)
end
--landing light
if self._have_landing_lights then
airutils.landing_lights_operate(self)
end
--smoke and fire
if self._engine_running then
local curr_health_percent = (self.hp_max * 100)/self._max_plane_hp
if curr_health_percent < 20 then
airutils.add_smoke_trail(self, 2)
elseif curr_health_percent < 50 then
airutils.add_smoke_trail(self, 1)
end
else
if self._smoke_spawner and not self._smoke_semaphore then
self._smoke_semaphore = 1 --to set it only one time
minetest.after(5, function()
if self._smoke_spawner then
minetest.delete_particlespawner(self._smoke_spawner)
self._smoke_spawner = nil
self._smoke_semaphore = nil
end
end)
end
end
if (math.abs(velocity.x) < 0.1 and math.abs(velocity.z) < 0.1) and is_flying == false and is_attached == false and self._engine_running == false then
if self._ground_friction then
if not self.isinliquid then self.object:set_velocity({x=0,y=airutils.gravity*self.dtime,z=0}) end
end
engine_set_sound_and_animation(self, false, 0, 0)
return
end
--adjust climb indicator
local y_velocity = 0
if self._engine_running or is_flying then y_velocity = velocity.y end
local climb_rate = y_velocity
if climb_rate > 5 then climb_rate = 5 end
if climb_rate < -5 then
climb_rate = -5
end
-- pitch and roll
local newroll = 0
local newpitch = 0
if ctrl and is_flying then
local command_angle = self._tilt_angle or 0
local max_acc = self._max_engine_acc
local pitch_ammount = (math.abs(self._vehicle_acc or 0) * command_angle) / max_acc
if math.abs(longit_speed) >= self._max_speed then pitch_ammount = command_angle end --gambiarra pra continuar com angulo
pitch_ammount = math.rad(math.min(pitch_ammount, command_angle))
if ctrl.up then newpitch = -pitch_ammount end
if ctrl.down then newpitch = pitch_ammount end
local roll_ammount = (math.abs(self._lat_acc or 0) * command_angle) / max_acc
if math.abs(later_speed) >= self._max_speed then roll_ammount = command_angle end --gambiarra pra continuar com angulo
roll_ammount = math.rad(math.min(roll_ammount, command_angle))
if ctrl.left then newroll = -roll_ammount end
if ctrl.right then newroll = roll_ammount end
if ctrl.up or ctrl.down or ctrl.left or ctrl.right then
self._cmd_snd = true
else
self._cmd_snd = false
end
end
-- new yaw
if math.abs(self._rudder_angle)>1.5 then
local turn_rate = math.rad(self._yaw_turn_rate)
local yaw_turn = self.dtime * math.rad(self._rudder_angle) * turn_rate * 4
newyaw = yaw + yaw_turn
end
---------------------------------
-- end roll
local pilot = player
if self._have_copilot then
if self._command_is_given and co_pilot then
pilot = co_pilot
else
self._command_is_given = false
end
end
------------------------------------------------------
--accell calculation block
------------------------------------------------------
if is_attached or co_pilot then
accel, stop = airutils.heli_control(self, self.dtime, hull_direction,
longit_speed, longit_drag, nhdir, later_speed, later_drag, accel, pilot, is_flying)
end
--end accell
--get disconnected players
airutils.rescueConnectionFailedPassengers(self)
if accel == nil then accel = {x=0,y=0,z=0} end
--lift calculation
accel.y = accel_y
--lets apply some bob in water
if self.isinliquid then
local bob = airutils.minmax(airutils.dot(accel,hull_direction),0.02) -- vertical bobbing
if bob < 0 then bob = 0 end
accel.y = accel.y + bob
local max_pitch = 6
local ref_speed = longit_speed * 20
if ref_speed < 0 then ref_speed = 0 end
local h_vel_compensation = ((ref_speed * 100)/max_pitch)/100
if h_vel_compensation < 0 then h_vel_compensation = 0 end
if h_vel_compensation > max_pitch then h_vel_compensation = max_pitch end
--minetest.chat_send_all(h_vel_compensation)
newpitch = newpitch + (velocity.y * math.rad(max_pitch - h_vel_compensation))
end
local ceiling = 5000
local blade_speed = self._rotor_speed or 15
local limit = (self._max_speed)
if self._engine_running == false then
if is_flying then
blade_speed = self._rotor_idle_speed or 12
if math.abs(longit_speed) > 0.5 then blade_speed = self._rotor_idle_speed + (self._rotor_speed - self._rotor_idle_speed) / 2 end
else
blade_speed = 0.001 --to avoid division by 0
end
end
local new_accel = airutils.getLiftAccel(self, {x=0, y=velocity.y, z=blade_speed}, {x=0, y=accel.y, z=blade_speed/self.dtime}, blade_speed, roll, curr_pos, self._lift, ceiling, self._wing_span)
local y_accell = new_accel.y
new_accel = vector.new(accel)
new_accel.y = y_accell
if velocity.y > limit then new_accel.y = 0 end --it isn't a rocket :/
--wind effects
if airutils.wind and is_flying == true then
local wind = airutils.get_wind(curr_pos, 0.1)
new_accel = vector.add(new_accel, wind)
end
if stop ~= true then --maybe == nil
self._last_accell = new_accel
self.object:move_to(curr_pos)
--airutils.set_acceleration(self.object, new_accel)
--local limit = self._climb_speed
--if new_accel.y > limit then new_accel.y = limit end --it isn't a rocket :/
else
if stop == true then
self._last_accell = vector.new() --self.object:get_acceleration()
self.object:set_acceleration({x=0,y=0,z=0})
self.object:set_velocity({x=0,y=0,z=0})
end
end
if self.wheels then
if is_flying == false then --isn't flying?
--animate wheels
local min_speed_animation = 0.1
if math.abs(velocity.x) > min_speed_animation or math.abs(velocity.z) > min_speed_animation then
self.wheels:set_animation_frame_speed(longit_speed * 10)
else
self.wheels:set_animation_frame_speed(0)
end
else
--stop wheels
self.wheels:set_animation_frame_speed(0)
end
end
------------------------------------------------------
-- end accell
------------------------------------------------------
------------------------------------------------------
-- sound and animation
------------------------------------------------------
local is_ship_attached = self.object:get_attach()
if is_ship_attached then
engine_set_sound_and_animation(self, false, newpitch, newroll) --is attached to a mother ship, so stop all
else
engine_set_sound_and_animation(self, is_flying, newpitch, newroll)
end
------------------------------------------------------
--GAUGES
--minetest.chat_send_all('rate '.. climb_rate)
local climb_angle = airutils.get_gauge_angle(climb_rate)
self._climb_rate = climb_rate
local indicated_speed = longit_speed * 0.9
if indicated_speed < 0 then indicated_speed = 0 end
self._indicated_speed = indicated_speed
local speed_angle = airutils.get_gauge_angle(indicated_speed, -45)
--adjust power indicator
local fixed_power = 60
if self._engine_running == false then fixed_power = 0 end
local power_indicator_angle = airutils.get_gauge_angle(fixed_power/10) + 90
local fuel_in_percent = (self._energy * 1)/self._max_fuel
local energy_indicator_angle = (180*fuel_in_percent)-180
if is_attached then
if self._show_hud then
airutils.update_hud(player, climb_angle, speed_angle, power_indicator_angle, energy_indicator_angle)
else
airutils.remove_hud(player)
end
end
if is_flying == false then
newyaw = yaw
end
if player and self._use_camera_relocation then
--minetest.chat_send_all(dump(newroll))
local new_eye_offset = airutils.camera_reposition(player, newpitch, newroll)
player:set_eye_offset(new_eye_offset, {x = 0, y = 1, z = -30})
end
--apply rotations
self.object:set_rotation({x=newpitch,y=newyaw,z=newroll})
--end
-- calculate energy consumption --
airutils.consumptionCalc(self, accel)
--saves last velocity for collision detection (abrupt stop)
self._last_accel = new_accel
self._last_vel = self.object:get_velocity()
self._last_longit_speed = longit_speed
self._yaw = newyaw
self._roll = newroll
self._pitch = newpitch
end

8
mods/airutils/lib_copter/init.lua Normal file
View file

@ -0,0 +1,8 @@
dofile(minetest.get_modpath("airutils") .. DIR_DELIM .. "lib_copter" .. DIR_DELIM .. "control.lua")
dofile(minetest.get_modpath("airutils") .. DIR_DELIM .. "lib_copter" .. DIR_DELIM .. "entities.lua")