Likelihood that check-lands will enter untapped

package checklands;

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

public class CheckLands {

    public static void main(String[] args) {

        Deck deck=new Deck();

        //CardType 1 is a proper-type land
        //CardType 2 is a check-land
        //CardType 3 is another land (e.g., creature-land or pain-land)
        //CardType 4 is a non-land card
        //CardType 5 is not used

        for (int basics=1; basics<=20; basics++){

            deck.SetDeck(basics,4,21-basics,35,0);
            double Probability;

            System.out.println("=================================================");
            System.out.println("We now consider a deck with "+basics+" proper-type lands");
            System.out.println("=================================================");

            //The first output line give the percentage probability that a check-land would enter the battlefield untapped on turn 1.
            //The second output line gives the percentage probability that a check-land would enter the battlefield untapped on turn 2.
            //Etc.

            for (int Turn=1; Turn<=7; Turn++){
                Probability=ProbabilityForRandomHand(deck,7,10000000,Turn);
                //System.out.println("Probability that, if you have a check-land in hand on turn "+Turn+" and decide to play it, it will enter untapped: "+ Math.round(Probability*10000)/100.0);
                System.out.println(Math.round(Probability*10000)/100.0);
            }
            System.out.println();

        }

    }//end of main

    public static double ProbabilityForRandomHand(Deck deck, int StartingCards, int NumberOfIterations, int ProbabilityType){
        Deck remainingdeck=new Deck();
        int NumberOfGamesWherePlayingCheckLandIsPossibleOnTurn=0;
        int NumberOfGamesWithUNTAPPEDCheckLandOnTurn=0;
        for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
            OpeningHand openinghand=GiveOpeningHandAfterMulls(deck, StartingCards);
            remainingdeck.SetDeck(deck.NumberOfBasicLands-openinghand.NumberOfBasicLands,deck.NumberOfCheckLands-openinghand.NumberOfCheckLands,deck.NumberOfOtherLands-openinghand.NumberOfOtherLands,deck.NumberOfNonLandCards-openinghand.NumberOfNonLandCards,deck.NotUsed-openinghand.NotUsed);
            int outcome_of_one_game=SimulateGame(remainingdeck,openinghand,ProbabilityType);
            if (outcome_of_one_game==1) {NumberOfGamesWherePlayingCheckLandIsPossibleOnTurn++; NumberOfGamesWithUNTAPPEDCheckLandOnTurn++;}
            if (outcome_of_one_game==2) {NumberOfGamesWherePlayingCheckLandIsPossibleOnTurn++;}
        }
        return NumberOfGamesWithUNTAPPEDCheckLandOnTurn/(NumberOfGamesWherePlayingCheckLandIsPossibleOnTurn+0.0);
    }

    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.NumberOfBasicLands,deck.NumberOfCheckLands,deck.NumberOfOtherLands,deck.NumberOfNonLandCards,deck.NotUsed);
                int NumberOfLands=0;
                for (int CardsDrawn=0; CardsDrawn<OpeningHandSize; CardsDrawn++){
                    TypeOfCardDrawn=remainingdeck.DrawCard();
                    if (TypeOfCardDrawn==1) {openinghand.NumberOfBasicLands++; NumberOfLands++;}
                    if (TypeOfCardDrawn==2) {openinghand.NumberOfCheckLands++; NumberOfLands++;}
                    if (TypeOfCardDrawn==3) {openinghand.NumberOfOtherLands++; NumberOfLands++;}
                    if (TypeOfCardDrawn==4) {openinghand.NumberOfNonLandCards++;}
                    if (TypeOfCardDrawn==5) {openinghand.NotUsed++;}
                }
                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, int ProbabilityType) {

        int TypeOfCardDrawn;
        int Outcome=3;

        int CheckLandsInHand=openinghand.NumberOfCheckLands;
        int BasicLandsInHand=openinghand.NumberOfBasicLands;
        int OtherLandsInHand=openinghand.NumberOfOtherLands;
        boolean BasicInPlay=false;

        for (int Turn=1; Turn<=7; Turn++){

            if (Turn>1) {
                TypeOfCardDrawn=remainingdeck.DrawCard();
                if (TypeOfCardDrawn==1) {BasicLandsInHand++;}
                if (TypeOfCardDrawn==2) {CheckLandsInHand++;}
                if (TypeOfCardDrawn==3) {OtherLandsInHand++;}
            }
            boolean LandPlayed=false;

            if (Turn==ProbabilityType){
                if (CheckLandsInHand==0) {Outcome=3;}
                if (CheckLandsInHand>=1) {
                    CheckLandsInHand--;
                    LandPlayed=true;
                    if (BasicInPlay) {Outcome=1;}
                    if (!BasicInPlay) {Outcome=2;}
                }
            }

            //1. If we can play a basic-type land, we do so.
            if (LandPlayed==false && BasicLandsInHand>=1) {
                BasicLandsInHand--;
                LandPlayed=true;
                BasicInPlay=true;
            }

            //2. Otherwise, if we can play an other land, we do so.
            if (LandPlayed==false && OtherLandsInHand>=1) {
                OtherLandsInHand--;
                LandPlayed=true;
            }

            //3.  Otherwise, if we can play a check-land, we do so.
            if (LandPlayed==false && CheckLandsInHand>=1) {
                CheckLandsInHand--;
                LandPlayed=true;
            }

        }//end of the for-loop over the turns

        return Outcome;

    }//end of SimulateGame


}

