763 lines
23 KiB
Lua
763 lines
23 KiB
Lua
local go = false
|
|
local DEBUG_WAYPOINT = false
|
|
local DEBUG_TEXT = false
|
|
local function get_sign(i)
|
|
if i == 0 then
|
|
return 0
|
|
else
|
|
return i / math.abs(i)
|
|
end
|
|
end
|
|
local player_attached = {}
|
|
|
|
local attachTimer = 0
|
|
local animateTimer = 0
|
|
minetest.register_globalstep(function(dtime)
|
|
attachTimer = attachTimer + dtime;
|
|
animateTimer = animateTimer + dtime
|
|
if attachTimer >= 5 then
|
|
minetest.after(0, function() attachTimer = 0 end)
|
|
end
|
|
if animateTimer >= .08 then
|
|
minetest.after(0, function() animateTimer = 0 end)
|
|
end
|
|
end)
|
|
|
|
local function detach(player)
|
|
if not player then return end
|
|
local name = player:get_player_name()
|
|
if not name then return end
|
|
|
|
local attached = player_attached[name]
|
|
if not attached then return end
|
|
player_attached[name] = nil
|
|
local i = 0
|
|
while i <= #attached.passengers do
|
|
i = i + 1
|
|
if attached.passengers[i].player == player then
|
|
attached.passengers[i].player = nil
|
|
if i == 1 then player:hud_remove(attached.hud) end
|
|
break
|
|
end
|
|
end
|
|
player:set_detach()
|
|
player:set_eye_offset({x=0,y=0,z=0}, {x=0,y=0,z=0})
|
|
default.player_attached[name] = false
|
|
default.player_set_animation(player, "stand" , 30)
|
|
end
|
|
|
|
local function get_yaw(yaw)
|
|
local sign = get_sign(yaw)
|
|
local newyaw = math.abs(yaw)
|
|
while newyaw > math.pi do
|
|
newyaw = newyaw - math.pi
|
|
end
|
|
return newyaw*sign
|
|
end
|
|
local function get_velocity(v, yaw, velocity)
|
|
local x = -math.sin(yaw) * v
|
|
local z = math.cos(yaw) * v
|
|
return {x = x, y = velocity.y, z = z}
|
|
end
|
|
|
|
local function get_v(v)
|
|
return math.sqrt(v.x ^ 2 + v.z ^ 2)
|
|
end
|
|
|
|
local function serializeContents(contents)
|
|
if not contents then return "" end
|
|
|
|
local tabs = {}
|
|
for i, stack in ipairs(contents) do
|
|
tabs[i] = stack and stack:to_table() or ""
|
|
end
|
|
|
|
return minetest.serialize(tabs)
|
|
end
|
|
|
|
local function deserializeContents(data)
|
|
if not data or data == "" then return nil end
|
|
local tabs = minetest.deserialize(data)
|
|
if not tabs or type(tabs) ~= "table" then return nil end
|
|
|
|
local contents = {}
|
|
for i, tab in ipairs(tabs) do
|
|
contents[i] = ItemStack(tab)
|
|
end
|
|
|
|
return contents
|
|
end
|
|
|
|
local charset = {} do -- [A-Z]
|
|
for c = 65, 90 do table.insert(charset, string.char(c)) end
|
|
end
|
|
local numset = {} do -- [0-9]
|
|
for c = 48, 57 do table.insert(numset, string.char(c)) end
|
|
end
|
|
|
|
local function randomString(length)
|
|
local text = ""
|
|
local i = 0
|
|
if not length or length <= 0 then return text end
|
|
while i < length do
|
|
text = text..charset[math.random(1, #charset)]
|
|
i = i + 1
|
|
end
|
|
return text
|
|
end
|
|
|
|
local function randomNumber(length)
|
|
local text = ""
|
|
local i = 0
|
|
if not length or length <= 0 then return text end
|
|
while i < length do
|
|
text = text..numset[math.random(1, #numset)]
|
|
i = i + 1
|
|
end
|
|
return text
|
|
end
|
|
local function wheelspeed(car)
|
|
if not car then return end
|
|
if not car.object then return end
|
|
if not car.object:getvelocity() then return end
|
|
if not car.wheel then return end
|
|
local direction = 1
|
|
if car.v then
|
|
direction = get_sign(car.v)
|
|
end
|
|
local v = get_v(car.object:get_velocity())
|
|
local fps = v*4
|
|
for id, wheel in pairs(car.wheel) do
|
|
wheel:set_animation({x=2, y=9}, fps*direction, 0, true)
|
|
end
|
|
if v ~= 0 then
|
|
local i = 16
|
|
while true do
|
|
if i/fps > 1 then i = i/2 else break end
|
|
end
|
|
minetest.after(i/fps, wheelspeed, car)
|
|
end
|
|
end
|
|
|
|
local function rotateVector(x, y, a)
|
|
local c = math.cos(a)
|
|
local s = math.sin(a)
|
|
return c*x - s*y, s*x + c*y
|
|
end
|
|
|
|
local function getClosest(player, car)
|
|
local def = cars_registered_cars[car.object:get_entity_name()]
|
|
local playerPos = player:getpos()
|
|
local dir = player:get_look_dir()
|
|
playerPos.y = playerPos.y + 1.45
|
|
local carPos = car.object:getpos()
|
|
local offset, _ = player:get_eye_offset()
|
|
local playeryaw = player:get_look_horizontal()
|
|
local x, z = rotateVector(offset.x, offset.z, playeryaw)
|
|
offset = vector.multiply({x=x, y=offset.y, z=z}, .1)
|
|
playerPos = vector.add(playerPos, offset)
|
|
if DEBUG_WAYPOINT then
|
|
local marker = player:hud_add({
|
|
hud_elem_type = "waypoint",
|
|
name = "start",
|
|
number = 0xFF0000,
|
|
world_pos = playerPos
|
|
})
|
|
minetest.after(5, function() player:hud_remove(marker) end, player, marker)
|
|
end
|
|
local punchPos = vector.add(playerPos, vector.multiply(dir, vector.distance(playerPos, carPos)))
|
|
if minetest.raycast then
|
|
local ray = minetest.raycast(playerPos, vector.add(playerPos, vector.multiply(dir, vector.distance(playerPos, carPos))))
|
|
if ray then
|
|
local pointed = ray:next()
|
|
if pointed and pointed.ref == player then
|
|
pointed = ray:next()
|
|
end
|
|
if pointed and pointed.ref == car.object and pointed.intersection_point then
|
|
punchPos = pointed.intersection_point
|
|
end
|
|
end
|
|
end
|
|
if not punchPos then return end
|
|
if DEBUG_WAYPOINT then
|
|
local marker = player:hud_add({
|
|
hud_elem_type = "waypoint",
|
|
name = "end",
|
|
number = 0xFF0000,
|
|
world_pos = punchPos
|
|
})
|
|
minetest.after(5, function() player:hud_remove(marker) end, player, marker)
|
|
end
|
|
punchPos = vector.subtract(punchPos, carPos)
|
|
local carYaw = car.object:getyaw()
|
|
local closest = {}
|
|
closest.id = 0
|
|
local trunkloc = def.trunkloc
|
|
if trunkloc then
|
|
local x, z = rotateVector(trunkloc.x, trunkloc.z, carYaw)
|
|
trunkloc = vector.multiply({x=x, y=trunkloc.y, z=z}, .1)
|
|
closest.distance = vector.distance(punchPos, trunkloc)
|
|
end
|
|
if DEBUG_WAYPOINT then
|
|
local marker = player:hud_add({
|
|
hud_elem_type = "waypoint",
|
|
name = "0",
|
|
number = 0xFF0000,
|
|
world_pos = vector.add(trunkloc, carPos)
|
|
})
|
|
minetest.after(5, function() player:hud_remove(marker) end, player, marker)
|
|
end
|
|
for id in pairs(car.passengers) do
|
|
local loc = car.passengers[id].loc
|
|
local x, z = rotateVector(loc.x, loc.z, carYaw)
|
|
loc = vector.multiply({x=x, y=loc.y, z=z}, .1)
|
|
if DEBUG_WAYPOINT then
|
|
local marker = player:hud_add({
|
|
hud_elem_type = "waypoint",
|
|
name = id,
|
|
number = 0xFF0000,
|
|
world_pos = vector.add(loc, carPos)
|
|
})
|
|
minetest.after(5, function() player:hud_remove(marker) end, player, marker)
|
|
end
|
|
local dis = vector.distance(punchPos, loc)
|
|
if not closest.distance then
|
|
closest.distance = dis
|
|
closest.id = id
|
|
elseif dis < closest.distance then closest.id = id closest.distance = dis end
|
|
end
|
|
return closest.id
|
|
end
|
|
|
|
local trunkplayer = {}
|
|
local function trunk_rightclick(self, clicker)
|
|
local def = cars_registered_cars[self.object:get_entity_name()]
|
|
local name = clicker:get_player_name()
|
|
trunkplayer[name] = self
|
|
local selfname = string.sub(tostring(self), 8)
|
|
local inventory = minetest.create_detached_inventory("cars"..selfname, {
|
|
on_move = function(inv, from_list, from_index, to_list, to_index, count, player)
|
|
self.trunkinv = inv:get_list("trunk")
|
|
end,
|
|
on_put = function(inv, listname, index, stack, player)
|
|
self.trunkinv = inv:get_list("trunk")
|
|
end,
|
|
on_take = function(inv, listname, index, stack, player)
|
|
self.trunkinv = inv:get_list("trunk")
|
|
end,
|
|
})
|
|
local x = def.trunksize.x
|
|
local y = def.trunksize.y
|
|
local formx = x
|
|
inventory:set_size("trunk", x * y)
|
|
if x < 8 then formx = 8 end
|
|
local templist = table.copy(self.trunkinv)
|
|
inventory:set_list("trunk", templist)
|
|
local formspec =
|
|
"size["..formx..","..5+y.."]"..
|
|
"list[detached:cars"..selfname..";trunk;0,.5;"..x..","..y..";]"..
|
|
"list[current_player;main;0,"..1+y..";8,4;]"
|
|
minetest.show_formspec(name, "cars_trunk", formspec)
|
|
end
|
|
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
|
if formname == "cars_trunk" then
|
|
if fields.quit then
|
|
local name = player:get_player_name()
|
|
if trunkplayer[name] then
|
|
minetest.sound_play("closetrunk", {
|
|
max_hear_distance = 24,
|
|
gain = 1,
|
|
object = trunkplayer[name].object
|
|
})
|
|
trunkplayer[name] = nil
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
local function car_step(self, dtime)
|
|
local def = cars_registered_cars[self.object:get_entity_name()]
|
|
if not self.v then self.v = 0 end
|
|
self.v = get_v(self.object:getvelocity()) * get_sign(self.v)
|
|
local pos = self.object:getpos()
|
|
if self.lastv then
|
|
local newv = self.object:getvelocity()
|
|
if not self.crash then self.crash = false end
|
|
local crash = false
|
|
if math.abs(self.lastv.x) > 5 and newv.x == 0 then crash = true end
|
|
if math.abs(self.lastv.y) > 10 and newv.y == 0 then crash = true end
|
|
if math.abs(self.lastv.z) > 5 and newv.z == 0 then crash = true end
|
|
--[[if crash then
|
|
local start = {x=pos.x, y=pos.y+self.stepheight, z=pos.z}
|
|
local finish = vector.add(start, vector.multiply(vector.normalize(self.lastv), 1))
|
|
if minetest.raycast then
|
|
local ray = minetest.raycast(start, finish)
|
|
if ray then
|
|
local pointed = ray:next()
|
|
if pointed == self then
|
|
pointed = ray:next()
|
|
end
|
|
--minetest.chat_send_all(dump(pointed.ref))
|
|
minetest.add_particle({
|
|
pos = finish,
|
|
expirationtime = 10,
|
|
size = 2,
|
|
texture = "gunslinger_decal.png",
|
|
vertical = true
|
|
})
|
|
if not pointed then crash = false end
|
|
end
|
|
else
|
|
if minetest.get_node(finish).name == "air" then crash = false end
|
|
end
|
|
end--]]
|
|
if crash and not self.crash then
|
|
self.crash = true
|
|
minetest.after(.5, function()
|
|
self.crash = false
|
|
end)
|
|
minetest.sound_play("crash"..math.random(1,3), {
|
|
max_hear_distance = 48,
|
|
pitch = .7,
|
|
gain = 10,
|
|
object = self.object
|
|
})
|
|
local checkpos = vector.add(pos, vector.multiply(vector.normalize(self.lastv), .8))
|
|
local objects = minetest.get_objects_inside_radius(checkpos, 1)
|
|
for _,obj in pairs(objects) do
|
|
if obj:is_player() then
|
|
for id, passengers in pairs (self.passengers) do
|
|
if passengers.player == obj then goto next end
|
|
end
|
|
local puncher = self.passengers[1].player
|
|
if not puncher then puncher = self.object end
|
|
local dmg = ((vector.length(self.lastv)-4)/(20-4))*20
|
|
local name = obj:get_player_name()
|
|
if default.player_attached[name] then dmg = dmg*.5 end
|
|
obj:punch(puncher, nil, {damage_groups={fleshy=dmg}})
|
|
::next::
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local driver = self.passengers[1].player
|
|
if driver then
|
|
driver:hud_change(self.hud, "text", tostring(math.abs(math.floor(self.v*2.23694*10)/10)).." MPH")
|
|
local ctrl = driver:get_player_control()
|
|
local yaw = self.object:getyaw()
|
|
local sign
|
|
if self.v == 0 then sign = 0 else sign = get_sign(self.v) end
|
|
if ctrl.up then
|
|
if sign >= 0 then
|
|
self.v = self.v + def.acceleration*dtime
|
|
else
|
|
self.v = self.v + def.braking*dtime
|
|
end
|
|
elseif ctrl.down then
|
|
if sign <= 0 then
|
|
self.v = self.v - def.acceleration*dtime
|
|
else
|
|
self.v = self.v - def.braking*dtime
|
|
end
|
|
elseif sign ~= 0 then
|
|
self.v = self.v - def.coasting*dtime*get_sign(self.v)
|
|
end
|
|
if get_sign(self.v) ~= sign and sign ~= 0 then
|
|
self.v = 0
|
|
end
|
|
|
|
local abs_v = math.abs(self.v)
|
|
local maxwheelpos = 45*(8/(abs_v+8))
|
|
if ctrl.left and self.wheelpos <= 0 then
|
|
self.wheelpos = self.wheelpos-50*dtime*(4/(abs_v+4))
|
|
if self.wheelpos < -1*maxwheelpos then
|
|
self.wheelpos = -1*maxwheelpos
|
|
end
|
|
elseif ctrl.right and self.wheelpos >= 0 then
|
|
self.wheelpos = self.wheelpos+50*dtime*(4/(abs_v+4))
|
|
if self.wheelpos > maxwheelpos then
|
|
self.wheelpos = maxwheelpos
|
|
end
|
|
else
|
|
local sign = get_sign(self.wheelpos)
|
|
|
|
self.wheelpos = self.wheelpos - 100*get_sign(self.wheelpos)*dtime
|
|
if math.abs(self.wheelpos) < 5 or sign ~= get_sign(self.wheelpos) then
|
|
self.wheelpos = 0
|
|
end
|
|
end
|
|
if animateTimer >= .08 then
|
|
self.wheel.frontright:set_attach(self.object, "", {z=10.75,y=2.5,x=-8.875}, {x=0,y=self.wheelpos,z=0})
|
|
self.wheel.frontleft:set_attach(self.object, "", {z=10.75,y=2.5,x=8.875}, {x=0,y=self.wheelpos,z=0})
|
|
self.steeringwheel:set_attach(self.object, "", {z=5.62706,y=8.25,x=-4.0}, {x=0,y=0,z=-self.wheelpos*8})
|
|
end
|
|
self.object:setyaw(yaw - ((self.wheelpos/8)*(self.v/8)*dtime))
|
|
|
|
if attachTimer >= 5 then
|
|
self.licenseplate:set_attach(self.object, "", {x = -.38, y = -0.85, z = -15.51}, {x = 0, y = 0, z = 0})
|
|
self.wheel.backright:set_attach(self.object, "", {z=-11.75,y=2.5,x=-8.875}, {x=0,y=0,z=0})
|
|
self.wheel.backleft:set_attach(self.object, "", {z=-11.75,y=2.5,x=8.875}, {x=0,y=0,z=0})
|
|
end
|
|
|
|
else
|
|
if math.abs(self.wheelpos) > 0 then
|
|
local yaw = self.object:getyaw()
|
|
self.wheelpos = 0
|
|
self.wheel.frontright:set_attach(self.object, "", {z=10.75,y=2.5,x=-8.875}, {x=0,y=self.wheelpos,z=0})
|
|
self.wheel.frontleft:set_attach(self.object, "", {z=10.75,y=2.5,x=8.875}, {x=0,y=self.wheelpos,z=0})
|
|
self.steeringwheel:set_attach(self.object, "", {z=5.62706,y=8.25,x=-4.0}, {x=0,y=0,z=-self.wheelpos*8})
|
|
self.object:setyaw(yaw - ((self.wheelpos/8)*(self.v/8)*dtime))
|
|
end
|
|
local sign
|
|
if self.v == 0 then sign = 0 else sign = get_sign(self.v) end
|
|
if sign ~= 0 then
|
|
self.v = self.v - 2*dtime*get_sign(self.v)
|
|
if get_sign(self.v) ~= sign then
|
|
self.v = 0
|
|
end
|
|
end
|
|
end
|
|
|
|
if attachTimer >= 5 then
|
|
for id, passengers in pairs (self.passengers) do
|
|
local player = passengers.player
|
|
if player then
|
|
player:set_attach(self.object, "",
|
|
passengers.loc, {x = 0, y = 0, z = 0})
|
|
end
|
|
end
|
|
end
|
|
if self.v > def.max_speed then
|
|
self.v = def.max_speed
|
|
elseif self.v < -1*def.max_speed/2 then
|
|
self.v = -1*def.max_speed/2
|
|
end
|
|
if math.abs(self.v) > 1 and minetest.get_item_group(minetest.get_node(pos).name, "water") > 0 then
|
|
self.v = 1*get_sign(self.v)
|
|
end
|
|
local new_velo
|
|
local velocity = self.object:getvelocity()
|
|
new_velo = get_velocity(self.v, self.object:getyaw(), velocity)
|
|
self.object:setvelocity(new_velo)
|
|
|
|
if math.abs(self.v) < .05 and math.abs(self.v) > 0 then
|
|
self.object:setvelocity({x = 0, y = 0, z = 0})
|
|
self.v = 0
|
|
if self.wheelsound then
|
|
minetest.sound_fade(self.wheelsound, 30, 0)
|
|
end
|
|
if self.windsound then
|
|
minetest.sound_fade(self.windsound, 30, 0)
|
|
end
|
|
wheelspeed(self)
|
|
return
|
|
end
|
|
if self.lastv and vector.length(self.lastv) == 0 and math.abs(self.v) > 0 then
|
|
wheelspeed(self)
|
|
end
|
|
--[[set acceleration for replication
|
|
if self.lastv then
|
|
local accel = vector.subtract(self.lastv, new_velo)
|
|
if self.v < 1 then
|
|
accel = {x=0,y=0,z=0}
|
|
end
|
|
accel = vector.multiply(accel, 20)
|
|
accel.y = -10
|
|
self.object:setacceleration(accel)
|
|
end--]]
|
|
self.lastv = new_velo
|
|
|
|
--sound
|
|
local abs_v = math.abs(self.v)
|
|
if abs_v > 0 and driver ~= nil then
|
|
self.timer1 = self.timer1 + dtime
|
|
if self.timer1 > .1 then
|
|
local rpm = 1
|
|
if abs_v > 16 then
|
|
rpm = abs_v/16+.5
|
|
elseif abs_v > 10 then
|
|
rpm = abs_v/10+.4
|
|
else
|
|
rpm = abs_v/5+.3
|
|
end
|
|
minetest.sound_play(def.enginesound, {
|
|
max_hear_distance = 48,
|
|
pitch = rpm+.1,
|
|
object = self.object
|
|
})
|
|
self.timer1 = 0
|
|
end
|
|
end
|
|
self.timer2 = self.timer2 + dtime
|
|
if self.timer2 > 1.5-self.v/def.max_speed*1.1 then
|
|
if abs_v > .2 then
|
|
if math.abs(velocity.y) < .1 then
|
|
self.wheelsound = minetest.sound_play("tyresound", {
|
|
max_hear_distance = 48,
|
|
object = self.object,
|
|
pitch = 1 + (abs_v/def.max_speed)*.6,
|
|
gain = .5 + (abs_v/def.max_speed)*2
|
|
})
|
|
elseif self.windsound then
|
|
minetest.sound_fade(self.windsound, 30, 0)
|
|
end
|
|
self.windsound = minetest.sound_play("wind", {
|
|
max_hear_distance = 10,
|
|
object = self.object,
|
|
pitch = 1 + (abs_v/def.max_speed)*.6,
|
|
gain = 0 + (abs_v/def.max_speed)*4
|
|
})
|
|
end
|
|
self.timer2 = 0
|
|
end
|
|
end
|
|
|
|
cars_registered_cars = {}
|
|
function cars_register_car(def)
|
|
cars_registered_cars[def.name] = def
|
|
minetest.register_entity(def.name, {
|
|
initial_properties = def.initial_properties,
|
|
on_activate = function(self, staticdata)
|
|
if not self.wheelpos then self.wheelpos = 0 end
|
|
if not self.timer1 then self.timer1 = 0 end
|
|
if not self.timer2 then self.timer2 = 0 end
|
|
if not self.platenumber then
|
|
self.platenumber = {}
|
|
end
|
|
self.passengers = def.passengers
|
|
if staticdata then
|
|
local deserialized = minetest.deserialize(staticdata)
|
|
if deserialized then
|
|
self.trunkinv = deserializeContents(deserialized.trunk)
|
|
if deserialized.plate then
|
|
self.platenumber.text = deserialized.plate.text
|
|
end
|
|
end
|
|
end
|
|
if not self.platenumber.text or self.platenumber.text == "" then self.platenumber.text = randomNumber(3).."-"..randomString(3) end
|
|
|
|
self.object:setacceleration({x=0, y=-10, z=0})
|
|
self.object:set_armor_groups({immortal = 1})
|
|
self.wheel = {}
|
|
wheelspeed(self)
|
|
local pos = self.object:getpos()
|
|
for index, wheel in pairs(def.wheel) do
|
|
if not self.wheel[index] then
|
|
self.wheel[index] = minetest.add_entity(pos, "cars:wheel")
|
|
end
|
|
if self.wheel[index] then
|
|
self.wheel[index]:set_attach(self.object, "", wheel, {x=0,y=0,z=0})
|
|
end
|
|
end
|
|
if not self.steeringwheel then
|
|
self.steeringwheel = minetest.add_entity(pos, "cars:steeringwheel")
|
|
end
|
|
if self.steeringwheel then
|
|
self.steeringwheel:set_attach(self.object, "", def.steeringwheel, {x=0,y=0,z=0})
|
|
end
|
|
--[[if not self.driverseat then
|
|
self.driverseat = minetest.add_entity(pos, "cars:seat")
|
|
end
|
|
if self.driverseat then
|
|
self.driverseat:set_attach(self.object, "", {x = -4, y = 3, z = 3}, {x = 0, y = 0, z = 0})
|
|
end--]]
|
|
if not self.licenseplate and minetest.get_modpath("signs") ~= nil then
|
|
self.licenseplate = minetest.add_entity(pos, "cars:licenseplate")
|
|
end
|
|
if self.licenseplate then
|
|
self.licenseplate:set_attach(self.object, "", def.licenseplate, {x = 0, y = 0, z = 0})
|
|
end
|
|
end,
|
|
get_staticdata = function(self)
|
|
return minetest.serialize({trunk = serializeContents(self.trunkinv), plate = self.platenumber})
|
|
end,
|
|
on_step = function(self, dtime)
|
|
car_step(self, dtime)
|
|
end,
|
|
on_punch = function(self, puncher, time_from_last_punch, tool_capabilities, dir)
|
|
if puncher == self.passengers[1].player then
|
|
minetest.sound_play(def.horn, {
|
|
max_hear_distance = 48,
|
|
gain = 8,
|
|
object = self.object
|
|
})
|
|
return
|
|
end
|
|
if (puncher:get_wielded_item():get_name() == "") and (time_from_last_punch >= tool_capabilities.full_punch_interval) and math.random(1,2) == 1 then
|
|
local closeid = getClosest(puncher, self)
|
|
if DEBUG_TEXT then
|
|
minetest.chat_send_all(tostring(closeid))
|
|
end
|
|
if not closeid or closeid == 0 then return end
|
|
detach(self.passengers[closeid].player)
|
|
end
|
|
end,
|
|
on_rightclick = function(self, clicker)
|
|
if not clicker or not clicker:is_player() then
|
|
return
|
|
end
|
|
local name = clicker:get_player_name()
|
|
if player_attached[name] == self then
|
|
detach(clicker)
|
|
elseif player_attached[name] then
|
|
return
|
|
else
|
|
local i = 0
|
|
local closeid = getClosest(clicker, self)
|
|
if DEBUG_TEXT then
|
|
minetest.chat_send_all(tostring(closeid))
|
|
end
|
|
if closeid then
|
|
if closeid == 0 then
|
|
minetest.sound_play("opentrunk", {
|
|
max_hear_distance = 24,
|
|
gain = 1,
|
|
object = self.object
|
|
})
|
|
trunk_rightclick(self, clicker)
|
|
return
|
|
end
|
|
if not self.passengers[closeid].player then
|
|
i = closeid
|
|
end
|
|
else
|
|
while i <= #self.passengers do
|
|
i = i + 1
|
|
if not self.passengers[i].player then break end
|
|
end
|
|
end
|
|
if i == 0 or i == #self.passengers+1 then return end
|
|
self.passengers[i].player = clicker
|
|
--add hud for driver
|
|
if i == 1 then
|
|
self.hud = clicker:hud_add({
|
|
hud_elem_type = "text",
|
|
position = {x = 0.5, y = 0.8},
|
|
offset = {x = 0, y = 0},
|
|
text = tostring(math.abs(math.floor(self.v*2.23694*10)/10)).." MPH",
|
|
alignment = {x = 0, y = 0}, -- center aligned
|
|
scale = {x = 100, y = 100}, -- covered later
|
|
number = 0xFFFFFF,
|
|
})
|
|
end
|
|
|
|
player_attached[name] = self
|
|
clicker:set_attach(self.object, "",
|
|
self.passengers[i].loc, {x = 0, y = 0, z = 0})
|
|
clicker:set_eye_offset(self.passengers[i].offset, {x=0,y=0,z=0})
|
|
default.player_attached[name] = true
|
|
minetest.after(.1, function()
|
|
default.player_set_animation(clicker, "sit" , 30)
|
|
end)
|
|
clicker:set_look_horizontal(self.object:getyaw())
|
|
end
|
|
end
|
|
})
|
|
minetest.register_craftitem(def.name, {
|
|
description = def.description,
|
|
inventory_image = def.inventory_image,
|
|
on_place = function(itemstack, placer, pointed_thing)
|
|
if pointed_thing.type ~= "node" then
|
|
return
|
|
end
|
|
local ent
|
|
if minetest.get_item_group(minetest.get_node(pointed_thing.under).name, "liquid") == 0 then
|
|
pointed_thing.above.y = pointed_thing.above.y - 0.5
|
|
ent = minetest.add_entity(pointed_thing.above, def.name)
|
|
end
|
|
ent:setyaw(placer:get_look_yaw() - math.pi/2)
|
|
itemstack:take_item()
|
|
return itemstack
|
|
end
|
|
})
|
|
if def.recipe then
|
|
minetest.register_craft({
|
|
output = def.name,
|
|
recipe = def.recipe
|
|
})
|
|
end
|
|
end
|
|
|
|
minetest.register_entity("cars:wheel", {
|
|
hp_max = 1,
|
|
physical = false,
|
|
pointable = false,
|
|
collide_with_objects = false,
|
|
weight = 5,
|
|
collisionbox = {-0.2,-0.2,-0.2, 0.2,0.2,0.2},
|
|
visual = "mesh",
|
|
visual_size = {x=1, y=1},
|
|
mesh = "wheel.x",
|
|
textures = {"car_dark_grey.png"}, -- number of required textures depends on visual
|
|
is_visible = true,
|
|
--makes_footstep_sound = false,
|
|
--automatic_rotate = true,
|
|
on_activate = function(self, staticdata, dtime_s)
|
|
minetest.after(.1, function()
|
|
if not self.object:get_attach() then
|
|
self.object:remove()
|
|
end
|
|
end)
|
|
end,
|
|
})
|
|
minetest.register_entity("cars:licenseplate", {
|
|
collisionbox = { 0, 0, 0, 0, 0, 0 },
|
|
visual = "upright_sprite",
|
|
textures = {"invisible.png"},
|
|
visual_size = {x=1.2, y=1.2, z=1.2},
|
|
physical = false,
|
|
pointable = false,
|
|
collide_with_objects = false,
|
|
on_activate = function(self)
|
|
minetest.after(.1, function()
|
|
if not self.object:get_attach() or minetest.get_modpath("signs") == nil then
|
|
self.object:remove()
|
|
else
|
|
self.object:set_armor_groups({immortal = 1})
|
|
local text = self.object:get_attach():get_luaentity().platenumber.text
|
|
if not text then return end
|
|
self.object:set_properties({textures={generate_texture(create_lines(text))}})
|
|
end
|
|
end)
|
|
end
|
|
})
|
|
minetest.register_entity("cars:steeringwheel", {
|
|
hp_max = 1,
|
|
physical = false,
|
|
pointable = false,
|
|
collide_with_objects = false,
|
|
weight = 5,
|
|
collisionbox = {-0.2,-0.3,-0.2, 0.2,0.3,0.2},
|
|
visual = "mesh",
|
|
visual_size = {x=1, y=1},
|
|
mesh = "steering.x",
|
|
textures = {"car_dark_grey.png"}, -- number of required textures depends on visual
|
|
is_visible = true,
|
|
--makes_footstep_sound = false,
|
|
--automatic_rotate = true,
|
|
on_punch = function(self, puncher, time_from_last_punch, tool_capabilities, dir)
|
|
minetest.sound_play("horn", {
|
|
max_hear_distance = 48,
|
|
gain = 8,
|
|
object = self.object
|
|
})
|
|
end,
|
|
on_activate = function(self, staticdata, dtime_s)
|
|
minetest.after(.1, function()
|
|
if not self.object:get_attach() then
|
|
self.object:remove()
|
|
else
|
|
self.object:set_armor_groups({immortal = 1})
|
|
end
|
|
end)
|
|
end,
|
|
})
|
|
|
|
minetest.register_on_leaveplayer(function(player)
|
|
detach(player)
|
|
end)
|
|
minetest.register_on_dieplayer(function(player)
|
|
detach(player)
|
|
end)
|
|
|
|
dofile(minetest.get_modpath("cars").."/car01.lua") |