public float getNetworkSpeed(BlockFacing facing)
        {
            MechanicalNetwork network = getNetwork(facing);

            if (network == null)
            {
                return(0);
            }
            return(network.getSpeed());
        }
        public void handleMechanicalRelayPlacement()
        {
            Dictionary <BlockFacing, MechanicalNetwork> networks = new Dictionary <BlockFacing, MechanicalNetwork>();
            List <BlockFacing> nullnetworks = new List <BlockFacing>();

            foreach (BlockFacing facing in BlockFacing.ALLFACES)
            {
                IMechanicalPowerDevice neib = getNeighbourDevice(facing, true);

                if (neib == null)
                {
                    continue;
                }

                MechanicalNetwork network = neib.getNetwork(facing.GetOpposite());

                if (network != null && !networks.ContainsValue(network))
                {
                    networks[facing] = network;
                }

                if (network == null)
                {
                    nullnetworks.Add(facing);
                }
            }

            //System.out.println(worldObj.isRemote + " found " + networks.size() + " networks ");

            if (networks.Count == 1)
            {
                BlockFacing facing = networks.Keys.ToArray()[0];

                trySetNetwork(networks[facing].networkId, facing);

                foreach (BlockFacing nullnetworkfacing in nullnetworks)
                {
                    getNeighbourDevice(nullnetworkfacing, true).propagateNetworkToNeighbours(
                        MechNetworkManagerRegistry.ManagersByWorld[api.World].getUniquePropagationId(),
                        networkId,
                        nullnetworkfacing
                        );
                }
            }

            if (networks.Count > 1 && api.World is IClientWorldAccessor)
            {
                float             maxSpeedDifference = 0;
                MechanicalNetwork dominantNetwork    = null;

                foreach (MechanicalNetwork network in networks.Values)
                {
                    if (dominantNetwork == null)
                    {
                        dominantNetwork = network;
                        continue;
                    }

                    maxSpeedDifference = Math.Max(maxSpeedDifference, Math.Abs(network.getSpeed() - dominantNetwork.getSpeed()));

                    if (Math.Abs(network.getSpeed()) > Math.Abs(dominantNetwork.getSpeed()))
                    {
                        dominantNetwork = network;
                    }
                }

                // Here we could disallow connecting of networks if
                // maxSpeedDifference is larger than 1
                // e.g. immediately break the placed block again because it cannot handle
                // the large torque difference. But implementation will be somewhat complicated
                foreach (MechanicalNetwork network in networks.Values)
                {
                    if (network != dominantNetwork)
                    {
                        network.isDead = true;
                        MechNetworkManagerRegistry.ManagersByWorld[api.World].discardNetwork(network);
                    }
                }
                dominantNetwork.rebuildNetwork();

                api.World.BlockAccessor.MarkBlockEntityDirty(pos);
            }
        }