API tools faq
paste
Kirkq

Bomberman Generations GCN Charaboms

Kirkq
Oct 28th, 2013
390
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.46 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <cstdio>
  3. #include <stdio.h>
  4. #include <math.h>
  5. #include <windows.h>
  6. using namespace std;
  7.  
  8. class Charabom
  9. {
  10.   public:
  11.     int Atk;
  12.     int Def;
  13.     int SpecAtk;
  14.     int SpecDef;
  15.     int Level;
  16.     int MaxHP;
  17.     int CurrHP;
  18.     double Modifier;
  19.     Charabom (int,int,int,int,double);
  20. };
  21. Charabom::Charabom (int a, int b, int c, int d, double e)
  22. {
  23.   Atk = a;
  24.   Def = b;
  25.   SpecAtk = c;
  26.   SpecDef = d;
  27.   Modifier = e;
  28.   Level = (a + b + c + d)/4;
  29.   MaxHP = Level*3;
  30.   CurrHP = MaxHP;
  31. }
  32.  
  33. class Player
  34. {
  35.   public:
  36.     int StratArray[3];
  37.     int TurnMove[3];
  38.     int EndFlag;
  39.     Player();
  40.     /////////////////////
  41.     void NextComb (void)
  42.     {
  43.       StratArray[0]++;
  44.       if(StratArray[0]>5)
  45.       {
  46.         StratArray[0]=0;
  47.         StratArray[1]++;
  48.         if(StratArray[1]>5)
  49.         {
  50.          StratArray[1]=0;
  51.          StratArray[2]++;
  52.          if(StratArray[2]>5)
  53.          {
  54.            EndFlag = 1;
  55.            StratArray[0]=0;
  56.            StratArray[1]=0;
  57.            StratArray[2]=0;                  
  58.          }                          
  59.         }
  60.       }    
  61.     }
  62.     /////////////////////
  63.     void TurnTranslate (int i)
  64.     {
  65.       if(StratArray[i]==0)
  66.       {
  67.         TurnMove[0]=0;
  68.         TurnMove[1]=1;
  69.         TurnMove[2]=2;  
  70.       }
  71.       else if(StratArray[i]==1)
  72.       {
  73.         TurnMove[0]=0;
  74.         TurnMove[1]=2;
  75.         TurnMove[2]=1;  
  76.       }
  77.       else if(StratArray[i]==2)
  78.       {
  79.         TurnMove[0]=1;
  80.         TurnMove[1]=0;
  81.         TurnMove[2]=2;  
  82.       }
  83.       else if(StratArray[i]==3)
  84.       {
  85.         TurnMove[0]=1;
  86.         TurnMove[1]=2;
  87.         TurnMove[2]=0;  
  88.       }
  89.       else if(StratArray[i]==4)
  90.       {
  91.         TurnMove[0]=2;
  92.         TurnMove[1]=0;
  93.         TurnMove[2]=1;  
  94.       }
  95.       else  //StratArray = 5
  96.       {
  97.         TurnMove[0]=2;
  98.         TurnMove[1]=1;
  99.         TurnMove[2]=0;  
  100.       }
  101.     }
  102. };
  103. Player::Player()
  104. {
  105.    StratArray[0]=0;
  106.    StratArray[1]=0;
  107.    StratArray[2]=0;
  108.    EndFlag = 0;
  109. }
  110.  
  111. class FightData
  112. {
  113.   public:
  114.     int CurrTurn; //1-3
  115.     int CurrRound; //1-3
  116.     int HumanAtkHigh;
  117.     int HumanAtkLow;
  118.     int HumanSpecHigh;
  119.     int HumanSpecLow;
  120.     int CPUAtkHigh;
  121.     int CPUAtkLow;  
  122.     int CPUSpecHigh;
  123.     int CPUSpecLow;
  124.     int FightEnd;
  125.     int FightWins;
  126.     int FightLosses;
  127.     int BestWins;
  128.     int BestLosses;
  129.     int BestRound1;
  130.     int BestRound2;
  131.     int ValidComb;
  132.     FightData();
  133. };  
  134. FightData::FightData()
  135. {
  136.    CurrTurn=0;
  137.    CurrRound=0;
  138.    HumanAtkHigh=0;
  139.    HumanAtkLow=0;
  140.    HumanSpecHigh=0;
  141.    HumanSpecLow=0;
  142.    CPUAtkHigh=0;
  143.    CPUAtkLow=0;  
  144.    CPUSpecHigh=0;
  145.    CPUSpecLow=0;
  146.    FightEnd=0;
  147.    FightWins=0;
  148.    FightLosses=0;
  149.    BestWins=0;
  150.    BestLosses=0;
  151.    BestRound1=0;
  152.    BestRound2=0;
  153.    ValidComb=0;
  154. }  
  155.  
  156. ////////////////////////////////////////////////////////////
  157. ////////////////////////////////////////////////////////////
  158.  
  159. int NegZero(int Value)
  160. {
  161.   if(Value<0)
  162.   {
  163.     Value = 0;
  164.   }
  165.   return Value;
  166. }
  167.  
  168. void CalculateFightData(Charabom &MyCharabom, Charabom &CPUCharabom, FightData &Fight)
  169. {
  170.   Fight.HumanAtkHigh = MyCharabom.Atk;
  171.   Fight.HumanAtkLow = MyCharabom.Atk - CPUCharabom.Def;
  172.   Fight.HumanAtkLow = NegZero(Fight.HumanAtkLow);
  173.   Fight.HumanSpecHigh = int (MyCharabom.Modifier*MyCharabom.SpecAtk);  ///This probably doesn't work right for different elements.
  174.   Fight.HumanSpecLow = int (MyCharabom.Modifier*MyCharabom.SpecAtk*0.5);  ///This probably doesn't work right for different elements.
  175.   Fight.CPUAtkHigh = CPUCharabom.Atk;
  176.   Fight.CPUAtkLow = CPUCharabom.Atk - MyCharabom.Def;
  177.   Fight.CPUAtkLow = NegZero(Fight.CPUAtkLow);
  178.   Fight.CPUSpecHigh = int (CPUCharabom.SpecAtk*0.5);  //This probably doesn't work right for different elements.
  179.   Fight.CPUSpecLow = int (CPUCharabom.SpecAtk*0);  //This probably doesn't work right for different elements.
  180.  
  181.   //printf("FightData %d, %d, %d, %d, ",Fight.HumanAtkHigh,Fight.HumanAtkLow,Fight.HumanSpecHigh,Fight.HumanSpecLow);
  182.   //printf("%d, %d, %d, %d \n",Fight.CPUAtkHigh,Fight.CPUAtkLow,Fight.CPUSpecHigh,Fight.CPUSpecLow);
  183. }
  184.  
  185. void CharabomRestat(Charabom &MyCharabom, int a, int b, int c, int d)
  186. {
  187.   MyCharabom.Atk = a;
  188.   MyCharabom.Def = b;
  189.   MyCharabom.SpecAtk = c;
  190.   MyCharabom.SpecDef = d;
  191.   MyCharabom.Level = (a + b + c + d)/4;
  192.   MyCharabom.MaxHP = MyCharabom.Level*3;
  193.   MyCharabom.CurrHP = MyCharabom.MaxHP;
  194. }
  195.  
  196. void ReplenishFight(Charabom &MyCharabom, Charabom &CPUCharabom, FightData &Fight)
  197. {
  198.    Fight.CurrTurn=0;
  199.    Fight.CurrRound=0;
  200.    Fight.FightEnd=0;
  201.    MyCharabom.CurrHP = MyCharabom.MaxHP;
  202.    CPUCharabom.CurrHP = CPUCharabom.MaxHP;
  203. }
  204.  
  205. void DumpCPU(FightData &Fight, Player &Human)
  206. {
  207.    //printf("Fight.FightWins %d out of 216\n",Fight.FightWins);
  208.    //printf("Fight.FightLosses %d\n",Fight.FightLosses);
  209.    //Sleep(50);
  210.    if(Fight.FightWins>Fight.BestWins)
  211.    {
  212.      Fight.BestWins = Fight.FightWins;
  213.      Fight.BestLosses = Fight.FightLosses;
  214.      Fight.BestRound1 = Human.StratArray[0];
  215.      Fight.BestRound2 = Human.StratArray[1];
  216.    }    
  217. }
  218.  
  219. void TurnSimulate(Player &Human, Charabom &MyCharabom, Player &CPU, Charabom &CPUCharabom, FightData &Fight)
  220. {
  221.      //printf("Turn %d\n",Fight.CurrTurn);
  222.      //We're assuming for this fight that the opponent always goes first, so if I'm dead by the end of the turn he wins anyway.
  223.      
  224.      if (Human.TurnMove[Fight.CurrTurn] == 0) //Is attacking
  225.      {
  226.        if(CPU.TurnMove[Fight.CurrTurn] == 1) //Is Defending
  227.        {
  228.          CPUCharabom.CurrHP = CPUCharabom.CurrHP - Fight.HumanAtkLow;
  229.          //printf("Dealt %d CPU HAS %d\n", Fight.HumanAtkLow,CPUCharabom.CurrHP);                              
  230.        }
  231.        else
  232.        {
  233.          CPUCharabom.CurrHP = CPUCharabom.CurrHP - Fight.HumanAtkHigh;
  234.          //printf("Dealt %d CPU HAS %d\n", Fight.HumanAtkHigh,CPUCharabom.CurrHP);                              
  235.        }      
  236.      }
  237.      //////
  238.      if (CPU.TurnMove[Fight.CurrTurn] == 0) //Is attacking
  239.      {
  240.        if(Human.TurnMove[Fight.CurrTurn] == 1) //Is Defending
  241.        {
  242.          MyCharabom.CurrHP = MyCharabom.CurrHP - Fight.CPUAtkLow;
  243.          //printf("Received %d \n", Fight.CPUAtkLow);                              
  244.        }
  245.        else
  246.        {
  247.          MyCharabom.CurrHP = MyCharabom.CurrHP - Fight.CPUAtkHigh;
  248.          //printf("Received %d \n", Fight.CPUAtkHigh);                              
  249.        }      
  250.      }
  251.      /////
  252.      if (Human.TurnMove[Fight.CurrTurn] == 2) //Is Spec Atking
  253.      {
  254.        if(CPU.TurnMove[Fight.CurrTurn] == 1) //Is Defending
  255.        {
  256.          CPUCharabom.CurrHP = CPUCharabom.CurrHP - Fight.HumanSpecLow;
  257.          //printf("Dealt %d CPU HAS %d\n", Fight.HumanSpecLow,CPUCharabom.CurrHP);                              
  258.        }
  259.        else
  260.        {
  261.          CPUCharabom.CurrHP = CPUCharabom.CurrHP - Fight.HumanSpecHigh;
  262.          //printf("Dealt %d CPU HAS %d\n", Fight.HumanSpecHigh,CPUCharabom.CurrHP);                                
  263.        }      
  264.      }
  265.      /////
  266.      if (CPU.TurnMove[Fight.CurrTurn] == 2) //Is Spec Atking
  267.      {
  268.        if(Human.TurnMove[Fight.CurrTurn] == 1) //Is Defending
  269.        {
  270.          MyCharabom.CurrHP = MyCharabom.CurrHP - Fight.CPUSpecLow;
  271.          //printf("Received %d \n", Fight.CPUSpecLow);                              
  272.        }
  273.        else
  274.        {
  275.          MyCharabom.CurrHP = MyCharabom.CurrHP - Fight.CPUSpecHigh;
  276.          //printf("Received %d \n", Fight.CPUSpecHigh);                                
  277.        }      
  278.      }
  279.      /////
  280.      if(CPUCharabom.CurrHP<0 || MyCharabom.CurrHP<0)
  281.      {
  282.           Fight.FightEnd = 1;                    
  283.      }  
  284. }
  285.  
  286. void RoundSimulate(Player &Human, Charabom &MyCharabom, Player &CPU, Charabom &CPUCharabom, FightData &Fight)
  287. {
  288.       //printf("ROUND: %d\n",Fight.CurrRound);
  289.       while(Fight.CurrTurn<3&&Fight.FightEnd==0)
  290.       {
  291.         TurnSimulate(Human, MyCharabom, CPU, CPUCharabom, Fight);
  292.         Fight.CurrTurn++;
  293.       }
  294.      
  295.      
  296. }
  297.  
  298. void ValidComb(Player &Human, Player &CPU, FightData &Fight)
  299. {
  300.      if(Human.StratArray[0]==Human.StratArray[1]||Human.StratArray[0]==Human.StratArray[2]||Human.StratArray[1]==Human.StratArray[2])
  301.      {
  302.        Fight.ValidComb = 0;
  303.      }
  304.      else if(CPU.StratArray[0]==CPU.StratArray[1]||CPU.StratArray[0]==CPU.StratArray[2]||CPU.StratArray[1]==CPU.StratArray[2])
  305.      {
  306.        Fight.ValidComb = 0;          
  307.      }
  308.      else
  309.      {
  310.        Fight.ValidComb = 1;
  311.      }
  312. }
  313.  
  314.  
  315. void BattleSimulate(Player &Human, Charabom &MyCharabom, Player &CPU, Charabom &CPUCharabom, FightData &Fight)
  316. {
  317.      //A battle has 3 rounds and a round has 3 turns.
  318.  
  319.      //////One human strategy vs all opponent strategies/////////////////////////////////////////////////////
  320. while(Human.EndFlag==0)
  321. {    
  322.   while(CPU.EndFlag==0)      
  323.   {
  324.      //////One fight instance//////////////////////////////////////////////////////////////
  325.      ReplenishFight(MyCharabom,CPUCharabom,Fight); //Resets round number, turn number, FightEnd, and HPs
  326.      //printf("Fight.CurrRound = 0 %d \n",Fight.CurrRound);  
  327.    
  328.     //printf("MyHP %d, CPUHP %d, CurRound %d \n",MyCharabom.CurrHP,CPUCharabom.CurrHP,Fight.CurrRound);
  329.      while( (MyCharabom.CurrHP>0) && (CPUCharabom.CurrHP>0)  && (Fight.CurrRound <3) && (Fight.FightEnd==0))
  330.      {
  331.        //One Round////
  332.        Human.TurnTranslate(Fight.CurrRound);
  333.        //printf("Human Turns %d,%d,%d \n",Human.TurnMove[0],Human.TurnMove[1],Human.TurnMove[2]);
  334.        CPU.TurnTranslate(Fight.CurrRound);
  335.        //printf("CPU Turns %d,%d,%d \n",CPU.TurnMove[0],CPU.TurnMove[1],CPU.TurnMove[2]);
  336.        RoundSimulate(Human, MyCharabom, CPU, CPUCharabom, Fight);
  337.        //Sleep(100);
  338.        Fight.CurrRound++;
  339.        Fight.CurrTurn = 0;
  340.        ///////////////
  341.      }
  342.      
  343.      ValidComb(Human, CPU, Fight);  //1,1,2 is not a valid fight set, we simulated it but we won't add it to the results.
  344.      
  345.      ///////////////////////////////////////////////////////////////////////////////////////
  346.      if((MyCharabom.CurrHP>0)&&(Fight.ValidComb==1))
  347.      {
  348.        Fight.FightWins += 1;
  349.        //printf("%d %d I win \n",MyCharabom.CurrHP,CPUCharabom.CurrHP);
  350.        //printf("NEW FIGHT");
  351.        //Sleep(100);                    
  352.      }
  353.      else if((MyCharabom.CurrHP<=0)&&(Fight.ValidComb==1))
  354.      {
  355.        Fight.FightLosses += 1;
  356.        //printf("%d %d I lose \n",MyCharabom.CurrHP,CPUCharabom.CurrHP);
  357.        //printf("NEW FIGHT");
  358.        //Sleep(100);      
  359.      }
  360.      CPU.NextComb();  //Next Comb of rounds
  361.      //printf("NEW ROUND CPU NextComb %d,%d,%d \n",CPU.StratArray[0],CPU.StratArray[1],CPU.StratArray[2]);
  362.      if(CPU.EndFlag==1)
  363.      {
  364.        DumpCPU(Fight,Human);
  365.        Fight.FightWins = 0;
  366.        Fight.FightLosses = 0;
  367.        //Sleep(100);
  368.      }
  369.  
  370.   }
  371.      CPU.EndFlag = 0;    
  372.      //////////////////////////////////////////////////////////////////////////////////////////////////////////
  373.      Human.NextComb();
  374.      //printf("NEW ROUND Human NextComb %d,%d,%d \n",Human.StratArray[0],Human.StratArray[1],Human.StratArray[2]);
  375. }  
  376. Human.EndFlag=0;
  377. }
  378.  
  379. int main ()
  380. {  
  381.   int i = 16;
  382.   int j = 17;
  383.   int k = 18;
  384.   int l = 17;
  385.   Player Kirkq;
  386.   Player CPU;
  387.   //Charabom Andlar (16,17,18,17,2); //Atk,Def,SpecAtk,SpecDef,Modifier
  388.   Charabom Andlar (16,17,18,17,2); //Atk,Def,SpecAtk,SpecDef,Modifier
  389.   Charabom Pteradon (40,30,10,20,0.5);
  390.   FightData Fight;
  391.  
  392.  
  393. //Lots of lower ways to get XX.
  394. //Pretty much need level 16 to get XX.
  395. //Level 17 and 19 Atk and 19 Spec or 18 and 20 will get 68.   //Let's try to route this?
  396. //Really need 19 Special
  397.  
  398. //22 18 = 56
  399. //19,19 = 68
  400. //18,20 = 68
  401. ///17,20 = 64
  402. //16,20 = 64
  403. //17,21 = 68
  404. //13,21 = 64
  405. //16,22 = 68
  406. //12,22 = 64
  407. //15,23 = 68
  408.  
  409. //Pretty much need level 21 to get XXX.
  410. //64-68 is about as good as it gets.
  411.  
  412. //His 1:57 does Lv19: 15,19,24,19
  413. //His 1:56 does Lv19: 18,19,23,19
  414.  
  415. for(i=12;i<25;i++){
  416. for(j=18;j<19;j++){
  417. for(k=12;k<25;k++){
  418. for(l=18;l<19;l++){
  419.   CharabomRestat(Andlar,i,j,k,l);
  420.   Sleep(10);
  421.   CalculateFightData(Andlar,Pteradon,Fight);
  422.   BattleSimulate(Kirkq,Andlar,CPU,Pteradon,Fight);
  423.   printf("Stats: Lv: %d , %d,%d,%d,%d BestWins: %d, Strat %d %d\n",Andlar.Level,Andlar.Atk,Andlar.Def,Andlar.SpecAtk,Andlar.SpecDef,Fight.BestWins,Fight.BestRound1,Fight.BestRound2);
  424.   Fight.BestWins = 0;
  425.   Fight.BestLosses = 0;
  426.   Fight.BestRound1 = 0;
  427.   Fight.BestRound2 = 0;
  428. }
  429. }
  430. }
  431. }
  432.   cout << "To close type something and hit enter: ";
  433.   cin >> i;
  434.   return 0;
  435. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!