api/network.lua

@@ -41,102 +41,6 @@ local function clampFlow(pos,flow)
 	return math.min(flow,newFlow)
 end
 
--- \brief Finds path from pos to dest in network. Function finished if either dest is found or every node was visited
--- \param pos Vector
--- \param dest Vector
--- \returns table or nil
-function industrialtest.api.findPathInNetwork(pos,dest)
-	local connections=industrialtest.api.getConnections(pos,"i")
-	if #connections==0 then
-		return nil
-	end
-
-	local workers={}
-	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
-	local visitedNodes={[serializedSourcePos]=true}
-	for _,conn in ipairs(connections) do
-		local sideVector=vector.subtract(conn,pos)
-		table.insert(workers,{
-			position=conn,
-			direction=sideVector,
-			path={[1]=conn}
-		})
-	end
-
-	while #workers>0 do
-		for i=1,#workers do
-			local worker=workers[i]
-			local serializedPos=worker.position.x..","..worker.position.y..","..worker.position.z
-			if visitedNodes[serializedPos] then
-				table.remove(workers,i)
-				break
-			end
-			visitedNodes[serializedPos]=true
-
-			if worker.position.x==dest.x and worker.position.y==dest.y and worker.position.z==dest.z then
-				return worker.path
-			end
-
-			local def=minetest.registered_nodes[minetest.get_node(worker.position).name]
-			if def and def.groups and def.groups._industrialtest_cable then
-				connections=industrialtest.api.getConnections(worker.position,"i")
-				for j=1,#connections do
-					local direction=vector.subtract(connections[j],worker.position)
-					local oppositeDirection=vector.multiply(worker.direction,vector.new(-1,-1,-1))
-					if direction.x~=oppositeDirection.x or direction.y~=oppositeDirection.y or direction.z~=oppositeDirection.z then
-						if worker.direction.x~=direction.x or worker.direction.y~=direction.y or worker.direction.z~=direction.z then
-							table.insert(worker.path,worker.position)
-						end
-						for c=1,#connections do
-							local nextDirection=vector.subtract(connections[c],worker.position)
-							if c~=j and (nextDirection.x~=oppositeDirection.x or nextDirection.y~=oppositeDirection.y or nextDirection.z~=oppositeDirection.z) then
-								local newWorker={
-									position=connections[c],
-									direction=nextDirection,
-									path=table.copy(worker.path)
-								}
-								table.insert(newWorker.path,worker.position)
-								table.insert(workers,newWorker)
-							end
-						end
-						worker.direction=direction
-						worker.position=connections[j]
-						break
-					end
-				end
-
-				if #connections>2 then
-					break
-				end
-			else
-				table.remove(workers,i)
-				break
-			end
-		end
-	end
-
-	return nil
-end
-
--- \brief Goes through path vertices specified by path running callback on each node.
---        Function finishes if either callback returns false or entire path is went over.
--- \param path table
--- \param callback function
--- \returns nil
-function industrialtest.api.walkPath(path,callback)
-	local pos=path[1]
-	for i=2,#path do
-		local pathNode=path[i]
-		local direction=vector.normalize(vector.subtract(pathNode,pos))
-		while pos.x~=pathNode.x or pos.y~=pathNode.y or pos.z~=pathNode.z do
-			if not callback(pos) then
-				return
-			end
-			pos=vector.add(pos,direction)
-		end
-	end
-end
-
 -- \brief Transfers power from source node to it's network, if sides is set then power will be only transfered to network connected to that sides
 -- \param pos Vector with position of source node
 -- \param (optional) sides table with Vectors
@@ -196,37 +100,9 @@ function industrialtest.api.powerFlow(pos,sides,flowOverride)
 					roomAvailable=true
 				end
 			else
-				local path=industrialtest.api.findPathInNetwork(pos,endpoint.position)
-				if path and #path>0 then
-					table.insert(path,endpoint.position)
-					local removed=false
-					industrialtest.api.walkPath(path,function(pathPos)
-						local def=minetest.registered_nodes[minetest.get_node(pathPos).name]
-						if not def or not def.groups or not def.groups._industrialtest_cable then
-							return false
-						end
-						if powerDistribution>def._industrialtest_cableFlow then
-							removed=true
-							minetest.swap_node(pathPos,{
-								name="air"
-							})
-							minetest.remove_node(pathPos)
-							minetest.check_for_falling(pathPos)
-							minetest.sound_play("default_cool_lava",{
-								pos=pathPos,
-								max_hear_distance=5,
-								gain=0.7
-							})
-						end
-						return true
-					end)
-					if not removed and powerDistribution>endpoint.originalFlow then
 				minetest.remove_node(endpoint.position)
 				industrialtest.internal.explode(endpoint.position,2)
 			end
-					industrialtest.api.createNetworkMapForNode(pos)
-				end
-			end
 		end
 	end
 	return roomAvailable,transferred
@@ -323,7 +199,6 @@ function industrialtest.api.createNetworkMap(pos,addCables,omit)
 					position=worker.position,
 					distance=worker.distance,
 					flow=math.min(worker.flow,flow),
-					originalFlow=flow,
 					side=connectionSide,
 					sourceSide=worker.sourceSide
 				})