class OpeningHand {
    int NumberOfBasicLands;
    int NumberOfCheckLands;
    int NumberOfOtherLands;
    int NumberOfNonLandCards;
    int NotUsed;

    int NrOfCards(){
        return NumberOfBasicLands+NumberOfCheckLands+NumberOfOtherLands+NumberOfNonLandCards+NotUsed;
    }

    void SetHand (int Nr1, int Nr2, int Nr3, int Nr4, int Nr5) {
        NumberOfBasicLands=Nr1;
        NumberOfCheckLands=Nr2;
        NumberOfOtherLands=Nr3;
        NumberOfNonLandCards=Nr4;
        NotUsed=Nr5;
    }

}//end of OpeningHand

class Deck {
    int NumberOfBasicLands;
    int NumberOfCheckLands;
    int NumberOfOtherLands;
    int NumberOfNonLandCards;
    int NotUsed;

    void SetDeck (int Nr1, int Nr2, int Nr3, int Nr4, int Nr5) {
        NumberOfBasicLands=Nr1;
        NumberOfCheckLands=Nr2;
        NumberOfOtherLands=Nr3;
        NumberOfNonLandCards=Nr4;
        NotUsed=Nr5;
    }

    int NrOfCards(){
        return NumberOfBasicLands+NumberOfCheckLands+NumberOfOtherLands+NumberOfNonLandCards+NotUsed;
    }

    int DrawCard (){
        Random generator = new Random();
        int CardType=0;
        int RandomIntegerBetweenOneAndDeckSize=generator.nextInt( this.NrOfCards() )+1;
        int OneCutoff=NumberOfBasicLands;
        int TwoCutoff=OneCutoff+NumberOfCheckLands;
        int ThreeCutoff=TwoCutoff+NumberOfOtherLands;
        int FourCutoff=ThreeCutoff+NumberOfNonLandCards;
        int FiveCutoff=FourCutoff+NotUsed;

        if (RandomIntegerBetweenOneAndDeckSize<=OneCutoff) {CardType=1; this.NumberOfBasicLands--;}
        if (RandomIntegerBetweenOneAndDeckSize>OneCutoff && RandomIntegerBetweenOneAndDeckSize<=TwoCutoff) {CardType=2; this.NumberOfCheckLands--;}
        if (RandomIntegerBetweenOneAndDeckSize>TwoCutoff && RandomIntegerBetweenOneAndDeckSize<=ThreeCutoff) {CardType=3; this.NumberOfOtherLands--;}
        if (RandomIntegerBetweenOneAndDeckSize>ThreeCutoff && RandomIntegerBetweenOneAndDeckSize<=FourCutoff) {CardType=4; this.NumberOfNonLandCards--;}
        if (RandomIntegerBetweenOneAndDeckSize>FourCutoff && RandomIntegerBetweenOneAndDeckSize<=FiveCutoff) {CardType=5; this.NotUsed--;}
        return CardType;
    }

}//end of Deck