frankkarsten

MTG Optimal Deck for Hexplate Golem format

Sep 23rd, 2013
461
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package hexplategolemformat;
  2.  
  3. import java.util.Arrays.*;
  4. import java.util.Random;
  5.  
  6. public class HexplateGolemFormat {
  7.  
  8.     public static void main(String[] args) {
  9.        
  10.         //Note: 1-drop means Fierce Empath!!!
  11.         //Note: 2-drop means Hexplate Golem!!!
  12.         //Note: Bolt means Kessig Wolf Run!!!
  13.         //Note: land means Gruul Turf!!!
  14.  
  15.         Deck deck=new Deck();
  16.         boolean[][][][][][] KeepOpeningHand = new boolean[8][8][8][8][8][8];
  17.         boolean TakeTimeToFindOptimalMulliganStrategy = false;
  18.         if (TakeTimeToFindOptimalMulliganStrategy==false) {KeepOpeningHand=GiveLooseMulliganStrategy();}
  19.         int NumberOfSimulationsPerDeck=2000;
  20.         double FastestTurn=50;
  21.         double KillTurn;
  22.         int OptimalOneDrops=0;
  23.         int OptimalTwoDrops=0;
  24.         int OptimalThreeDrops=0;
  25.         int OptimalBolts=0;
  26.         int OptimalLands=0;
  27.  
  28.         for (int TripleOneDropCount=0; TripleOneDropCount<=10; TripleOneDropCount++){
  29.             for (int TripleTwoDropCount=0; TripleTwoDropCount<=3; TripleTwoDropCount++){
  30.                 for (int TripleThreeDropCount=0; TripleThreeDropCount<=0; TripleThreeDropCount++){
  31.                     for (int TripleBoltCount=0; TripleBoltCount<=10; TripleBoltCount++){
  32.                         int TripleLandCount=20-TripleOneDropCount-TripleTwoDropCount-TripleThreeDropCount-TripleBoltCount;
  33.                         if (TripleLandCount>=0 && TripleLandCount<=10) {
  34.                             deck.SetDeck(3*TripleOneDropCount,3*TripleTwoDropCount,3*TripleThreeDropCount,3*TripleBoltCount,3*TripleLandCount);
  35.                             deck.PrintDeckBrief();
  36.                             KillTurn=AverageKillTurnForRandomHand(deck,7,KeepOpeningHand,NumberOfSimulationsPerDeck);
  37.                             System.out.println(" "+KillTurn);
  38.                             if (KillTurn<FastestTurn){
  39.                                 FastestTurn=KillTurn;
  40.                                 OptimalOneDrops=3*TripleOneDropCount;
  41.                                 OptimalTwoDrops=3*TripleTwoDropCount;
  42.                                 OptimalThreeDrops=3*TripleThreeDropCount;
  43.                                 OptimalBolts=3*TripleBoltCount;
  44.                                 OptimalLands=3*TripleLandCount;
  45.                             }
  46.                         }
  47.                     }
  48.                 }
  49.             }
  50.         }
  51.        
  52.         System.out.println("----------------");
  53.         System.out.print("The optimal deck after the grid-enumeration at a small number of simulations per deck was:");
  54.         deck.SetDeck(OptimalOneDrops,OptimalTwoDrops,OptimalThreeDrops,OptimalBolts,OptimalLands);
  55.         deck.PrintDeckBrief();
  56.         System.out.println();
  57.         System.out.println("----------------");
  58.        
  59.         NumberOfSimulationsPerDeck=10000;
  60.         int NewOptimalOneDrops=0;
  61.         int NewOptimalTwoDrops=0;
  62.         int NewOptimalThreeDrops=0;
  63.         int NewOptimalBolts=0;
  64.         int NewOptimalLands=0;
  65.         boolean ContinueLocalSearch=true;
  66.        
  67.         do {
  68.             FastestTurn=50;
  69.             for (int OneDropCount=Math.max(0,OptimalOneDrops-3); OneDropCount<=Math.min(60,OptimalOneDrops+3); OneDropCount++){
  70.                 for (int TwoDropCount=Math.max(0,OptimalTwoDrops-3); TwoDropCount<=Math.min(60,OptimalTwoDrops+3); TwoDropCount++){
  71.                     for (int ThreeDropCount=0; ThreeDropCount<=0; ThreeDropCount++){
  72.                         for (int BoltCount=Math.max(0,OptimalBolts-3); BoltCount<=Math.min(60,OptimalBolts+3); BoltCount++){
  73.                            int LandCount=60-OneDropCount-TwoDropCount-ThreeDropCount-BoltCount;
  74.                            if (LandCount>=Math.max(0,OptimalLands-3) && LandCount<=Math.min(60,OptimalLands+3)) {
  75.                                 deck.SetDeck(OneDropCount,TwoDropCount,ThreeDropCount,BoltCount,LandCount);
  76.                                 deck.PrintDeckBrief();
  77.                                 KillTurn=AverageKillTurnForRandomHand(deck,7,KeepOpeningHand,NumberOfSimulationsPerDeck);
  78.                                 System.out.println(" "+KillTurn);
  79.                                 if (KillTurn<FastestTurn){
  80.                                     FastestTurn=KillTurn;
  81.                                     NewOptimalOneDrops=OneDropCount;
  82.                                     NewOptimalTwoDrops=TwoDropCount;
  83.                                     NewOptimalThreeDrops=ThreeDropCount;
  84.                                     NewOptimalBolts=BoltCount;
  85.                                     NewOptimalLands=LandCount;
  86.                                 }
  87.                             }
  88.                         }
  89.                     }
  90.                 }
  91.             }
  92.             if (Math.abs(NewOptimalOneDrops-OptimalOneDrops)+Math.abs(NewOptimalTwoDrops-OptimalTwoDrops)+Math.abs(NewOptimalThreeDrops-OptimalThreeDrops)+Math.abs(NewOptimalBolts-OptimalBolts)+Math.abs(NewOptimalLands-OptimalLands)<=2) {ContinueLocalSearch=false;}
  93.             OptimalOneDrops=NewOptimalOneDrops;
  94.             OptimalTwoDrops=NewOptimalTwoDrops;
  95.             OptimalThreeDrops=NewOptimalThreeDrops;
  96.             OptimalBolts=NewOptimalBolts;
  97.             OptimalLands=NewOptimalLands;
  98.             System.out.println("----------------");
  99.             System.out.print("The optimal deck after the local search was:");
  100.             deck.SetDeck(OptimalOneDrops,OptimalTwoDrops,OptimalThreeDrops,OptimalBolts,OptimalLands);
  101.             deck.PrintDeckBrief();
  102.             System.out.println();
  103.             System.out.println("----------------");
  104.         } while (ContinueLocalSearch);
  105.        
  106.         TakeTimeToFindOptimalMulliganStrategy=true;
  107.         NumberOfSimulationsPerDeck=50000;
  108.         FastestTurn=50;
  109.         ContinueLocalSearch=true;
  110.        
  111.         do {
  112.             for (int OneDropCount=Math.max(0,OptimalOneDrops-2); OneDropCount<=Math.min(60,OptimalOneDrops+2); OneDropCount++){
  113.                 for (int TwoDropCount=Math.max(0,OptimalTwoDrops-2); TwoDropCount<=Math.min(60,OptimalTwoDrops+2); TwoDropCount++){
  114.                     for (int ThreeDropCount=0; ThreeDropCount<=0; ThreeDropCount++){
  115.                         for (int BoltCount=Math.max(0,OptimalBolts-2); BoltCount<=Math.min(60,OptimalBolts+2); BoltCount++){
  116.                             int LandCount=60-OneDropCount-TwoDropCount-ThreeDropCount-BoltCount;
  117.                             if (LandCount>=Math.max(0,OptimalLands-2) && LandCount<=Math.min(60,OptimalLands+2)) {
  118.                                 deck.SetDeck(OneDropCount,TwoDropCount,ThreeDropCount,BoltCount,LandCount);
  119.                                 deck.PrintDeckBrief();
  120.                                 if (TakeTimeToFindOptimalMulliganStrategy==true) {KeepOpeningHand=GiveOptimalMulliganStrategy(deck);}
  121.                                 KillTurn=AverageKillTurnForRandomHand(deck,7,KeepOpeningHand,NumberOfSimulationsPerDeck);
  122.                                 System.out.println(" "+KillTurn);
  123.                                 if (KillTurn<FastestTurn){
  124.                                     FastestTurn=KillTurn;
  125.                                     NewOptimalOneDrops=OneDropCount;
  126.                                     NewOptimalTwoDrops=TwoDropCount;
  127.                                     NewOptimalThreeDrops=ThreeDropCount;
  128.                                     NewOptimalBolts=BoltCount;
  129.                                     NewOptimalLands=LandCount;
  130.                                 }
  131.                             }
  132.                         }
  133.                     }
  134.                 }
  135.             }
  136.             if (Math.abs(NewOptimalOneDrops-OptimalOneDrops)+Math.abs(NewOptimalTwoDrops-OptimalTwoDrops)+Math.abs(NewOptimalThreeDrops-OptimalThreeDrops)+Math.abs(NewOptimalBolts-OptimalBolts)+Math.abs(NewOptimalLands-OptimalLands)==0) {ContinueLocalSearch=false;}
  137.             OptimalOneDrops=NewOptimalOneDrops;
  138.             OptimalTwoDrops=NewOptimalTwoDrops;
  139.             OptimalThreeDrops=NewOptimalThreeDrops;
  140.             OptimalBolts=NewOptimalBolts;
  141.             OptimalLands=NewOptimalLands;
  142.             System.out.println("----------------");
  143.             System.out.print("The final optimal deck:");
  144.             deck.SetDeck(OptimalOneDrops,OptimalTwoDrops,OptimalThreeDrops,OptimalBolts,OptimalLands);
  145.             deck.PrintDeckBrief();
  146.             System.out.println();
  147.             System.out.println("----------------");
  148.         } while (ContinueLocalSearch);
  149.     }//end of main
  150.  
  151.     public static boolean[][][][][][] GiveOptimalMulliganStrategy(Deck deck) {
  152.         boolean[][][][][][] KeepOpeningHand = new boolean[8][8][8][8][8][8];
  153.         OpeningHand openinghand=new OpeningHand();
  154.         int NumberOfSimulationsPerOpeningHandSize=1000;
  155.         int OriginalNr1Cost=deck.NumberOf1Cost;
  156.         int OriginalNr2Cost=deck.NumberOf2Cost;
  157.         int OriginalNr3Cost=deck.NumberOf3Cost;
  158.         int OriginalNrBolts=deck.NumberOfBolts;
  159.         int OriginalNrLands=deck.NumberOfLands;
  160.         double CutOffTurn = AverageKillTurnForRandomHand(deck,1,KeepOpeningHand,NumberOfSimulationsPerOpeningHandSize);
  161.         for (int StartingCards=2; StartingCards<=7; StartingCards++){
  162.             System.out.print(".");
  163.             for (int OneDropCount=0; OneDropCount<=OriginalNr1Cost && OneDropCount<=StartingCards; OneDropCount++){
  164.                 for (int TwoDropCount=0; TwoDropCount<=OriginalNr2Cost && TwoDropCount+OneDropCount<=StartingCards; TwoDropCount++){
  165.                     for  (int ThreeDropCount=0; ThreeDropCount<=OriginalNr3Cost && ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; ThreeDropCount++){
  166.                         for (int BoltCount=0; BoltCount<=OriginalNrBolts && BoltCount+ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; BoltCount++){
  167.                             int LandCount=StartingCards-OneDropCount-TwoDropCount-ThreeDropCount-BoltCount;
  168.                             if (LandCount<=OriginalNrLands){
  169.                                 openinghand.SetHand(OneDropCount, TwoDropCount, ThreeDropCount, BoltCount, LandCount);
  170.                                 deck.SetDeck(OriginalNr1Cost,OriginalNr2Cost,OriginalNr3Cost,OriginalNrBolts,OriginalNrLands);
  171.                                 double AvgKillTurn=AverageKillTurnForSpecificHand(deck,openinghand);
  172.                                 if (AvgKillTurn<=CutOffTurn) { KeepOpeningHand[StartingCards][OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount]=true;}
  173.                                 if (AvgKillTurn>CutOffTurn) { KeepOpeningHand[StartingCards][OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount]=false;}
  174.                                 }
  175.                             }
  176.                         }
  177.                     }
  178.                 }
  179.             deck.SetDeck(OriginalNr1Cost,OriginalNr2Cost,OriginalNr3Cost,OriginalNrBolts,OriginalNrLands);
  180.             if (StartingCards<7) {CutOffTurn=AverageKillTurnForRandomHand(deck,StartingCards,KeepOpeningHand,NumberOfSimulationsPerOpeningHandSize);}
  181.         }
  182.         return KeepOpeningHand;
  183.     }
  184.  
  185.     public static boolean[][][][][][] GiveLooseMulliganStrategy() {
  186.         boolean[][][][][][] KeepOpeningHand = new boolean[8][8][8][8][8][8];
  187.         for (int StartingCards=2; StartingCards<=7; StartingCards++){
  188.             for (int OneDropCount=0; OneDropCount<=StartingCards; OneDropCount++){
  189.                 for (int TwoDropCount=0; TwoDropCount+OneDropCount<=StartingCards; TwoDropCount++){
  190.                     for  (int ThreeDropCount=0; ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; ThreeDropCount++){
  191.                         for (int BoltCount=0; BoltCount+ThreeDropCount+TwoDropCount+OneDropCount<=StartingCards; BoltCount++){
  192.                             int LandCount=StartingCards-OneDropCount-TwoDropCount-ThreeDropCount-BoltCount;
  193.                             KeepOpeningHand[StartingCards][OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount]=false;
  194.                             if (LandCount>=1 && BoltCount>=1) {KeepOpeningHand[StartingCards][OneDropCount][TwoDropCount][ThreeDropCount][BoltCount][LandCount]=true;}
  195.                         }
  196.                     }
  197.                 }
  198.             }
  199.         }
  200.         return KeepOpeningHand;
  201.     }
  202.    
  203.     public static double AverageKillTurnForSpecificHand(Deck deck, OpeningHand openinghand){
  204.         int NumberOfIterations=200;
  205.         Deck remainingdeck=new Deck();
  206.         double AverageKillTurn=0;
  207.         for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
  208.             remainingdeck.SetDeck(deck.NumberOf1Cost-openinghand.NumberOf1Cost,deck.NumberOf2Cost-openinghand.NumberOf2Cost,deck.NumberOf3Cost-openinghand.NumberOf3Cost,deck.NumberOfBolts-openinghand.NumberOfBolts,deck.NumberOfLands-openinghand.NumberOfLands);
  209.             AverageKillTurn=AverageKillTurn+TurnKill(remainingdeck,openinghand);
  210.         }
  211.         return (AverageKillTurn/(NumberOfIterations+0.0));
  212.     }//end of AverageKillTurnForSpecificHand
  213.  
  214.     public static double AverageKillTurnForRandomHand(Deck deck, int StartingCards, boolean[][][][][][] KeepOpeningHand, int NumberOfIterations){
  215.         Deck remainingdeck=new Deck();
  216.         double AverageKillTurn=0;
  217.         for (int IterationCounter=1; IterationCounter<=NumberOfIterations; IterationCounter++){
  218.             OpeningHand openinghand=GiveOpeningHandAfterMulls(deck, StartingCards, KeepOpeningHand);
  219.             remainingdeck.SetDeck(deck.NumberOf1Cost-openinghand.NumberOf1Cost,deck.NumberOf2Cost-openinghand.NumberOf2Cost,deck.NumberOf3Cost-openinghand.NumberOf3Cost,deck.NumberOfBolts-openinghand.NumberOfBolts,deck.NumberOfLands-openinghand.NumberOfLands);
  220.             AverageKillTurn=AverageKillTurn+TurnKill(remainingdeck,openinghand);
  221.             if ( IterationCounter % 200000 == 0) {System.out.print(".");}
  222.         }
  223.         return AverageKillTurn/(NumberOfIterations+0.0);
  224.     }//end of AverageKillTurnForRandomHand
  225.    
  226.     static OpeningHand GiveOpeningHandAfterMulls (Deck deck, int StartingCards, boolean[][][][][][] KeepOpeningHand) {
  227.        
  228.         Deck remainingdeck=new Deck();
  229.         OpeningHand openinghand=new OpeningHand();
  230.         int TypeOfCardDrawn;
  231.         boolean KeepHand=false;
  232.        
  233.         for (int OpeningHandSize=7; OpeningHandSize>=1; OpeningHandSize--){
  234.             if (KeepHand==false && StartingCards>=OpeningHandSize){
  235.                 openinghand.ResetHand();
  236.                 remainingdeck.SetDeck(deck.NumberOf1Cost,deck.NumberOf2Cost,deck.NumberOf3Cost,deck.NumberOfBolts,deck.NumberOfLands);
  237.                 for (int CardsDrawn=0; CardsDrawn<OpeningHandSize; CardsDrawn++){
  238.                     TypeOfCardDrawn=remainingdeck.DrawCard();
  239.                     if (TypeOfCardDrawn==1) {openinghand.NumberOf1Cost++;}
  240.                     if (TypeOfCardDrawn==2) {openinghand.NumberOf2Cost++;}
  241.                     if (TypeOfCardDrawn==3) {openinghand.NumberOf3Cost++;}
  242.                     if (TypeOfCardDrawn==4) {openinghand.NumberOfBolts++;}
  243.                     if (TypeOfCardDrawn==5) {openinghand.NumberOfLands++;}
  244.                 }
  245.                 KeepHand=true;
  246.                 if (OpeningHandSize>1) {
  247.                     if (KeepOpeningHand[OpeningHandSize][openinghand.NumberOf1Cost][openinghand.NumberOf2Cost][openinghand.NumberOf3Cost][openinghand.NumberOfBolts][openinghand.NumberOfLands]==false) {KeepHand=false;}
  248.                 }
  249.             }
  250.         }
  251.        
  252.         return openinghand;
  253.     }//end of GiveOpeningHandAfterMulls
  254.    
  255. static int TurnKill(Deck remainingdeck, OpeningHand openinghand) {
  256.        
  257.         int EmpathPower=1;
  258.         int HexplatePower=5;
  259.        
  260.         int Turn=0;
  261.         int OppLife=20;
  262.         int ManaLeft;
  263.         int TurfsLeft;
  264.         int TypeOfCardDrawn;
  265.    
  266.         int EmpathsInPlay=0;
  267.         int HexplatesInPlay=0;
  268.         int WolfRunsInPlay=0;
  269.         int TurfsInPlay=0;
  270.         int TotalPower;
  271.         int TotalPump;
  272.         boolean LandPlayed;
  273.        
  274.         int EmpathsInHand=openinghand.NumberOf1Cost;
  275.         int HexplatesInHand=openinghand.NumberOf2Cost;
  276.         int WolfRunsInHand=openinghand.NumberOfBolts;
  277.         int TurfsInHand=openinghand.NumberOfLands;
  278.        
  279.         do {
  280.            
  281.             Turn++;
  282.            
  283.             if (Turn>1) {
  284.  
  285.                 TypeOfCardDrawn=remainingdeck.DrawCard();
  286.                 if (TypeOfCardDrawn==1) {EmpathsInHand++;}
  287.                 if (TypeOfCardDrawn==2) {HexplatesInHand++;}
  288.                 if (TypeOfCardDrawn==4) {WolfRunsInHand++;}
  289.                 if (TypeOfCardDrawn==5) {TurfsInHand++;}
  290.             }
  291.            
  292.             LandPlayed=false;
  293.            
  294.             //Start by attacking with all creatures; we can pump later
  295.             TotalPower=EmpathsInPlay*EmpathPower+HexplatesInPlay*HexplatePower;
  296.             OppLife=OppLife-TotalPower;
  297.            
  298.             //Play a Wolf Run if we already have a Turf
  299.             if (WolfRunsInHand>=1 && TurfsInPlay>=1) {
  300.                 WolfRunsInPlay++; WolfRunsInHand--;
  301.                 LandPlayed=true;
  302.             }
  303.            
  304.             //Check to see if pumping all-in is lethal
  305.             TotalPump=0;
  306.             if (WolfRunsInPlay>=1 && TurfsInPlay>=1 && TotalPower>=1) {
  307.                 TotalPump=TotalPump+(WolfRunsInPlay-1)+(TurfsInPlay*2-2);
  308.             }
  309.             if (TotalPump>=OppLife) {OppLife=OppLife-TotalPump;}
  310.            
  311.             //If we already won, then whatever. Otherwise, check to see if we can play a Hexplate Golem
  312.             ManaLeft=WolfRunsInPlay+TurfsInPlay*2;
  313.            
  314.             if (ManaLeft>=7 && HexplatesInHand>=1) {
  315.                 HexplatesInHand--;
  316.                 HexplatesInPlay++;
  317.                 ManaLeft=ManaLeft-7;
  318.             }
  319.            
  320.             //Otherwise, on turns 3-5, check to see if we can play a Fierce Empath
  321.             TurfsLeft=TurfsInPlay;
  322.            
  323.             if (ManaLeft>=3 && ManaLeft<=5 && TurfsLeft>=1 && EmpathsInHand>=1) {
  324.                 EmpathsInHand--;
  325.                 EmpathsInPlay++;
  326.                 ManaLeft=ManaLeft-3;
  327.                 TurfsLeft--;
  328.                 if (remainingdeck.NumberOf2Cost>=1) {
  329.                     remainingdeck.NumberOf2Cost--;
  330.                     HexplatesInHand++;
  331.                 }
  332.             }
  333.            
  334.             //On turns 6+, if we don't already have an Empth, then cast one
  335.             if (ManaLeft>=6 && EmpathsInPlay==0 && EmpathsInHand>=1) {
  336.                 EmpathsInHand=EmpathsInHand--;
  337.                 EmpathsInPlay++;
  338.                 ManaLeft=ManaLeft-3;
  339.                 TurfsLeft--;
  340.                 if (remainingdeck.NumberOf2Cost>=1) {
  341.                     remainingdeck.NumberOf2Cost--;
  342.                     HexplatesInHand++;
  343.                 }
  344.             }
  345.  
  346.             //If we have six mana left and can cast two Empaths, then do so (otherwise, spend mana to pump)
  347.             if (ManaLeft==6 && TurfsLeft>=2 && EmpathsInHand>=2) {
  348.                 EmpathsInHand=EmpathsInHand--;
  349.                 EmpathsInPlay++;
  350.                 ManaLeft=ManaLeft-3;
  351.                 TurfsLeft--;
  352.                 if (remainingdeck.NumberOf2Cost>=1) {
  353.                     remainingdeck.NumberOf2Cost--;
  354.                     HexplatesInHand++;
  355.                 }
  356.                 EmpathsInHand=EmpathsInHand--;
  357.                 EmpathsInPlay++;
  358.                 ManaLeft=ManaLeft-3;
  359.                 TurfsLeft--;
  360.                 if (remainingdeck.NumberOf2Cost>=1) {
  361.                     remainingdeck.NumberOf2Cost--;
  362.                     HexplatesInHand++;
  363.                 }
  364.             }
  365.  
  366.             //Pump remaining mana into Wolf Run
  367.             if (WolfRunsInPlay>=1 && TurfsLeft>=1 && TotalPower>=1 && ManaLeft>=4) {
  368.                 TotalPump=ManaLeft-3;
  369.                 OppLife=OppLife-TotalPump;
  370.             }
  371.  
  372.             //Play a Gruul Turf if possible
  373.             if (TurfsInHand>=1 && WolfRunsInPlay>=1 && !LandPlayed) {
  374.                 TurfsInPlay++;
  375.                 TurfsInHand--;
  376.                 WolfRunsInPlay--;
  377.                 WolfRunsInHand++;
  378.                 LandPlayed=true;
  379.             }
  380.            
  381.             //Otherwise, play a Kessig Wolf Run if possible
  382.             if (WolfRunsInHand>=1 && !LandPlayed) {
  383.                 WolfRunsInPlay++;
  384.                 WolfRunsInHand--;
  385.                 LandPlayed=true;
  386.             }
  387.            
  388.            //System.out.println("At the end of Turn "+Turn+" with the opponent at "+OppLife+" life, the situation is as follows:");
  389.            // System.out.println("Hand: "+EmpathsInHand+ " Empaths, "+HexplatesInHand+" Hexplates, "+TurfsInHand+" Turfs, "+WolfRunsInHand+" Wolf Runs");
  390.            // System.out.println("Board: "+EmpathsInPlay+ " Empaths, "+HexplatesInPlay+" Hexplates, "+TurfsInPlay+" Turfs, and "+WolfRunsInPlay+" Wolf Runs.");
  391.  
  392.         } while (OppLife>0 &&Turn<=50);
  393.        
  394.         return Turn;
  395.     }//end of TurnKill
  396.  
  397. }//end of OptimalAggroGoldfishDeck
  398.  
  399. class OpeningHand {
  400.     int NumberOf1Cost;
  401.     int NumberOf2Cost;
  402.     int NumberOf3Cost;
  403.     int NumberOfBolts;
  404.     int NumberOfLands;
  405.  
  406.     void ResetHand(){
  407.         NumberOf1Cost=0;
  408.         NumberOf2Cost=0;
  409.         NumberOf3Cost=0;
  410.         NumberOfBolts=0;
  411.         NumberOfLands=0;
  412.     }
  413.            
  414.     void SetHand (int Nr1Cost, int Nr2Cost, int Nr3Cost, int NrBolts, int NrLands) {
  415.         NumberOf1Cost=Nr1Cost;
  416.         NumberOf2Cost=Nr2Cost;
  417.         NumberOf3Cost=Nr3Cost;
  418.         NumberOfBolts=NrBolts;
  419.         NumberOfLands=NrLands;
  420.     }
  421.  
  422. }//end of OpeningHand
  423.  
  424. class Deck {
  425.     int NumberOf1Cost;
  426.     int NumberOf2Cost;
  427.     int NumberOf3Cost;
  428.     int NumberOfBolts;
  429.     int NumberOfLands;
  430.  
  431.     void PrintDeckBrief () {
  432.         if(NumberOf1Cost<10) {System.out.print("0");}
  433.         System.out.print(NumberOf1Cost+" ");
  434.         if(NumberOf2Cost<10) {System.out.print("0");}
  435.         System.out.print(NumberOf2Cost+" ");
  436.         if(NumberOf3Cost<10) {System.out.print("0");}
  437.         System.out.print(NumberOf3Cost+" ");
  438.         if(NumberOfBolts<10) {System.out.print("0");}
  439.         System.out.print(NumberOfBolts+" ");
  440.         if(NumberOfLands<10) {System.out.print("0");}
  441.         System.out.print(NumberOfLands);
  442.         System.out.print(" ");
  443.     }
  444.  
  445.     void SetDeck (int Nr1Cost, int Nr2Cost, int Nr3Cost, int NrBolts, int NrLands) {
  446.         NumberOf1Cost=Nr1Cost;
  447.         NumberOf2Cost=Nr2Cost;
  448.         NumberOf3Cost=Nr3Cost;
  449.         NumberOfBolts=NrBolts;
  450.         NumberOfLands=NrLands;
  451.     }
  452.    
  453.     int NrOfCards(){
  454.         return NumberOf1Cost+NumberOf2Cost+NumberOf3Cost+NumberOfBolts+NumberOfLands;
  455.     }
  456.    
  457.     int DrawCard (){
  458.             Random generator = new Random();
  459.             int RandomIntegerBetweenOneAndDeckSize=generator.nextInt( this.NrOfCards() )+1;
  460.             int CardType=0;
  461.             int OneCostCutoff=NumberOf1Cost;
  462.             int TwoCostCutoff=OneCostCutoff+NumberOf2Cost;
  463.             int ThreeCostCutoff=TwoCostCutoff+NumberOf3Cost;
  464.             int BoltCutoff=ThreeCostCutoff+NumberOfBolts;
  465.             int LandCutoff=BoltCutoff+NumberOfLands;
  466.            
  467.             if (RandomIntegerBetweenOneAndDeckSize<=OneCostCutoff) {CardType=1; this.NumberOf1Cost--;}
  468.             if (RandomIntegerBetweenOneAndDeckSize>OneCostCutoff && RandomIntegerBetweenOneAndDeckSize<=TwoCostCutoff) {CardType=2; this.NumberOf2Cost--;}
  469.             if (RandomIntegerBetweenOneAndDeckSize>TwoCostCutoff && RandomIntegerBetweenOneAndDeckSize<=ThreeCostCutoff) {CardType=3; this.NumberOf3Cost--;}
  470.             if (RandomIntegerBetweenOneAndDeckSize>ThreeCostCutoff && RandomIntegerBetweenOneAndDeckSize<=BoltCutoff) {CardType=4; this.NumberOfBolts--;}
  471.             if (RandomIntegerBetweenOneAndDeckSize>BoltCutoff && RandomIntegerBetweenOneAndDeckSize<=LandCutoff) {CardType=5; this.NumberOfLands--;}
  472.             return CardType;
  473.     }
  474.    
  475. }//end of Deck
RAW Paste Data