@@ -396,34 +271,6 @@ function industrialtest.api.getNetwork(meta)
 	return minetest.deserialize(meta:get_string("industrialtest.network"))
 end
 
--- \brief Returns amount of power that will flow from specified network master
--- \param pos Vector
--- \returns number
-function industrialtest.api.getFlowingCurrent(pos)
-	local meta=minetest.get_meta(pos)
-	if not industrialtest.api.hasPowerStorage(meta) or meta:get_int("industrialtest.powerAmount")==0 then
-		return 0
-	end
-	local network=industrialtest.api.getNetwork(meta)
-	if not network then
-		return 0
-	end
-
-	local amount=meta:get_int("industrialtest.powerAmount")
-	if amount==0 then
-		return 0
-	end
-	local demand=0
-	for _,endpoint in ipairs(network) do
-		local endpointMeta=minetest.get_meta(endpoint.position)
-		if industrialtest.api.hasPowerStorage(endpointMeta) then
-			demand=demand+math.min(endpointMeta:get_int("industrialtest.powerCapacity")-endpointMeta:get_int("industrialtest.powerAmount"),endpoint.flow)
-		end
-	end
-
-	return math.min(amount,demand)
-end
-
 -- \brief Returns connections of node with power storage. If direction is "i" only input connections will be returned, if direction is "o" only output connections
 --        will be returned, if it's not provided all connections will be returned.
 -- \param pos Vector

cables.lua

@@ -162,15 +162,12 @@ function industrialtest.Cable.createDefinitionTable(self,description,inventoryIm
 		def.sound=mcl_sounds.node_sound_metal_defaults()
 	end
 	def.groups._industrialtest_cable=1
-	if insulated then
-		def.groups._industrialtest_insulatedCable=1
-	end
 
 	return def
 end
 
 function industrialtest.Cable.register(self)
-	local def=self:createDefinitionTable(self.description,self.inventoryImage,self.tile,self.safe)
+	local def=self:createDefinitionTable(self.description,self.inventoryImage,self.tile,false)
 	minetest.register_node(self.name,def)
 
 	if self.insulated then
@@ -388,7 +385,6 @@ industrialtest.internal.unpackTableInto(industrialtest.GlassFibreCable,{
 	inventoryImage="industrialtest_glass_fibre_cable_inv.png",
 	transparent=true,
 	tile="industrialtest_glass_fibre_cable.png",
-	safe=true,
 	size=0.12,
 	flow=industrialtest.api.ivPowerFlow
 })
@@ -405,52 +401,3 @@ minetest.register_craft({
 	}
 })
 -- TODO: Add glass fibre cable craft with silver ingot
-
-if industrialtest.config.electrocution then
-	local electrocutionDelta=0
-	minetest.register_globalstep(function(dtime)
-		electrocutionDelta=electrocutionDelta+dtime
-		if electrocutionDelta<industrialtest.config.updateDelay then
-			return
-		end
-		electrocutionDelta=0
-
-		local offsets={
-			vector.new(0,0,0),
-			vector.new(-0.7,0,0),
-			vector.new(-0.7,1,0),
-			vector.new(0,1,0),
-			vector.new(0.7,0,0),
-			vector.new(0.7,1,0),
-			vector.new(0,0,-0.7),
-			vector.new(0,1,-0.7),
-			vector.new(0,0,0.7),
-			vector.new(0,1,0.7)
-		}
-
-		local players=minetest.get_connected_players()
-		for _,player in ipairs(players) do
-			local pos=player:get_pos()
-			for _,offset in ipairs(offsets) do
-				local nodePos=vector.add(pos,offset)
-				local node=minetest.get_node(nodePos)
-				local def=minetest.registered_nodes[node.name]
-				if def and def.groups and def.groups._industrialtest_cable and not def.groups._industrialtest_insulatedCable then
-					local meta=minetest.get_meta(pos)
-					local networks=industrialtest.api.isAttachedToNetwork(meta)
-					if networks then
-						local current=0
-						for _,network in ipairs(networks) do
-							current=current+industrialtest.api.getFlowingCurrent(network)
-						end
-						if current>0 then
-							local removed=math.ceil(current/500)
-							player:set_hp(player:get_hp()-removed,"electrocution")
-							break
-						end
-					end
-				end
-			end
-		end
-	end)
-end

init.lua

@@ -21,8 +21,7 @@ industrialtest={}
 
 -- Settings
 industrialtest.config={
-	updateDelay=tonumber(minetest.settings:get("industrialtest.updateDelay") or "1"),
+	updateDelay=minetest.settings:get("industrialtest.updateDelay") or 1,
-	electrocution=minetest.settings:get_bool("industrialtest.electrocution",true),
 	developerMode=minetest.settings:get_bool("industrialtest.developerMode",false)
 }
 

settingtypes.txt

@@ -1,8 +1,5 @@
 # This determines value how frequently machines update
 industrialtest.updateDelay (Update delay) float 1.0
 
-# Whether electrocution by uninsulated cables is used
-industrialtest.electrocution (Electrocution) bool true
-
 # Enables additional utils useful when developing mod
 industrialtest.developerMode (Developer mode) bool false