private void removeLastConnection(SolarDiagnosticPiece piece)
    {
        if (useConnectingObjects)
        {
            // destroy connecting object
            GameObject lastConnectingObject = visibleConnectingObjects[visibleConnectingObjects.Count - 1];
            visibleConnectingObjects.Remove(lastConnectingObject);
            Destroy(lastConnectingObject);
        }

        // turn off piece
        lastPiece.activated = false;

        SolarDiagnosticPiece tempPiece = lastPiece;

        // set new piece order
        lastPiece = lastPiece.PreviousPiece;
        tempPiece.PreviousPiece = null;

        connections.Remove(tempPiece);

        if (useDebugLogs)
        {
            Debug.Log(piece.name + ": piece deleted");
        }
    }
    private void RemoveConnectionsFromHereTillEnd(int startRemove)
    {
        if (useDebugLogs)
        {
            Debug.Log("Start remove : " + startRemove);
        }

        SolarDiagnosticPiece[] connectionsCopy = new SolarDiagnosticPiece[connections.Count];
        connections.CopyTo(connectionsCopy);
        int startIndex = (connectionsCopy.Length - 1);

        if (startIndex < 0)
        {
            return;
        }

        for (int i = startIndex; i >= startRemove; i--)
        {
            SolarDiagnosticPiece piece = connections[i];

            if (useDebugLogs)
            {
                Debug.Log("Remove piece:" + piece.name + " at i " + i + " length: " + connectionsCopy.Length);
            }

            if (!piece.isSource)
            {
                piece.activated = false;
            }

            connections.Remove(piece);
        }

        if (useConnectingObjects)
        {
            foreach (GameObject connectingObject in visibleConnectingObjects)
            {
                Destroy(connectingObject);
            }

            visibleConnectingObjects.Clear();
        }

        if (!dontUseDiagnosticBar)
        {
            diagnosticBar.ShowBars(connections.Count);
        }
    }
    // Returns true if you can continue the line
    public bool StartLineFromPieceTap(SolarDiagnosticPiece piece)
    {
        if (piece.isSource)
        {
            originalPiece = piece;
            lastPiece     = piece;

            // Clear previous line
            RemoveConnectionsFromHereTillEnd(0);

            if (!dontUseLastPieceHalo)
            {
                lastPieceHalo.transform.position = piece.transform.position;
            }

            if (connections.Count < 1)
            {
                // If you tap on a source piece multiple times, don't add it
                // Also if you toggle between the two source pieces, don't add it.
                connections.Add(piece);
            }

            return(true);
        }
        else
        {
            if (connections != null)
            {
                if (connections[connections.Count - 1].Equals(piece))
                {
                    if (useDebugLogs)
                    {
                        Debug.Log("Continue the line");
                    }
                    originalPiece = piece;
                    lastPiece     = piece;

                    return(true);
                }
            }
        }
        return(false);
    }
    void AddPieceToSelectedPieceConnection(SolarDiagnosticPiece piece)
    {
        if (useSound)
        {
            Helper.PlayAudioIfSoundOn(pieceAddedSound);
        }

        if (useConnectingObjects)
        {
            Vector3    connectionPosition      = (piece.transform.position + lastPiece.transform.position) / 2;
            GameObject currentConnectingObject = Instantiate(connectingObject, connectionPosition, new Quaternion(0, 0, 0, 0), piece.transform);

            visibleConnectingObjects.Add(currentConnectingObject);


            if (piece.row == lastPiece.row)
            {
                currentConnectingObject.transform.eulerAngles = new Vector3(0, 0, 90);
            }
            else if (piece.column == lastPiece.column)
            {
                currentConnectingObject.transform.eulerAngles = new Vector3(0, 0, 0);
            }
        }

        piece.activated = true;

        connections.Add(piece);

        if (!dontUseDiagnosticBar)
        {
            diagnosticBar.ShowBars(connections.Count);
        }

        piece.PreviousPiece = lastPiece;
        lastPiece           = piece;

        if (!dontUseLastPieceHalo)
        {
            lastPieceHalo.transform.position = lastPiece.transform.position;
        }
    }
 public override void ResetPuzzle()
 {
     lastPiece = null;
     RemoveConnectionsFromHereTillEnd(0);
     base.ResetPuzzle();
 }
    public void SiblingCollided(SolarDiagnosticPiece piece)
    {
        if (lastPiece.neighbors.Contains(piece))
        {
            if (piece.isSource)
            {
                //  if (piece == originalPiece)
                if (piece == lastPiece.PreviousPiece)
                {
                    // End touch if you hit yourself
                    //originalPiece.EndTouch();

                    lastPiece.EndTouch();
                    if (allowDrawingBackwards)
                    {
                        removeLastConnection(lastPiece);
                    }
                }
                else
                {
                    // You have hit the other source
                    AddPieceToSelectedPieceConnection(piece);
                    CheckIfWin();
                }
            }
            else
            {
                if (piece.isObstacle)
                {
                    if (useDebugLogs)
                    {
                        Debug.Log("Obstacle at: " + piece.name);
                    }
                    if (useObstacleKey)
                    {
                        Helper.LocalizeKeyToTopBar(obstacleTxtKey);
                    }
                    piece.activated = true; // Activate the obstacle
                }
                else
                {
                    if (!piece.activated)
                    {
                        AddPieceToSelectedPieceConnection(piece);
                        if (useDebugLogs)
                        {
                            DebugLogConnections();
                        }
                    }
                    else
                    {
                        // remove piece if getting backwards
                        if (piece == lastPiece.PreviousPiece && allowDrawingBackwards)
                        {
                            removeLastConnection(piece);
                        }
                        else if (useDebugLogs)
                        {
                            Debug.Log("Piece already activated");
                        }
                    }
                }
            }

            CheckIfWin();
        }
    }