How many Legends do you need for a Legendary sorcery?

package legendarysorcery;

import java.util.Arrays.*;
import java.util.Random;

public class LegendarySorcery{

    public static void main(String[] args) {

        Deck deck=new Deck();

        //CardType 1 is a land
        //CardType 2 is a legendary sorcery
        //CardType 3 is a legend
        //CardType 4 is not used
        //CardType 5 is another card


        for (int NrLegends=8; NrLegends<=26; NrLegends++){
            deck.SetDeck(25,4,NrLegends,0,60-29-NrLegends);
            double Probability=ProbabilityForRandomHand(deck,7,10000000);
            //System.out.print("Probability of having a legend in games where you have a legendary sorcery and enough lands on turn 6 after mulls in a deck with "+NrLegends+" legends: ");
            System.out.println(Math.round(Probability*10000)/100.0);
        }

    }//end of main

    public static double ProbabilityForRandomHand(Deck deck, int StartingCards, int NumberOfIterations){
        Deck remainingdeck=new Deck();
        double NumberOfGamesWithfavorableOutcome=0;
        double NumberOfGamesWithSorcery=0; //These are the games where you have a legendary sorcery in hand on turn 6 and at least five lands
        //On the play
        for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
            OpeningHand openinghand=GiveOpeningHandAfterMulls(deck, StartingCards);
            remainingdeck.SetDeck(deck.NumberOfLands-openinghand.NumberOfLands,deck.NumberOfCardType2-openinghand.NumberOfCardType2,deck.NumberOfCardType3-openinghand.NumberOfCardType3,deck.NumberOfCardType4-openinghand.NumberOfCardType4,deck.NumberOfSpells-openinghand.NumberOfSpells);

            int Outcome=SimulateGame(remainingdeck,openinghand,true);
            if (Outcome==0) {NumberOfGamesWithfavorableOutcome++; NumberOfGamesWithSorcery++;}
            if (Outcome==1) {NumberOfGamesWithSorcery++;}
        }
        //On the draw; this is a copy-paste where the only change is that the boolean is now false
        for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
            OpeningHand openinghand=GiveOpeningHandAfterMulls(deck, StartingCards);
            remainingdeck.SetDeck(deck.NumberOfLands-openinghand.NumberOfLands,deck.NumberOfCardType2-openinghand.NumberOfCardType2,deck.NumberOfCardType3-openinghand.NumberOfCardType3,deck.NumberOfCardType4-openinghand.NumberOfCardType4,deck.NumberOfSpells-openinghand.NumberOfSpells);
            int Outcome=SimulateGame(remainingdeck,openinghand,false);
            if (Outcome==0) {NumberOfGamesWithfavorableOutcome++; NumberOfGamesWithSorcery++;}
            if (Outcome==1) {NumberOfGamesWithSorcery++;}
        }

        return NumberOfGamesWithfavorableOutcome/(NumberOfGamesWithSorcery+0.0);
    }//end of AverageKillTurnForRandomHand

    static OpeningHand GiveOpeningHandAfterMulls (Deck deck, int StartingCards) {

        Deck remainingdeck=new Deck();
        OpeningHand openinghand=new OpeningHand();
        int TypeOfCardDrawn;
        boolean KeepHand=false;

        for (int OpeningHandSize=7; OpeningHandSize>=1; OpeningHandSize--){
            if (KeepHand==false){
                openinghand.SetHand(0,0,0,0,0);
                remainingdeck.SetDeck(deck.NumberOfLands,deck.NumberOfCardType2,deck.NumberOfCardType3,deck.NumberOfCardType4,deck.NumberOfSpells);
                int NumberOfLands=0;
                for (int CardsDrawn=0; CardsDrawn<OpeningHandSize; CardsDrawn++){
                    TypeOfCardDrawn=remainingdeck.DrawCard();
                    if (TypeOfCardDrawn==1) {openinghand.NumberOfLands++; NumberOfLands++;}
                    if (TypeOfCardDrawn==2) {openinghand.NumberOfCardType2++;}
                    if (TypeOfCardDrawn==3) {openinghand.NumberOfCardType3++;}
                    if (TypeOfCardDrawn==4) {openinghand.NumberOfCardType4++;}
                    if (TypeOfCardDrawn==5) {openinghand.NumberOfSpells++;}
                }
                KeepHand=true;
                if (OpeningHandSize>1) {
                    // We mulligan a hand if it contains 0, 1, 6, or 7 lands
                    if (NumberOfLands<=1 || NumberOfLands>=6) {KeepHand=false;}
                    //
                }
            }
        }

        return openinghand;
    }//end of GiveOpeningHandAfterMulls


    static int SimulateGame(Deck remainingdeck, OpeningHand openinghand, boolean OnThePlay) {

        //Initializing
        int TypeOfCardDrawn=0;
        int Outcome=2;
        int Turn;
        int NrOpposingRemovalSpells=2;

        int LandInHand=openinghand.NumberOfLands;
        int SorceryInHand=openinghand.NumberOfCardType2;
        int LegendInHand=openinghand.NumberOfCardType3;

        //Turn 1

        if (OnThePlay==false) {
                TypeOfCardDrawn=remainingdeck.DrawCard();
                if (TypeOfCardDrawn==1) {LandInHand++;}
                if (TypeOfCardDrawn==2) {SorceryInHand++;}
                if (TypeOfCardDrawn==3) {LegendInHand++;}
            }

        for (Turn=2; Turn<=5; Turn++){
            TypeOfCardDrawn=remainingdeck.DrawCard();
            if (TypeOfCardDrawn==1) {LandInHand++;}
            if (TypeOfCardDrawn==2) {SorceryInHand++;}
            if (TypeOfCardDrawn==3) {LegendInHand++;}
        }

        boolean WeHaveEnoughLegends=false;
        if (LegendInHand>NrOpposingRemovalSpells) {WeHaveEnoughLegends=true;}

        //Turn 6

        TypeOfCardDrawn=remainingdeck.DrawCard();
        if (TypeOfCardDrawn==1) {LandInHand++;}
        if (TypeOfCardDrawn==2) {SorceryInHand++;}

        boolean WeHaveEnoughLands=false;
        if (LandInHand>=5) {WeHaveEnoughLands=true;}

        boolean WeHoldTheSorcery=false;
        if (SorceryInHand>=1) {WeHoldTheSorcery=true;}

        if (WeHaveEnoughLands && WeHoldTheSorcery && WeHaveEnoughLegends) {Outcome=0;}
        if (WeHaveEnoughLands && WeHoldTheSorcery && !WeHaveEnoughLegends) {Outcome=1;}

        return Outcome;
    }//end of SimulateGame

}

