public static HashSet <IntrinsicElectronicData> SwitchCaseConnections(Vector2 searchVec,
                                                                          Matrix matrix,
                                                                          HashSet <PowerTypeCategory> CanConnectTo,
                                                                          Connection connectionPoint,
                                                                          IntrinsicElectronicData OIinheritance,
                                                                          HashSet <IntrinsicElectronicData> connections,
                                                                          // used in SurroundingTiles connection
                                                                          Connection otherConnectionPoint = Connection.NA)
    {
        var searchVecInt = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);

        {           // LogError Duplicate wires
            var eConnsAtSearchVec = matrix.GetElectricalConnections(searchVecInt);
            foreach (var con in eConnsAtSearchVec)
            {
                if (OIinheritance != con)
                {
                    if ((OIinheritance.WireEndA == con.WireEndA && OIinheritance.WireEndB == con.WireEndB) ||
                        (OIinheritance.WireEndA == con.WireEndB && OIinheritance.WireEndB == con.WireEndA))
                    {
                        Logger.LogErrorFormat("{0} < duplicate Please remove {1}",
                                              Category.Electrical,
                                              searchVecInt,
                                              OIinheritance);
                    }
                }
            }

            eConnsAtSearchVec.Clear();
            ElectricalPool.PooledFPCList.Add(eConnsAtSearchVec);
        }

        if (connectionPoint == Connection.SurroundingTiles)
        {
            foreach (var dir in NeighbourDirections)
            {
                // check all nearby connections except connection that is specified in other wire end
                if (dir.Key == otherConnectionPoint)
                {
                    continue;
                }

                var pos   = searchVecInt + dir.Value;
                var conns = matrix.GetElectricalConnections(pos);

                // get connections pointing towards our tile [ex. if neighbour is at north, get all south connections(SW, S, SE)]
                HashSet <Connection> possibleConnections = ConnectionMap.GetConnectionsTargeting(dir.Key);
                if (possibleConnections != null)
                {
                    foreach (var con in conns)
                    {
                        if (OIinheritance != con &&
                            CanConnectTo.Contains(con.Categorytype)
                            // check if possibleConnections contains our WireEnd A or B
                            && (possibleConnections.Contains(con.WireEndA) || possibleConnections.Contains(con.WireEndB))
                            // check if contains to avoid errors
                            && !connections.Contains(con))
                        {
                            connections.Add(con);
                        }
                    }
                }

                conns.Clear();
                ElectricalPool.PooledFPCList.Add(conns);
            }

            return(connections);
        }

        // Connect to machine connnectors
        if (connectionPoint == Connection.MachineConnect)
        {
            foreach (var dir in MachineConnectorDirections)
            {
                var pos   = searchVecInt + dir;
                var conns = matrix.GetElectricalConnections(pos);
                foreach (var con in conns)
                {
                    if (OIinheritance != con && CanConnectTo.Contains(con.Categorytype) &&
                        ConnectionMap.IsConnectedToTile(Connection.MachineConnect, con.GetConnPoints()) && !connections.Contains(con))
                    {
                        connections.Add(con);
                    }
                }

                conns.Clear();
                ElectricalPool.PooledFPCList.Add(conns);
            }
            return(connections);
        }

        // Make a vector representing the connection direction
        Vector3Int connVectorInt = ConnectionMap.GetDirectionFromConnection(connectionPoint);
        Vector3Int position      = searchVecInt + connVectorInt;

        // Connect wires
        {
            var  eConnsAtPosition = matrix.GetElectricalConnections(position);
            bool connectionsAdded = false;
            foreach (var con in eConnsAtPosition)
            {
                if (CanConnectTo.Contains(con.Categorytype) &&
                    ConnectionMap.IsConnectedToTile(connectionPoint, con.GetConnPoints()))
                {
                    connections.Add(con);
                    connectionsAdded = true;
                }
            }
            eConnsAtPosition.Clear();
            ElectricalPool.PooledFPCList.Add(eConnsAtPosition);

            if (connectionsAdded)
            {
                return(connections);
            }
        }

        // Connect to overlap
        {
            var eConnsAtSearchVec = matrix.GetElectricalConnections(searchVecInt);
            foreach (var con in eConnsAtSearchVec)
            {
                if (OIinheritance != con && CanConnectTo.Contains(con.Categorytype) &&
                    ConnectionMap.IsConnectedToTileOverlap(connectionPoint, con.GetConnPoints()))
                {
                    connections.Add(con);
                }
            }
            eConnsAtSearchVec.Clear();
            ElectricalPool.PooledFPCList.Add(eConnsAtSearchVec);
        }
        return(connections);
    }