frankkarsten

Should we play one fewer land under the new mull rule?

Sep 2nd, 2015
911
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package newmullruleonefewerland;
  2.  
  3. import java.util.Arrays.*;
  4. import java.util.Random;
  5.  
  6. public class NewMullRuleOneFewerLand {
  7.  
  8.     public static void main(String[] args) {
  9.        
  10.         Deck deck=new Deck();
  11.         double KillTurn;
  12.         boolean NewMullRuleActive;
  13.         System.out.println("---New mull rule active---");
  14.         NewMullRuleActive = true;
  15.        
  16.         for (int OneDrops=13; OneDrops<=17; OneDrops++){
  17.             for (int TwoDrops=9; TwoDrops<=13; TwoDrops++){
  18.                 for (int ThreeDrops=0; ThreeDrops<=2; ThreeDrops++){
  19.                     for (int Bolts=12; Bolts<=16; Bolts++){
  20.                        
  21.                     int NumberLands=60-OneDrops-TwoDrops-ThreeDrops-Bolts;    
  22.                     deck.SetDeck(OneDrops,TwoDrops,ThreeDrops,Bolts,NumberLands);
  23.  
  24.                     if (Math.abs(OneDrops-15)+Math.abs(TwoDrops-11)+Math.abs(ThreeDrops-0)+Math.abs(Bolts-14)+Math.abs(NumberLands-20)<=4){
  25.                         //analyze if deck is at most 2 cards different from original optimal deck
  26.                         boolean[][][][][][] ScryToBottom=GiveOptimalScryStrategy(deck);
  27.                         boolean[][][][][][] KeepOpeningHand=GiveOptimalMulliganStrategy(deck,ScryToBottom,NewMullRuleActive);
  28.                         KillTurn=AverageKillTurnForRandomHand(deck,7,KeepOpeningHand,ScryToBottom,NewMullRuleActive,false,20000000);
  29.                         System.out.print("Kill turn for new mull rule:"+KillTurn+". ");
  30.                         deck.PrintDeckBrief();
  31.                         System.out.println();
  32.                     }
  33.  
  34.         }}}} //end of all the for-loops
  35.        
  36.     }//end of main
  37.  
  38.     public static boolean[][][][][][] GiveOptimalScryStrategy(Deck deck) {
  39.         boolean[][][][][][] ScryToBottom = new boolean[8][8][8][8][8][8];
  40.         OpeningHand openinghand=new OpeningHand();
  41.         int OriginalNr1Cost=deck.NumberOf1Cost;
  42.         int OriginalNr2Cost=deck.NumberOf2Cost;
  43.         int OriginalNr3Cost=deck.NumberOf3Cost;
  44.         int OriginalNrBolts=deck.NumberOfBolts;
  45.         int OriginalNrLands=deck.NumberOfLands;
  46.         boolean NewMullRuleActive = true;
  47.         for (int StartingCards=1; StartingCards<=7; StartingCards++){
  48.             System.out.print(".");
  49.             for (int OneDropCount=0; OneDropCount<=OriginalNr1Cost && OneDropCount<=StartingCards; OneDropCount++){
  50.                 for (int TwoDropCount=0; TwoDropCount<=OriginalNr2Cost && TwoDropCount+OneDropCount<=StartingCards; TwoDropCount++){
  51.                     for  (int ThreeDropCount=0; ThreeDropCount<=OriginalNr3Cost && ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; ThreeDropCount++){
  52.                         for (int BoltCount=0; BoltCount<=OriginalNrBolts && BoltCount+ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; BoltCount++){
  53.                             int LandCount=StartingCards-OneDropCount-TwoDropCount-ThreeDropCount-BoltCount;
  54.                             if (LandCount<=OriginalNrLands){
  55.                                 for (int CardType=1; CardType<=5; CardType++){
  56.                                     boolean DoWeCheckThis=false;
  57.                                     if (CardType==1 && OneDropCount+1<=OriginalNr1Cost) {DoWeCheckThis=true;}
  58.                                     if (CardType==2 && TwoDropCount+1<=OriginalNr2Cost) {DoWeCheckThis=true;}
  59.                                     if (CardType==3 && ThreeDropCount+1<=OriginalNr3Cost) {DoWeCheckThis=true;}
  60.                                     if (CardType==4 && BoltCount+1<=OriginalNrBolts) {DoWeCheckThis=true;}
  61.                                     if (CardType==5 && LandCount+1<=OriginalNrLands) {DoWeCheckThis=true;}
  62.                                     if (DoWeCheckThis) {
  63.                                         openinghand.SetHand(OneDropCount, TwoDropCount, ThreeDropCount, BoltCount, LandCount);
  64.                                         deck.SetDeck(OriginalNr1Cost,OriginalNr2Cost,OriginalNr3Cost,OriginalNrBolts,OriginalNrLands);
  65.                                         ScryToBottom[OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount][CardType]=true;
  66.                                         double AvgKillTurnWithBottom=AverageKillTurnForSpecificHand(deck,openinghand, ScryToBottom, CardType, NewMullRuleActive);
  67.                                         //Checked how well scrying to botttom does
  68.                                         openinghand.SetHand(OneDropCount, TwoDropCount, ThreeDropCount, BoltCount, LandCount);
  69.                                         deck.SetDeck(OriginalNr1Cost,OriginalNr2Cost,OriginalNr3Cost,OriginalNrBolts,OriginalNrLands);
  70.                                         ScryToBottom[OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount][CardType]=false;
  71.                                         double AvgKillTurnWithTop=AverageKillTurnForSpecificHand(deck,openinghand, ScryToBottom, CardType, NewMullRuleActive);
  72.                                         //Checked how well scrying to top does
  73.                                         if (AvgKillTurnWithTop>AvgKillTurnWithBottom) {ScryToBottom[OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount][CardType]=true;}
  74.                                         if (AvgKillTurnWithTop<=AvgKillTurnWithBottom) {ScryToBottom[OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount][CardType]=false;}
  75.                                     }
  76.                                 }
  77.                             }
  78.                         }
  79.                     }
  80.                 }
  81.             }
  82.         }
  83.         return ScryToBottom;
  84.     }
  85.  
  86.     public static boolean[][][][][][] GiveOptimalMulliganStrategy(Deck deck, boolean[][][][][][] ScryToBottom, boolean NewMullRuleActive) {
  87.         boolean[][][][][][] KeepOpeningHand = new boolean[8][8][8][8][8][8];
  88.         OpeningHand openinghand=new OpeningHand();
  89.         int OriginalNr1Cost=deck.NumberOf1Cost;
  90.         int OriginalNr2Cost=deck.NumberOf2Cost;
  91.         int OriginalNr3Cost=deck.NumberOf3Cost;
  92.         int OriginalNrBolts=deck.NumberOfBolts;
  93.         int OriginalNrLands=deck.NumberOfLands;
  94.         double CutOffTurn = AverageKillTurnForRandomHand(deck,1,KeepOpeningHand,ScryToBottom,NewMullRuleActive,false,200000); //Switch to 1000000!!!!!!!!!!!!!!!!!!!!!!
  95.         for (int StartingCards=2; StartingCards<=7; StartingCards++){
  96.             System.out.print(".");
  97.             for (int OneDropCount=0; OneDropCount<=OriginalNr1Cost && OneDropCount<=StartingCards; OneDropCount++){
  98.                 for (int TwoDropCount=0; TwoDropCount<=OriginalNr2Cost && TwoDropCount+OneDropCount<=StartingCards; TwoDropCount++){
  99.                     for  (int ThreeDropCount=0; ThreeDropCount<=OriginalNr3Cost && ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; ThreeDropCount++){
  100.                         for (int BoltCount=0; BoltCount<=OriginalNrBolts && BoltCount+ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; BoltCount++){
  101.                             int LandCount=StartingCards-OneDropCount-TwoDropCount-ThreeDropCount-BoltCount;
  102.                             if (LandCount<=OriginalNrLands){
  103.                                 openinghand.SetHand(OneDropCount, TwoDropCount, ThreeDropCount, BoltCount, LandCount);
  104.                                 deck.SetDeck(OriginalNr1Cost,OriginalNr2Cost,OriginalNr3Cost,OriginalNrBolts,OriginalNrLands);
  105.                                 double AvgKillTurn=AverageKillTurnForSpecificHand(deck,openinghand, ScryToBottom,0,NewMullRuleActive);
  106.                                 if (AvgKillTurn<=CutOffTurn) { KeepOpeningHand[StartingCards][OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount]=true;}
  107.                                 if (AvgKillTurn>CutOffTurn) { KeepOpeningHand[StartingCards][OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount]=false;}
  108.                                 }
  109.                             }
  110.                         }
  111.                     }
  112.                 }
  113.             deck.SetDeck(OriginalNr1Cost,OriginalNr2Cost,OriginalNr3Cost,OriginalNrBolts,OriginalNrLands);
  114.             if (StartingCards<7) {CutOffTurn=AverageKillTurnForRandomHand(deck,StartingCards,KeepOpeningHand, ScryToBottom,NewMullRuleActive,false,1000000);}
  115.         }
  116.         return KeepOpeningHand;
  117.     }
  118.    
  119.     public static double AverageKillTurnForSpecificHand(Deck deck, OpeningHand openinghand, boolean[][][][][][] ScryToBottom, int CardOnTop, boolean NewMullRuleActive){
  120.         int NumberOfIterations=10000;
  121.         Deck remainingdeck=new Deck();
  122.         double AverageKillTurn=0;
  123.         for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
  124.             remainingdeck.SetDeck(deck.NumberOf1Cost-openinghand.NumberOf1Cost,deck.NumberOf2Cost-openinghand.NumberOf2Cost,deck.NumberOf3Cost-openinghand.NumberOf3Cost,deck.NumberOfBolts-openinghand.NumberOfBolts,deck.NumberOfLands-openinghand.NumberOfLands);
  125.             AverageKillTurn=AverageKillTurn+TurnKill(remainingdeck,openinghand,ScryToBottom,CardOnTop,NewMullRuleActive,false);
  126.         }
  127.         return (AverageKillTurn/(NumberOfIterations+0.0));
  128.     }//end of AverageKillTurnForSpecificHand
  129.  
  130.    
  131.     public static double AverageKillTurnForRandomHand(Deck deck, int StartingCards, boolean[][][][][][] KeepOpeningHand, boolean[][][][][][] ScryToBottom, boolean NewMullRuleActive, boolean NonInteractiveCheck, int NumberOfIterations){
  132.         Deck remainingdeck=new Deck();
  133.         double AverageKillTurn=0;
  134.         for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
  135.             OpeningHand openinghand=GiveOpeningHandAfterMulls(deck, StartingCards, KeepOpeningHand);
  136.             remainingdeck.SetDeck(deck.NumberOf1Cost-openinghand.NumberOf1Cost,deck.NumberOf2Cost-openinghand.NumberOf2Cost,deck.NumberOf3Cost-openinghand.NumberOf3Cost,deck.NumberOfBolts-openinghand.NumberOfBolts,deck.NumberOfLands-openinghand.NumberOfLands);
  137.             AverageKillTurn=AverageKillTurn+TurnKill(remainingdeck,openinghand,ScryToBottom,0,NewMullRuleActive,NonInteractiveCheck);
  138.         }
  139.         return AverageKillTurn/(NumberOfIterations+0.0);
  140.     }//end of AverageKillTurnForRandomHand
  141.    
  142.     static OpeningHand GiveOpeningHandAfterMulls (Deck deck, int StartingCards, boolean[][][][][][] KeepOpeningHand) {
  143.        
  144.         Deck remainingdeck=new Deck();
  145.         OpeningHand openinghand=new OpeningHand();
  146.         int TypeOfCardDrawn;
  147.         boolean KeepHand=false;
  148.        
  149.         for (int OpeningHandSize=7; OpeningHandSize>=1; OpeningHandSize--){
  150.             if (KeepHand==false && StartingCards>=OpeningHandSize){
  151.                 openinghand.ResetHand();
  152.                 remainingdeck.SetDeck(deck.NumberOf1Cost,deck.NumberOf2Cost,deck.NumberOf3Cost,deck.NumberOfBolts,deck.NumberOfLands);
  153.                 for (int CardsDrawn=0; CardsDrawn<OpeningHandSize; CardsDrawn++){
  154.                     TypeOfCardDrawn=remainingdeck.DrawCard();
  155.                     if (TypeOfCardDrawn==1) {openinghand.NumberOf1Cost++;}
  156.                     if (TypeOfCardDrawn==2) {openinghand.NumberOf2Cost++;}
  157.                     if (TypeOfCardDrawn==3) {openinghand.NumberOf3Cost++;}
  158.                     if (TypeOfCardDrawn==4) {openinghand.NumberOfBolts++;}
  159.                     if (TypeOfCardDrawn==5) {openinghand.NumberOfLands++;}
  160.                 }
  161.                 KeepHand=true;
  162.                 if (OpeningHandSize>1) {
  163.                     if (KeepOpeningHand[OpeningHandSize][openinghand.NumberOf1Cost][openinghand.NumberOf2Cost][openinghand.NumberOf3Cost][openinghand.NumberOfBolts][openinghand.NumberOfLands]==false) {KeepHand=false;}
  164.                 }
  165.             }
  166.         }
  167.        
  168.         return openinghand;
  169.     }//end of GiveOpeningHandAfterMulls
  170.    
  171.    
  172.     static int TurnKill(Deck remainingdeck, OpeningHand openinghand, boolean[][][][][][] ScryToBottom, int CardOnTop, boolean NewMullRuleActive, boolean NonInteractiveCheck) {
  173.        
  174.         int OneCostPower=2;
  175.         int TwoCostPower=4;
  176.         int ThreeCostPower=6;
  177.         int BoltDamage=3;
  178.        
  179.         int Turn=0;
  180.         int OppLife=20;
  181.         int ManaLeft;
  182.         int TypeOfCardDrawn;
  183.    
  184.         int OneDropsInPlay=0;
  185.         int TwoDropsInPlay=0;
  186.         int ThreeDropsInPlay=0;
  187.         int LandsInPlay=0;
  188.        
  189.         int OneDropsInHand=openinghand.NumberOf1Cost;
  190.         int TwoDropsInHand=openinghand.NumberOf2Cost;
  191.         int ThreeDropsInHand=openinghand.NumberOf3Cost;
  192.         int BoltsInHand=openinghand.NumberOfBolts;
  193.         int LandsInHand=openinghand.NumberOfLands;
  194.        
  195.         boolean CardOnTopFixed=false;
  196.         int TypeOfCardOnTop=0;
  197.        
  198.         if (openinghand.NumberOf1Cost+openinghand.NumberOf2Cost+openinghand.NumberOf3Cost+openinghand.NumberOfBolts+openinghand.NumberOfLands<7 && NewMullRuleActive) {
  199.             if (CardOnTop==0){
  200.                 TypeOfCardOnTop=remainingdeck.DrawCard();
  201.             }
  202.             if (CardOnTop>0){
  203.                 TypeOfCardOnTop=CardOnTop;
  204.                 if (CardOnTop==1){remainingdeck.NumberOf1Cost--;}
  205.                 if (CardOnTop==2){remainingdeck.NumberOf2Cost--;}
  206.                 if (CardOnTop==3){remainingdeck.NumberOf3Cost--;}
  207.                 if (CardOnTop==4){remainingdeck.NumberOfBolts--;}
  208.                 if (CardOnTop==5){remainingdeck.NumberOfLands--;}
  209.             }
  210.             if (ScryToBottom[OneDropsInHand][TwoDropsInHand][ThreeDropsInHand][BoltsInHand][LandsInHand][TypeOfCardOnTop]==true) {
  211.                 CardOnTopFixed=false;
  212.                 //The drawn card is set aside, we don't do anything with it, which can be interpreted as pushing it to the bottom
  213.             }
  214.             if (ScryToBottom[OneDropsInHand][TwoDropsInHand][ThreeDropsInHand][BoltsInHand][LandsInHand][TypeOfCardOnTop]==false) {
  215.                 CardOnTopFixed=true;
  216.                 //The drawn card is set aside to be drawn next turn instead of a random draw
  217.             }
  218.         }
  219.         do {
  220.            
  221.             Turn++;
  222.            
  223.             if (Turn==1) {
  224.                
  225.                 if (LandsInHand>=1) {LandsInPlay++; LandsInHand--;}
  226.                 ManaLeft=LandsInPlay;
  227.                 if (OneDropsInHand>=1 && ManaLeft==1) {OneDropsInPlay++; ManaLeft--; OneDropsInHand--;}
  228.                 if (BoltsInHand>=1 && ManaLeft==1) {OppLife=OppLife-BoltDamage; ManaLeft--; BoltsInHand--;}
  229.                
  230.             } //end of the first turn
  231.            
  232.             if (Turn>1) {
  233.  
  234.                 if (Turn==2 && CardOnTopFixed){
  235.                     TypeOfCardDrawn=TypeOfCardOnTop;
  236.                 }
  237.                 else {
  238.                     TypeOfCardDrawn=remainingdeck.DrawCard();
  239.                 }
  240.                 if (TypeOfCardDrawn==1) {OneDropsInHand++;}
  241.                 if (TypeOfCardDrawn==2) {TwoDropsInHand++;}
  242.                 if (TypeOfCardDrawn==3) {ThreeDropsInHand++;}
  243.                 if (TypeOfCardDrawn==4) {BoltsInHand++;}
  244.                 if (TypeOfCardDrawn==5) {LandsInHand++;}
  245.  
  246.                 if (LandsInHand>=1) {LandsInPlay++; LandsInHand--;}
  247.                 ManaLeft=LandsInPlay;
  248.                 OppLife=OppLife-OneCostPower*OneDropsInPlay;
  249.                 OppLife=OppLife-TwoCostPower*TwoDropsInPlay;
  250.                 OppLife=OppLife-ThreeCostPower*ThreeDropsInPlay;
  251.                
  252.                 if (ManaLeft==1) {
  253.                     int CastableBolts=Math.min(BoltsInHand, ManaLeft);
  254.                     if (OppLife<=CastableBolts*BoltDamage) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  255.                     if (OneDropsInHand>=1 && ManaLeft==1) {OneDropsInPlay++; ManaLeft--; OneDropsInHand--;}
  256.                     if (BoltsInHand>=1 && ManaLeft==1) {OppLife=OppLife-BoltDamage; ManaLeft--; BoltsInHand--;}
  257.                 }
  258.                
  259.                 if (ManaLeft==2) {
  260.                     int CastableBolts=Math.min(BoltsInHand, ManaLeft);
  261.                     if (OppLife<=CastableBolts*BoltDamage) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  262.                     if (TwoDropsInHand>=1 && ManaLeft==2) {TwoDropsInPlay++; ManaLeft=ManaLeft-2; TwoDropsInHand--;}
  263.                     int CastableOneDrops=Math.min(OneDropsInHand, ManaLeft);
  264.                     if (CastableOneDrops>=1) {OneDropsInPlay=OneDropsInPlay+CastableOneDrops; ManaLeft=ManaLeft-CastableOneDrops; OneDropsInHand=OneDropsInHand-CastableOneDrops;}
  265.                     CastableBolts=Math.min(BoltsInHand, ManaLeft);
  266.                     if (CastableBolts>=1) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  267.                 }
  268.  
  269.                 if (ManaLeft==3) {
  270.                     int CastableBolts=Math.min(BoltsInHand, ManaLeft);
  271.                     if (OppLife<=CastableBolts*BoltDamage) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  272.                     if (ThreeDropsInHand>=1 && ManaLeft==3) {ThreeDropsInPlay++; ManaLeft=ManaLeft-3; ThreeDropsInHand--;}
  273.                     if (TwoDropsInHand>=1 && ManaLeft>=2) {TwoDropsInPlay++; ManaLeft=ManaLeft-2; TwoDropsInHand--;}
  274.                     int CastableOneDrops=Math.min(OneDropsInHand, ManaLeft);
  275.                     if (CastableOneDrops>=1) {OneDropsInPlay=OneDropsInPlay+CastableOneDrops; ManaLeft=ManaLeft-CastableOneDrops; OneDropsInHand=OneDropsInHand-CastableOneDrops;}
  276.                     CastableBolts=Math.min(BoltsInHand, ManaLeft);
  277.                     if (CastableBolts>=1) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  278.                 }
  279.                
  280.                 if (ManaLeft==4) {
  281.                     int CastableBolts=Math.min(BoltsInHand, ManaLeft);
  282.                     if (OppLife<=CastableBolts*BoltDamage) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  283.                     int CastableTwoDrops=Math.min(TwoDropsInHand, ManaLeft/2);
  284.                     if (CastableTwoDrops==2) {TwoDropsInPlay=TwoDropsInPlay+2; ManaLeft=ManaLeft-4; TwoDropsInHand=TwoDropsInHand-2;}
  285.                     if (ThreeDropsInHand>=1 && ManaLeft>=3) {ThreeDropsInPlay++; ManaLeft=ManaLeft-3; ThreeDropsInHand--;}
  286.                     if (TwoDropsInHand>=1 && ManaLeft>=2) {TwoDropsInPlay++; ManaLeft=ManaLeft-2; TwoDropsInHand--;}
  287.                     int CastableOneDrops=Math.min(OneDropsInHand, ManaLeft);
  288.                     if (CastableOneDrops>=1) {OneDropsInPlay=OneDropsInPlay+CastableOneDrops; ManaLeft=ManaLeft-CastableOneDrops; OneDropsInHand=OneDropsInHand-CastableOneDrops;}
  289.                     CastableBolts=Math.min(BoltsInHand, ManaLeft);
  290.                     if (CastableBolts>=1) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  291.                 }
  292.                        
  293.                 if (ManaLeft>=5) {
  294.                     int CastableBolts=Math.min(BoltsInHand, ManaLeft);
  295.                     if (OppLife<=CastableBolts*BoltDamage) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  296.                     int CastableThreeDrops=Math.min(ThreeDropsInHand, ManaLeft/3);
  297.                     if (CastableThreeDrops>=1) {ThreeDropsInPlay=ThreeDropsInPlay+CastableThreeDrops; ManaLeft=ManaLeft-3*CastableThreeDrops; ThreeDropsInHand=ThreeDropsInHand-CastableThreeDrops;}
  298.                     int CastableTwoDrops=Math.min(TwoDropsInHand, ManaLeft/2);
  299.                     if (CastableTwoDrops>=1) {TwoDropsInPlay=TwoDropsInPlay+CastableTwoDrops; ManaLeft=ManaLeft-2*CastableTwoDrops; TwoDropsInHand=TwoDropsInHand-CastableTwoDrops;}
  300.                     int CastableOneDrops=Math.min(OneDropsInHand, ManaLeft);
  301.                     if (CastableOneDrops>=1) {OneDropsInPlay=OneDropsInPlay+CastableOneDrops; ManaLeft=ManaLeft-CastableOneDrops; OneDropsInHand=OneDropsInHand-CastableOneDrops;}
  302.                     CastableBolts=Math.min(BoltsInHand, ManaLeft);
  303.                     if (CastableBolts>=1) {OppLife=OppLife-CastableBolts*BoltDamage; ManaLeft=ManaLeft-CastableBolts; BoltsInHand=BoltsInHand-CastableBolts;}
  304.                 }
  305.                
  306.                
  307.                
  308.             } //end of a turn in which we drew a card and attacked
  309.  
  310.          
  311.         } while (OppLife>0 &&Turn<=50);
  312.         int Outcome=Turn;
  313.  
  314.         return Outcome;
  315.     }//end of TurnKill
  316.    
  317. /*
  318.     static int TurnKill(Deck remainingdeck, OpeningHand openinghand, boolean[][][][][][] ScryToBottom, int CardOnTop, boolean NewMullRuleActive, boolean NonInteractiveCheck) {
  319.        
  320.         int Turn=0;
  321.         int ManaLeft;
  322.         int TypeOfCardDrawn;
  323.    
  324.         boolean WeHaventWonYet=true;
  325.         boolean LandPlayed=false;
  326.         boolean PestermiteInPlay=false;
  327.         int LandsInPlay=0;
  328.        
  329.         int PestersInHand=openinghand.NumberOf1Cost;
  330.         int TwinsInHand=openinghand.NumberOf2Cost;
  331.         int LandsInHand=openinghand.NumberOfLands;
  332.        
  333.         boolean CardOnTopFixed=false;
  334.         int TypeOfCardOnTop=0;
  335.        
  336.         if (openinghand.NumberOf1Cost+openinghand.NumberOf2Cost+openinghand.NumberOf3Cost+openinghand.NumberOfBolts+openinghand.NumberOfLands<7 && NewMullRuleActive) {
  337.             if (CardOnTop==0){
  338.                 TypeOfCardOnTop=remainingdeck.DrawCard();
  339.             }
  340.             if (CardOnTop>0){
  341.                 TypeOfCardOnTop=CardOnTop;
  342.                 if (CardOnTop==1){remainingdeck.NumberOf1Cost--;}
  343.                 if (CardOnTop==2){remainingdeck.NumberOf2Cost--;}
  344.                 if (CardOnTop==3){remainingdeck.NumberOf3Cost--;}
  345.                 if (CardOnTop==4){remainingdeck.NumberOfBolts--;}
  346.                 if (CardOnTop==5){remainingdeck.NumberOfLands--;}
  347.             }
  348.             if (ScryToBottom[PestersInHand][TwinsInHand][0][0][LandsInHand][TypeOfCardOnTop]==true) {
  349.                 CardOnTopFixed=false;
  350.                 //The drawn card is set aside, we don't do anything with it, which can be interpreted as pushing it to the bottom
  351.             }
  352.             if (ScryToBottom[PestersInHand][TwinsInHand][0][0][LandsInHand][TypeOfCardOnTop]==false) {
  353.                 CardOnTopFixed=true;
  354.                 //The drawn card is set aside to be drawn next turn instead of a random draw
  355.             }
  356.         }
  357.         int Outcome=0;
  358.         do {
  359.            
  360.             Turn++;
  361.            
  362.             if (Turn>1){
  363.                
  364.                 if (Turn==2 && CardOnTopFixed){
  365.                     TypeOfCardDrawn=TypeOfCardOnTop;
  366.                 }
  367.                 else {
  368.                     TypeOfCardDrawn=remainingdeck.DrawCard();
  369.                 }
  370.                 if (TypeOfCardDrawn==1) {PestersInHand++;}
  371.                 if (TypeOfCardDrawn==2) {TwinsInHand++;}
  372.                 if (TypeOfCardDrawn==5) {LandsInHand++;}
  373.            
  374.             }
  375.            
  376.             LandPlayed=false;
  377.             if (LandsInHand>=1) {LandsInPlay++; LandsInHand--; LandPlayed=true;}
  378.             ManaLeft=LandsInPlay;
  379.             //System.out.println("Situation: ManaLeft="+ManaLeft+", LandsInPlay="+LandsInPlay+", PestermiteInPlay="+PestermiteInPlay+", HaventWonYet="+WeHaventWonYet+", Peeks in hand="+PeeksInHand+", Pesters in hand="+PestersInHand+", TwinsInHand="+TwinsInHand+", LandsInHand="+LandsInHand+". NOW START TURN "+Turn);
  380.  
  381.             if (PestermiteInPlay && TwinsInHand>=1 && ManaLeft>=4) {WeHaventWonYet=false; TwinsInHand--;}
  382.             if (!PestermiteInPlay && PestersInHand>=1 && ManaLeft>=3) {PestermiteInPlay=true; PestersInHand--;}
  383.                      
  384.         } while (WeHaventWonYet);
  385.        
  386.         Outcome=Turn;
  387.        
  388.         return Outcome;
  389.     }//end of TurnKill
  390.     */
  391.    
  392. }//end of OptimalAggroGoldfishDeck
  393.  
  394. class OpeningHand {
  395.     int NumberOf1Cost;
  396.     int NumberOf2Cost;
  397.     int NumberOf3Cost;
  398.     int NumberOfBolts;
  399.     int NumberOfLands;
  400.  
  401.     void ResetHand(){
  402.         NumberOf1Cost=0;
  403.         NumberOf2Cost=0;
  404.         NumberOf3Cost=0;
  405.         NumberOfBolts=0;
  406.         NumberOfLands=0;
  407.     }
  408.            
  409.     void SetHand (int Nr1Cost, int Nr2Cost, int Nr3Cost, int NrBolts, int NrLands) {
  410.         NumberOf1Cost=Nr1Cost;
  411.         NumberOf2Cost=Nr2Cost;
  412.         NumberOf3Cost=Nr3Cost;
  413.         NumberOfBolts=NrBolts;
  414.         NumberOfLands=NrLands;
  415.     }
  416.  
  417. }//end of OpeningHand
  418.  
  419. class Deck {
  420.     int NumberOf1Cost;
  421.     int NumberOf2Cost;
  422.     int NumberOf3Cost;
  423.     int NumberOfBolts;
  424.     int NumberOfLands;
  425.  
  426.     void PrintDeckBrief () {
  427.         if(NumberOf1Cost<10) {System.out.print("0");}
  428.         System.out.print(NumberOf1Cost+" ");
  429.         if(NumberOf2Cost<10) {System.out.print("0");}
  430.         System.out.print(NumberOf2Cost+" ");
  431.         if(NumberOf3Cost<10) {System.out.print("0");}
  432.         System.out.print(NumberOf3Cost+" ");
  433.         if(NumberOfBolts<10) {System.out.print("0");}
  434.         System.out.print(NumberOfBolts+" ");
  435.         if(NumberOfLands<10) {System.out.print("0");}
  436.         System.out.print(NumberOfLands);
  437.         System.out.print(" ");
  438.     }
  439.  
  440.     void SetDeck (int Nr1Cost, int Nr2Cost, int Nr3Cost, int NrBolts, int NrLands) {
  441.         NumberOf1Cost=Nr1Cost;
  442.         NumberOf2Cost=Nr2Cost;
  443.         NumberOf3Cost=Nr3Cost;
  444.         NumberOfBolts=NrBolts;
  445.         NumberOfLands=NrLands;
  446.     }
  447.    
  448.     int NrOfCards(){
  449.         return NumberOf1Cost+NumberOf2Cost+NumberOf3Cost+NumberOfBolts+NumberOfLands;
  450.     }
  451.    
  452.     int DrawCard (){
  453.             Random generator = new Random();
  454.             int RandomIntegerBetweenOneAndDeckSize=generator.nextInt( this.NrOfCards() )+1;
  455.             int CardType=0;
  456.             int OneCostCutoff=NumberOf1Cost;
  457.             int TwoCostCutoff=OneCostCutoff+NumberOf2Cost;
  458.             int ThreeCostCutoff=TwoCostCutoff+NumberOf3Cost;
  459.             int BoltCutoff=ThreeCostCutoff+NumberOfBolts;
  460.             int LandCutoff=BoltCutoff+NumberOfLands;
  461.            
  462.             if (RandomIntegerBetweenOneAndDeckSize<=OneCostCutoff) {CardType=1; this.NumberOf1Cost--;}
  463.             if (RandomIntegerBetweenOneAndDeckSize>OneCostCutoff && RandomIntegerBetweenOneAndDeckSize<=TwoCostCutoff) {CardType=2; this.NumberOf2Cost--;}
  464.             if (RandomIntegerBetweenOneAndDeckSize>TwoCostCutoff && RandomIntegerBetweenOneAndDeckSize<=ThreeCostCutoff) {CardType=3; this.NumberOf3Cost--;}
  465.             if (RandomIntegerBetweenOneAndDeckSize>ThreeCostCutoff && RandomIntegerBetweenOneAndDeckSize<=BoltCutoff) {CardType=4; this.NumberOfBolts--;}
  466.             if (RandomIntegerBetweenOneAndDeckSize>BoltCutoff && RandomIntegerBetweenOneAndDeckSize<=LandCutoff) {CardType=5; this.NumberOfLands--;}
  467.             return CardType;
  468.     }
  469.    
  470. }//end of Deck
RAW Paste Data