class OpeningHand {
    int NumberOfLands;
    int NumberOfCardType2;
    int NumberOfCardType3;
    int NumberOfCardType4;
    int NumberOfSpells;

    int NrOfCards(){
        return NumberOfLands+NumberOfCardType2+NumberOfCardType3+NumberOfCardType4+NumberOfSpells;
    }

    void SetHand (int Nr1, int Nr2, int Nr3, int Nr4, int Nr5) {
        NumberOfLands=Nr1;
        NumberOfCardType2=Nr2;
        NumberOfCardType3=Nr3;
        NumberOfCardType4=Nr4;
        NumberOfSpells=Nr5;
    }

}//end of OpeningHand

class Deck {
    int NumberOfLands;
    int NumberOfCardType2;
    int NumberOfCardType3;
    int NumberOfCardType4;
    int NumberOfSpells;

    void SetDeck (int Nr1, int Nr2, int Nr3, int Nr4, int Nr5) {
        NumberOfLands=Nr1;
        NumberOfCardType2=Nr2;
        NumberOfCardType3=Nr3;
        NumberOfCardType4=Nr4;
        NumberOfSpells=Nr5;
    }

    int NrOfCards(){
        return NumberOfLands+NumberOfCardType2+NumberOfCardType3+NumberOfCardType4+NumberOfSpells;
    }

    int DrawCard (){
        Random generator = new Random();
        int CardType=0;
        int RandomIntegerBetweenOneAndDeckSize=generator.nextInt( this.NrOfCards() )+1;
        int OneCutoff=NumberOfLands;
        int TwoCutoff=OneCutoff+NumberOfCardType2;
        int ThreeCutoff=TwoCutoff+NumberOfCardType3;
        int FourCutoff=ThreeCutoff+NumberOfCardType4;
        int FiveCutoff=FourCutoff+NumberOfSpells;

        if (RandomIntegerBetweenOneAndDeckSize<=OneCutoff) {CardType=1; this.NumberOfLands--;}
        if (RandomIntegerBetweenOneAndDeckSize>OneCutoff && RandomIntegerBetweenOneAndDeckSize<=TwoCutoff) {CardType=2; this.NumberOfCardType2--;}
        if (RandomIntegerBetweenOneAndDeckSize>TwoCutoff && RandomIntegerBetweenOneAndDeckSize<=ThreeCutoff) {CardType=3; this.NumberOfCardType3--;}
        if (RandomIntegerBetweenOneAndDeckSize>ThreeCutoff && RandomIntegerBetweenOneAndDeckSize<=FourCutoff) {CardType=4; this.NumberOfCardType4--;}
        if (RandomIntegerBetweenOneAndDeckSize>FourCutoff && RandomIntegerBetweenOneAndDeckSize<=FiveCutoff) {CardType=5; this.NumberOfSpells--;}
        return CardType;
    }

}//end of Deck