advtrains.git - Advtrains mod for minetest.

diff options

Diffstat (limited to 'advtrains/textures/advtrains_track_swlcr_45.png')

-rwxr-xr-x

advtrains/textures/advtrains_track_swlcr_45.png

bin

0 -> 45772 bytes

1 files changed, 0 insertions, 0 deletions

--trainlogic.lua --controls train entities stuff about connecting/disconnecting/colliding trains and other things local benchmark=false local bm={} local bmlt=0 local bmsteps=0 local bmstepint=200 atprintbm=function(action, ta) if not benchmark then return end local t=(os.clock()-ta)*1000 if not bm[action] then bm[action]=t else bm[action]=bm[action]+t end bmlt=bmlt+t end function endstep() if not benchmark then return end bmsteps=bmsteps-1 if bmsteps<=0 then bmsteps=bmstepint for key, value in pairs(bm) do minetest.chat_send_all(key.." "..(value/bmstepint).." ms avg.") end minetest.chat_send_all("Total time consumed by all advtrains actions per step: "..(bmlt/bmstepint).." ms avg.") bm={} bmlt=0 end end --acceleration for lever modes (trainhud.lua), per wagon local t_accel_all={ [0] = -10, [1] = -3, [2] = -0.5, [4] = 0.5, } --acceleration per engine local t_accel_eng={ [0] = 0, [1] = 0, [2] = 0, [4] = 1.5, } advtrains.mainloop_trainlogic=function(dtime) --build a table of all players indexed by pts. used by damage and door system. advtrains.playersbypts={} for _, player in pairs(minetest.get_connected_players()) do if not advtrains.player_to_train_mapping[player:get_player_name()] then --players in train are not subject to damage local ptspos=minetest.pos_to_string(vector.round(player:getpos())) advtrains.playersbypts[ptspos]=player end end --regular train step -- do in two steps: -- a: predict path and add all nodes to the advtrains.detector.on_node table -- b: check for collisions based on these data -- (and more) local t=os.clock() advtrains.detector.on_node={} for k,v in pairs(advtrains.trains) do advtrains.atprint_context_tid=sid(k) advtrains.atprint_context_tid_full=k advtrains.train_step_a(k, v, dtime) end for k,v in pairs(advtrains.trains) do advtrains.atprint_context_tid=sid(k) advtrains.atprint_context_tid_full=k advtrains.train_step_b(k, v, dtime) end advtrains.atprint_context_tid=nil advtrains.atprint_context_tid_full=nil atprintbm("trainsteps", t) endstep() end minetest.register_on_joinplayer(function(player) return advtrains.pcall(function() local pname=player:get_player_name() local id=advtrains.player_to_train_mapping[pname] if id then local train=advtrains.trains[id] if not train then advtrains.player_to_train_mapping[pname]=nil return end --set the player to the train position. --minetest will emerge the area and load the objects, which then will call reattach_all(). --because player is in mapping, it will not be subject to dying. player:setpos(train.last_pos_prev) --independent of this, cause all wagons of the train which are loaded to reattach their players --needed because already loaded wagons won't call reattach_all() for _,wagon in pairs(minetest.luaentities) do if wagon.is_wagon and wagon.initialized and wagon.train_id==id then wagon:reattach_all() end end end end) end) minetest.register_on_dieplayer(function(player) return advtrains.pcall(function() local pname=player:get_player_name() local id=advtrains.player_to_train_mapping[pname] if id then local train=advtrains.trains[id] if not train then advtrains.player_to_train_mapping[pname]=nil return end for _,wagon in pairs(minetest.luaentities) do if wagon.is_wagon and wagon.initialized and wagon.train_id==id then --when player dies, detach him from the train --call get_off_plr on every wagon since we don't know which one he's on. wagon:get_off_plr(pname) end end end end) end) --[[ train step structure: - legacy stuff - preparing the initial path and creating index - setting node coverage old indices - handle velocity influences: - off-track - atc - player controls - environment collision - update index = move - create path - call stay_node on all old positions to register train there, for collision system - do less important stuff such as checking trainpartload or removing -- break -- - Call enter_node and leave_node callbacks (required here because stay_node needs to be called on all trains first) - handle train collisions ]] function advtrains.train_step_a(id, train, dtime) --atprint("--- runcnt ",advtrains.mainloop_runcnt,": index",train.index,"end_index", train.end_index,"| max_iot", train.max_index_on_track, "min_iot", train.min_index_on_track, "<> pe_min", train.path_extent_min,"pe_max", train.path_extent_max) if train.min_index_on_track then assert(math.floor(train.min_index_on_track)==train.min_index_on_track) end --- 1. not exactly legacy. required now because of saving --- if not train.drives_on or not train.max_speed then advtrains.update_trainpart_properties(id) end --TODO check for all vars to be present if not train.velocity then train.velocity=0 end if not train.movedir or (train.movedir~=1 and train.movedir~=-1) then train.movedir=1 end --- 2. prepare initial path and index if needed --- if not train.index then train.index=0 end if not train.path then if not train.last_pos then --no chance to recover atwarn("Unable to restore train ",id,": missing last_pos") advtrains.trains[id]=nil return false end local node_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(train.last_pos), train.drives_on) if node_ok==nil then --block not loaded, do nothing atprint("last_pos", advtrains.round_vector_floor_y(train.last_pos), "not loaded and not in ndb, waiting") return nil elseif node_ok==false then atprint("Unable to restore train ",id,": No rail at train's position") return false end if not train.last_pos_prev then --no chance to recover atwarn("Unable to restore train ",id,": missing last_pos_prev") advtrains.trains[id]=nil return false end local prevnode_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(train.last_pos_prev), train.drives_on) if prevnode_ok==nil then --block not loaded, do nothing atprint("last_pos_prev", advtrains.round_vector_floor_y(train.last_pos_prev), "not loaded and not in ndb, waiting") return nil elseif prevnode_ok==false then atprint("Unable to restore train ",id,": No rail at train's position") return false end train.index=(train.restore_add_index or 0)+(train.savedpos_off_track_index_offset or 0) --restore_add_index is set by save() to prevent trains hopping to next round index. should be between -0.5 and 0.5 --savedpos_off_track_index_offset is set if train went off track. see below. train.path={} train.path_dist={} train.path[0]=train.last_pos train.path[-1]=train.last_pos_prev train.path_dist[-1]=vector.distance(train.last_pos, train.last_pos_prev) train.path_extent_min=-1 train.path_extent_max=0 train.min_index_on_track=-1 train.max_index_on_track=0 --[[ Bugfix for trains randomly ignoring ATC rails: - Paths have been invalidated. 1 gets executed and ensures an initial path - 2a sets train end index. The problem is that path_dist is not known for the whole path, so train end index will be nearly trainlen - Since the detector indices are also unknown, they get set to the new (wrong) train_end_index. Enter_node calls are not executed for the nodes that lie in between real end_index and trainlen. - The next step, mistake is recognized, train leaves some positions. From there, everything works again. To overcome this, we will generate the full required path here so that path_dist is available for get_train_end_index(). ]] advtrains.pathpredict(id, train, 3, -train.trainlen-3) end --- 2a. set train.end_index which is required in different places, IF IT IS NOT SET YET by STMT afterwards. --- --- table entry to avoid triple recalculation --- if not train.end_index then train.end_index=advtrains.get_train_end_index(train) end --- 2b. set node coverage old indices --- train.detector_old_index = atround(train.index) train.detector_old_end_index = atround(train.end_index) --- 3. handle velocity influences --- local train_moves=(train.velocity~=0) local tarvel_cap if train.recently_collided_with_env then tarvel_cap=0 train.active_control=false if not train_moves then train.recently_collided_with_env=nil--reset status when stopped end end if train.locomotives_in_train==0 then tarvel_cap=0 end --- 3a. this can be useful for debugs/warnings and is used for check_trainpartload --- local t_info, train_pos=sid(id), train.path[atround(train.index)] if train_pos then t_info=t_info.." @"..minetest.pos_to_string(train_pos) --atprint("train_pos:",train_pos) end --apply off-track handling: local front_off_track=train.max_index_on_track and train.index>train.max_index_on_track local back_off_track=train.min_index_on_track and train.end_index<train.min_index_on_track local pprint if front_off_track and back_off_track then--allow movement in both directions tarvel_cap=1 elseif front_off_track then--allow movement only backward if train.movedir==1 then tarvel_cap=0 end if train.movedir==-1 then tarvel_cap=1 end elseif back_off_track then--allow movement only forward if train.movedir==1 then tarvel_cap=1 end if train.movedir==-1 then tarvel_cap=0 end end --interpret ATC command and apply auto-lever control when not actively controlled local trainvelocity = train.velocity if not train.lever then train.lever=3 end if train.active_control then advtrains.atc.train_reset_command(id) else if train.atc_brake_target and train.atc_brake_target>=trainvelocity then train.atc_brake_target=nil end if train.atc_wait_finish then if not train.atc_brake_target and train.velocity==train.tarvelocity then train.atc_wait_finish=nil end end if train.atc_command then if train.atc_delay<=0 and not train.atc_wait_finish then advtrains.atc.execute_atc_command(id, train) else train.atc_delay=train.atc_delay-dtime end end train.lever = 3 if train.tarvelocity>trainvelocity then train.lever=4 end if train.tarvelocity<trainvelocity then if (train.atc_brake_target and train.atc_brake_target<trainvelocity) then train.lever=1 else train.lever=2 end end end if tarvel_cap and tarvel_cap<train.tarvelocity then train.tarvelocity=tarvel_cap end local tmp_lever = train.lever if tarvel_cap and trainvelocity>tarvel_cap then tmp_lever = 0 end --- 3a. actually calculate new velocity --- if tmp_lever~=3 then local acc_all = t_accel_all[tmp_lever] local acc_eng = t_accel_eng[tmp_lever] local nwagons = #train.trainparts local accel = acc_all + (acc_eng*train.locomotives_in_train)/nwagons local vdiff = accel*dtime if not train.active_control then local tvdiff = train.tarvelocity - trainvelocity if math.abs(vdiff) > math.abs(tvdiff) then --applying this change would cross tarvelocity vdiff=tvdiff end end if tarvel_cap and trainvelocity<=tarvel_cap and trainvelocity+vdiff>tarvel_cap then vdiff = tarvel_cap - train.velocity end if trainvelocity+vdiff < 0 then vdiff = - trainvelocity end local mspeed = (train.max_speed or 10) if trainvelocity+vdiff > mspeed then vdiff = mspeed - trainvelocity end train.last_accel=(vdiff*train.movedir) train.velocity=train.velocity+vdiff if train.active_control then train.tarvelocity = train.velocity end else train.last_accel = 0 end --- 4. move train --- train.index=train.index and train.index+(((train.velocity*train.movedir)/(train.path_dist[math.floor(train.index)] or 1))*dtime) or 0 --- 4a. update train.end_index to the new position --- train.end_index=advtrains.get_train_end_index(train) --- 4b calculate how far a path is required --- local path_req_dd = 10 -- path required in driving direction local path_req_ndd = 4 -- path required against driving direction -- when using easyBSS (block signalling), we need to make sure that the whole brake distance is known if advtrains_easybss then local acc_all = t_accel_all[1] local acc_eng = t_accel_eng[1] local nwagons = #train.trainparts local acc = acc_all + (acc_eng*train.locomotives_in_train)/nwagons local vel = train.velocity local brakedst = (vel*vel) / (2*acc) path_req_dd = math.ceil(brakedst+10) end local idx_front=math.max(train.index, train.detector_old_index) local idx_back=math.min(train.end_index, train.detector_old_end_index) local path_req_front, path_req_back if train.movedir == 1 then path_req_front = atround(idx_front + path_req_dd) path_req_back = atround(idx_back - path_req_ndd) else path_req_front = atround(idx_front + path_req_ndd) path_req_back = atround(idx_back - path_req_dd) end --- 5. extend path as necessary --- --why this is an extra function, see under 3. advtrains.pathpredict(id, train, path_req_front, path_req_back) --- 5a. make pos/yaw available for possible recover calls --- if train.max_index_on_track<train.index then --whoops, train went too far. the saved position will be the last one that lies on a track, and savedpos_off_track_index_offset will hold how far to go from here train.savedpos_off_track_index_offset=atround(train.index)-train.max_index_on_track train.last_pos=train.path[train.max_index_on_track] train.last_pos_prev=train.path[train.max_index_on_track-1] atprint("train is off-track (front), last positions kept at", train.last_pos, "/", train.last_pos_prev) elseif train.min_index_on_track+1>train.index then --whoops, train went even more far. same behavior train.savedpos_off_track_index_offset=atround(train.index)-train.min_index_on_track train.last_pos=train.path[train.min_index_on_track+1] train.last_pos_prev=train.path[train.min_index_on_track] atprint("train is off-track (back), last positions kept at", train.last_pos, "/", train.last_pos_prev) else --regular case train.savedpos_off_track_index_offset=nil train.last_pos=train.path[math.floor(train.index+1)] train.last_pos_prev=train.path[math.floor(train.index)] end --- 5b. Remove path items that are no longer used --- -- Necessary since path items are no longer invalidated in save steps local del_keep=8 local offtrack_keep=4 local delete_min=math.min(train.max_index_on_track - offtrack_keep, path_req_back - del_keep) local delete_max=math.max(train.min_index_on_track + offtrack_keep, path_req_front + del_keep) if train.path_extent_min<delete_min then --atprint(sid(id),"clearing path min ",train.path_extent_min," to ",delete_min) for i=train.path_extent_min,delete_min-1 do train.path[i]=nil train.path_dist[i]=nil end train.path_extent_min=delete_min train.min_index_on_track=math.max(train.min_index_on_track, delete_min) end if train.path_extent_max>delete_max then --atprint(sid(id),"clearing path max ",train.path_extent_max," to ",delete_max) train.path_dist[delete_max]=nil for i=delete_max+1,train.path_extent_max do train.path[i]=nil train.path_dist[i]=nil end train.path_extent_max=delete_max train.max_index_on_track=math.min(train.max_index_on_track, delete_max) end --- 6b. call stay_node to register trains in the location table - actual enter_node stuff is done in step b --- local ifo, ibo = train.detector_old_index, train.detector_old_end_index local path=train.path for i=ibo, ifo do if path[i] then advtrains.detector.stay_node(path[i], id) end end --- 7. do less important stuff --- --check for any trainpart entities if they have been unloaded. do this only if train is near a player, to not spawn entities into unloaded areas train.check_trainpartload=(train.check_trainpartload or 0)-dtime local node_range=(math.max((minetest.settings:get("active_block_range") or 0),1)*16) if train.check_trainpartload<=0 then local ori_pos=train_pos --see 3a. --atprint("[train "..id.."] at "..minetest.pos_to_string(vector.round(ori_pos))) local should_check=false for _,p in ipairs(minetest.get_connected_players()) do should_check=should_check or (ori_pos and ((vector.distance(ori_pos, p:getpos())<node_range))) end if should_check then advtrains.update_trainpart_properties(id) end train.check_trainpartload=2 end --remove? if #train.trainparts==0 then atprint("[train "..sid(id).."] has empty trainparts, removing.") advtrains.detector.leave_node(path[train.detector_old_index], id) advtrains.trains[id]=nil return end end function advtrains.train_step_b(id, train, dtime) --hacky fix: if train_step_a returned in phase 2, end_index may not be set. --just return if not train.index or not train.end_index then return end --- 6. update node coverage --- -- when paths get cleared, the old indices set above will be up-to-date and represent the state in which the last run of this code was made local ifo, ifn, ibo, ibn = train.detector_old_index, atround(train.index), train.detector_old_end_index, atround(train.end_index) --atprint(ifo,">", ifn, "<==>", ibo,">", ibn) local path=train.path if train.enter_node_all then --field set by create_new_train_at. --ensures that new train calls enter_node on all nodes for i=ibn, ifn do if path[i] then advtrains.detector.enter_node(path[i], id) end end train.enter_node_all=nil else if ifn>ifo then for i=ifo+1, ifn do if path[i] then if advtrains.detector.occupied(path[i], id) then --if another train has signed up for this position first, it won't be recognized in train_step_b. So do collision here. atprint("Collision detected in enter_node callbacks (front) @",path[i],"with",sid(advtrains.detector.get(path[i], id))) advtrains.collide_and_spawn_couple(id, path[i], advtrains.detector.get(path[i], id), false) end atprint("enter_node (front) @index",i,"@",path[i],"on_node",sid(advtrains.detector.get(path[i], id))) advtrains.detector.enter_node(path[i], id) end end elseif ifn<ifo then for i=ifn+1, ifo do if path[i] then advtrains.detector.leave_node(path[i], id) end end end if ibn<ibo then for i=ibn, ibo-1 do if path[i] then local pts=minetest.pos_to_string(path[i]) if advtrains.detector.occupied(path[i], id) then --if another train has signed up for this position first, it won't be recognized in train_step_b. So do collision here. atprint("Collision detected in enter_node callbacks (back) @",path[i],"with",sid(advtrains.detector.get(path[i], id))) advtrains.collide_and_spawn_couple(id, path[i], advtrains.detector.get(path[i], id), true) end atprint("enter_node (back) @index",i,"@",path[i],"on_node",sid(advtrains.detector.get(path[i], id))) advtrains.detector.enter_node(path[i], id) end end elseif ibn>ibo then for i=ibo, ibn-1 do if path[i] then advtrains.detector.leave_node(path[i], id) end end end end --- 8. check for collisions with other trains and damage players --- local train_moves=(train.velocity~=0) if train_moves then --TO BE REMOVED: if not train.extent_h then advtrains.update_trainpart_properties(id) end local collpos local coll_grace=1 if train.movedir==1 then collpos=advtrains.get_real_index_position(train.path, train.index-coll_grace) else collpos=advtrains.get_real_index_position(train.path, train.end_index+coll_grace) end if collpos then local rcollpos=advtrains.round_vector_floor_y(collpos) for x=-train.extent_h,train.extent_h do for z=-train.extent_h,train.extent_h do local testpos=vector.add(rcollpos, {x=x, y=0, z=z}) --- 8a Check collision --- if advtrains.detector.occupied(testpos, id) then --collides advtrains.collide_and_spawn_couple(id, testpos, advtrains.detector.get(testpos, id), train.movedir==-1) end --- 8b damage players --- if not minetest.settings:get_bool("creative_mode") then local testpts = minetest.pos_to_string(testpos) local player=advtrains.playersbypts[testpts] if player and not minetest.check_player_privs(player, "creative") and train.velocity>3 then --instantly kill player --drop inventory contents first, to not to spawn bones local player_inv=player:get_inventory() for i=1,player_inv:get_size("main") do minetest.add_item(testpos, player_inv:get_stack("main", i)) end for i=1,player_inv:get_size("craft") do minetest.add_item(testpos, player_inv:get_stack("craft", i)) end -- empty lists main and craft player_inv:set_list("main", {}) player_inv:set_list("craft", {}) player:set_hp(0) end end end end --- 8c damage other objects --- local objs = minetest.get_objects_inside_radius(rcollpos, 2) for _,obj in ipairs(objs) do if not obj:is_player() and obj:get_armor_groups().fleshy and obj:get_armor_groups().fleshy > 0 and obj:get_luaentity() and obj:get_luaentity().name~="signs:text" then obj:punch(obj, 1, { full_punch_interval = 1.0, damage_groups = {fleshy = 1000}, }, nil) end end end end end --returns new id function advtrains.create_new_train_at(pos, pos_prev) local newtrain_id=advtrains.random_id() while advtrains.trains[newtrain_id] do newtrain_id=advtrains.random_id() end--ensure uniqueness advtrains.trains[newtrain_id]={} advtrains.trains[newtrain_id].id = newtrain_id advtrains.trains[newtrain_id].last_pos=pos advtrains.trains[newtrain_id].last_pos_prev=pos_prev advtrains.trains[newtrain_id].tarvelocity=0 advtrains.trains[newtrain_id].velocity=0 advtrains.trains[newtrain_id].trainparts={} advtrains.trains[newtrain_id].enter_node_all=true return newtrain_id end function advtrains.get_train_end_index(train) return advtrains.get_real_path_index(train, train.trainlen or 2)--this function can be found inside wagons.lua since it's more related to wagons. we just set trainlen as pos_in_train end function advtrains.add_wagon_to_train(wagon_id, train_id, index) local train=advtrains.trains[train_id] if index then table.insert(train.trainparts, index, wagon_id) else table.insert(train.trainparts, wagon_id) end advtrains.update_trainpart_properties(train_id) end -- this function sets wagon's pos_in_train(parts) properties and train's max_speed and drives_on (and more) function advtrains.update_trainpart_properties(train_id, invert_flipstate) local train=advtrains.trains[train_id] train.drives_on=advtrains.merge_tables(advtrains.all_tracktypes) --FIX: deep-copy the table!!! train.max_speed=20 train.extent_h = 0; local rel_pos=0 local count_l=0 local shift_dcpl_lock=false for i, w_id in ipairs(train.trainparts) do local data = advtrains.wagons[w_id] -- 1st: update wagon data (pos_in_train a.s.o) if data then local wagon = minetest.registered_luaentites[data.type] if not wagon then atwarn("Wagon '",data.type,"' couldn't be found. Please check that all required modules are loaded!") wagon = minetest.registered_luaentites["advtrains:wagon_placeholder"] end rel_pos=rel_pos+wagon.wagon_span data.train_id=train_id data.pos_in_train=rel_pos data.pos_in_trainparts=i if wagon.is_locomotive then count_l=count_l+1 end if invert_flipstate then data.wagon_flipped = not data.wagon_flipped shift_dcpl_lock, data.dcpl_lock = data.dcpl_lock, shift_dcpl_lock end rel_pos=rel_pos+wagon.wagon_span if wagon.drives_on then for k,_ in pairs(train.drives_on) do if not wagon.drives_on[k] then train.drives_on[k]=nil end end end train.max_speed=math.min(train.max_speed, wagon.max_speed) train.extent_h = math.max(train.extent_h, wagon.extent_h or 1); end end end -- This function checks whether entities need to be spawned for certain wagons, and spawns them. function advtrains.spawn_wagons(train_id) local train=advtrains.trains[train_id] for i, w_id in ipairs(train.trainparts) do local data = advtrains.wagons[w_id] if data then if not data.object or not data.object:getyaw() then -- eventually need to spawn new object. check if position is loaded. local index = advtrains.path_get_index_by_offset(train, train.index, -data.pos_in_train) local pos = advtrains.path_get(train, atfloor(index)) if minetest.get_node_or_nil(pos) then local wt = data.type if not minetest.registered_luaentities[wt] then atprint("Unable to load",w_id,"of type",wt,", using placeholder") wt="advtrains:wagon_placeholder" end wagon=minetest.add_entity(pos, wt):get_luaentity() wagon:set_id(w_id) end end end end end function advtrains.split_train_at_wagon(wagon) --get train local train=advtrains.trains[wagon.train_id] if not train.path then return end local real_pos_in_train=advtrains.get_real_path_index(train, wagon.pos_in_train) local pos_for_new_train=train.path[math.floor(real_pos_in_train+wagon.wagon_span)] local pos_for_new_train_prev=train.path[math.floor(real_pos_in_train+wagon.wagon_span-1)] --before doing anything, check if both are rails. else do not allow if not pos_for_new_train then atprint("split_train: pos_for_new_train not set") return false end local node_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(pos_for_new_train), train.drives_on) if not node_ok then atprint("split_train: pos_for_new_train ",advtrains.round_vector_floor_y(pos_for_new_train_prev)," not loaded or is not a rail") return false end if not train.last_pos_prev then atprint("split_train: pos_for_new_train_prev not set") return false end local prevnode_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(pos_for_new_train), train.drives_on) if not prevnode_ok then atprint("split_train: pos_for_new_train_prev ", advtrains.round_vector_floor_y(pos_for_new_train_prev), " not loaded or is not a rail") return false end --create subtrain local newtrain_id=advtrains.create_new_train_at(pos_for_new_train, pos_for_new_train_prev) local newtrain=advtrains.trains[newtrain_id] --insert all wagons to new train for k,v in ipairs(train.trainparts) do if k>=wagon.pos_in_trainparts then table.insert(newtrain.trainparts, v) train.trainparts[k]=nil end end --update train parts advtrains.update_trainpart_properties(wagon.train_id)--atm it still is the desierd id. advtrains.update_trainpart_properties(newtrain_id) train.tarvelocity=0 newtrain.velocity=train.velocity newtrain.tarvelocity=0 newtrain.enter_node_all=true newtrain.couple_lck_back=train.couple_lck_back newtrain.couple_lck_front=false train.couple_lck_back=false end --there are 4 cases: --1/2. F<->R F<->R regular, put second train behind first --->frontpos of first train will match backpos of second --3. F<->R R<->F flip one of these trains, take the other as new train --->backpos's will match --4. R<->F F<->R flip one of these trains and take it as new parent --->frontpos's will match --true when trains are facing each other. needed on colliding. -- check done by iterating paths and checking their direction --returns nil when not on the same track at all OR when required path items are not generated. this distinction may not always be needed. function advtrains.trains_facing(train1, train2) local sr_pos=train1.path[atround(train1.index)] local sr_pos_p=train1.path[atround(train1.index)-1] for i=advtrains.minN(train2.path), advtrains.maxN(train2.path) do if vector.equals(sr_pos, train2.path[i]) then if train2.path[i+1] and vector.equals(sr_pos_p, train2.path[i+1]) then return true end if train2.path[i-1] and vector.equals(sr_pos_p, train2.path[i-1]) then return false end return nil end end return nil end function advtrains.collide_and_spawn_couple(id1, pos, id2, t1_is_backpos) if minetest.settings:get_bool("advtrains_disable_collisions") then return end atprint("COLLISION: ",sid(id1)," and ",sid(id2)," at ",pos,", t1_is_backpos=",(t1_is_backpos and "true" or "false"))


context:
space:
mode: