Sign in to follow this  

WOW!WTF stop the press!

This topic is 3860 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

[brag].. Mads has just finished his first "real" game - a Blackjack game! wohoo"! Here it is, in all its awesomeness, but for your eyes only!: [showoff]
#include <iostream>
#include <string>
#include <vector>
#include <ctime>
#include <algorithm>

using namespace std;

class Kort
{
 public:
  enum rank {ES = 1, TO, TRE, FIRE, FEM, SEKS, SYV, OTTE, NI, TI, BONDE, DRONNING, KONGE};
  enum kulør {KLØR, RUDER, HJERTER, SPAR};
  
  //overloader << operatoren så jeg kan sende Kort objekter til standard output
  friend ostream& operator<<(ostream& os, const Kort& etKort);
  
  Kort(rank e = ES, kulør s = SPAR, bool VendtOp = true);
  
  //returnere værdien af kort, 1-11 
  int HentVærdi() const;
  
  //vender kortet, hvis kortet vender nedad vendes det om og vice versa
  void Vend();
 
 //slut med public, start af private
 private:
  rank m_Rank;
  kulør m_Kulør;
  bool m_ErVendtOp;
}; //slut på class Kort

//Kort constructor
Kort::Kort(rank r, kulør s, bool VendtOp): m_Rank(r), m_Kulør(s), m_ErVendtOp(VendtOp)
{}

int Kort::HentVærdi() const
{
 int værdi = 0;
 if (m_ErVendtOp)
 {
  //værdien er den vist på kortet
  værdi = m_Rank;
  //værdien er 10 for knægt, dronning og konge
  if (værdi > 10)
   værdi = 10;
 }
return værdi;
}

void Kort::Vend()
{
 m_ErVendtOp = !(m_ErVendtOp);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////HER BEGYNDER 'HÅND KLASSEN'/////////////////////////////////

class Hånd
{ 
 public:
  Hånd();
  
  virtual ~Hånd();
  
  void TilføjKort(Kort* pKort);
  //sletter hele hånden
  void Slet();
    
  int HentTotal() const;
 
 protected: 
  vector<Kort*> m_Kort;
}; //slut på class Hånd

Hånd::Hånd()
{
 m_Kort.reserve(7);
}

Hånd::~Hånd()
{
 Slet();
}

void Hånd::TilføjKort(Kort* pKort)
{
 m_Kort.push_back(pKort);
}

void Hånd::Slet()
{
 vector<Kort*>::iterator iter = m_Kort.begin();
 for(iter = m_Kort.begin(); iter != m_Kort.end(); ++iter)
 {
  delete *iter;
  *iter = 0;
 }
 m_Kort.clear();
}

int Hånd::HentTotal() const
{
 if (m_Kort.empty())
  return 0;
 
 if (m_Kort[0]->HentVærdi() == 0)
  return 0;
 
 //Når vi er nået hertil, kan det kun betyde at ingen af kortene er vendt om, og at hånden ikke er tom
 int total = 0;
 vector<Kort*>::const_iterator iter;
 
 for(iter = m_Kort.begin(); iter != m_Kort.end(); ++iter)
 {
  total += (*iter)->HentVærdi();
 }
 
 //find ud af om hånden indeholder et es
 bool IndeholderES = false;
 for (iter = m_Kort.begin(); iter != m_Kort.end(); ++iter)
 {
  if((*iter)->HentVærdi() == Kort::ES)
   IndeholderES = true;
 }
 
 //hvis hånden indeholder et ES, skal vi se om det skal tydes som 1 eller 11
 if (IndeholderES && total <= 11)
  total += 10;

return total;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////HER BEGYNDER GenetiskSpiller classen////////////////////

class GenetiskSpiller: public Hånd
{
 friend ostream& operator<<(ostream& os, const GenetiskSpiller& enGenetiskSpiller);
 
 public:
  GenetiskSpiller(const string& = "");
  
  virtual ~GenetiskSpiller();
  
  //abstract funktion
  virtual bool FlereKort() const = 0;
  
  bool ErBusted() const;
  
  void AnnoncerBusted() const;
 
 protected:
  string m_Name;
};

GenetiskSpiller::GenetiskSpiller(const string& name): m_Name(name)
{}

GenetiskSpiller::~GenetiskSpiller()
{}

bool GenetiskSpiller::ErBusted() const
{
 return (HentTotal()> 21);
}

void GenetiskSpiller::AnnoncerBusted() const
{
 cout << m_Name << " er blevet busted.\n";
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////HER STARTER SPILLER CLASSEN///////////////////////////

class Spiller: public GenetiskSpiller
{
 public: 
  Spiller(const string& name = "");
  
  virtual ~Spiller();
  
  virtual bool FlereKort() const;
  
  void Vundet() const;
  void Tabt() const;
  void Uafgjort() const;
};

Spiller::Spiller(const string& name): GenetiskSpiller(name)
{}

Spiller::~Spiller()
{}

bool Spiller::FlereKort() const
{
 cout << m_Name << "vil du have flere kort?(Y/N): ";
 char svar;
 cin >> svar;
 return (svar == 'y' || svar == 'Y');
}

void Spiller::Vundet() const
{
 cout << "Tillykke " << m_Name << " har vundet\n";
}

void Spiller::Tabt() const
{
 cout << "Desværre " << m_Name << " du har tabt\n";
}

void Spiller::Uafgjort() const
{
 cout << m_Name << " lave uafgjort mod computeren!\n";
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////HER BEGYNDER HUS CLASSEN//////////////////////////////

class Hus: public GenetiskSpiller
{
 public:
  Hus(const string& name = "Huset");
  
  virtual ~Hus();
  
  virtual bool FlereKort() const;
  
  void VendFørsteKort();
};

Hus::Hus(const string& name): GenetiskSpiller(name)
{}

Hus::~Hus()
{}

bool Hus::FlereKort() const
{
 return (HentTotal() <= 16);
}

void Hus::VendFørsteKort()
{
 if (!(m_Kort.empty()))
  m_Kort[0]->Vend();
 else cout << "Ingen kort at vende\n";
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////HER STARTER DÆK CLASSEN////////////////////////////

class Dæk: public Hånd
{
 public:
  Dæk();
  
  virtual ~Dæk();
  
  void LavDæk();
  
  void Bland();
  
  void Deal(Hånd& enHånd);
  
  void FlereKortTilSpiller(GenetiskSpiller& enGenetiskSpiller);
};

Dæk::Dæk()
{
 m_Kort.reserve(52);
 LavDæk();
}

Dæk::~Dæk()
{}

void Dæk::LavDæk()
{
 Slet();
 
 for (int s = Kort::KLØR; s <= Kort::SPAR; ++s)
  for (int r = Kort::ES; r <= Kort::KONGE; ++r)
   TilføjKort(new Kort(static_cast<Kort::rank>(r), static_cast<Kort::kulør>(s)));
      
}

void Dæk::Bland()
{
 random_shuffle(m_Kort.begin(), m_Kort.end());
}

void Dæk::Deal( Hånd& enHånd)
{
 if (!m_Kort.empty())
 { 
  enHånd.TilføjKort(m_Kort.back());
  m_Kort.pop_back();
 }
 else
  cout << "Ikke flere kort, er ikke i stand til at Deale\n";
}

void Dæk::FlereKortTilSpiller(GenetiskSpiller& enGenetiskSpiller)
{
 cout << endl;
 
 while ( !(enGenetiskSpiller.ErBusted()) && enGenetiskSpiller.FlereKort())
 {
  Deal(enGenetiskSpiller);
  cout << enGenetiskSpiller << endl;
  
  if (enGenetiskSpiller.ErBusted())
   enGenetiskSpiller.AnnoncerBusted();
 }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////HER STARTER GAME CLASSEN//////////////////////////////

class Spillet
{
 public:
  Spillet(const vector<string>& navne);
  
  ~Spillet();
  
  void Spil();
  
 private:
  Dæk m_Dæk;
  Hus m_Huset;
  vector<Spiller> m_Spillere;
};

Spillet::Spillet(const vector<string>& navne)
{
 //laver en vector af spillere, ud fra en vector med navne
 vector<string>::const_iterator pNavne;
 for( pNavne = navne.begin(); pNavne != navne.end(); ++pNavne)
  m_Spillere.push_back(Spiller(*pNavne));
 
 srand(time(0));
 m_Dæk.LavDæk();
 m_Dæk.Bland();
}

Spillet::~Spillet()
{}

void Spillet::Spil()
{
 vector<Spiller>::iterator pSpiller;
 
 for (int i = 0; i < 2; ++i)
 {
  for (pSpiller = m_Spillere.begin(); pSpiller != m_Spillere.end(); ++pSpiller)
   m_Dæk.Deal(*pSpiller);
  
  m_Dæk.Deal(m_Huset);
 }  
 //gem husets første kort
 m_Huset.VendFørsteKort();
  
 //vis alles kort
 for (pSpiller = m_Spillere.begin(); pSpiller != m_Spillere.end(); ++pSpiller)
  cout << *pSpiller << endl;
 cout << m_Huset << endl;
 
 //giv flere kort til spillere
 for( pSpiller = m_Spillere.begin(); pSpiller != m_Spillere.end();++pSpiller)
  m_Dæk.FlereKortTilSpiller(*pSpiller);
  
 //vis husets første kort
 m_Huset.VendFørsteKort();
 cout << endl << m_Huset << endl;
 
 //giv flere kort til huset
 m_Dæk.FlereKortTilSpiller(m_Huset);
 
 if(m_Huset.ErBusted())
 {
  for( pSpiller = m_Spillere.begin(); pSpiller != m_Spillere.end(); ++pSpiller)
   if (!(pSpiller->ErBusted()))
    pSpiller->Vundet();
 }
 else
 {
  for (pSpiller = m_Spillere.begin(); pSpiller != m_Spillere.end(); ++pSpiller)
   if (!(pSpiller->ErBusted()))
   {
    if (pSpiller->HentTotal() > m_Huset.HentTotal())
     pSpiller->Vundet();
    else if ( pSpiller->HentTotal() < m_Huset.HentTotal())
     pSpiller->Tabt();
    else
     pSpiller->Uafgjort();
   }
 }

//fjerner alles kort
for (pSpiller = m_Spillere.begin(); pSpiller != m_Spillere.end(); ++pSpiller)
 pSpiller->Slet();
m_Huset.Slet();
}

//funktions prototyper
ostream& operator<<(ostream& os, const Kort& etKort);
ostream& operator<<(ostream& os, const GenetiskSpiller& enGenetiskSpiller);

//main()
int main()
{
 cout << "\t\t Velkommen til Blackjack!\n\n\n";
 
 int numSpillere = 0;
 
 while( numSpillere < 1 || numSpillere > 7)
 {
  cout << "Hvor mange spillere?(1-7): ";
  cin >> numSpillere;
 }
 
 vector<string> navne;
 string navn;
 
 for (int i = 0; i < numSpillere; ++i)
 {
  cout << "Skriv spiller " << i <<"'s navn: ";
  cin >> navn;
  navne.push_back(navn);
 }
 cout << endl << endl;
 
 //the game loop
 Spillet etSpil(navne);
 char igen = 'y';
 
 while (igen != 'n' && igen!= 'N')
 {
  etSpil.Spil();
  cout << "Tak for spillet. Vil du spille igen?(Y/N): ";
  cin >> igen;
 }

return 0;
}

//overloader <<operatoren så Kort objekter kan sendes til cout
ostream& operator<<(ostream& os, const Kort& etKort)
{
 const string RANK[] = { "0", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "B", "D", "K"};
 const string KULØR[] = { "K", "R", "H", "S"};
 
 if(etKort.m_ErVendtOp)
  os << RANK[etKort.m_Rank] << KULØR[etKort.m_Kulør];
 else
 os << "XX";

return os;
}

//overloader << operatoren så GenetiskSpiller objekter kan sendes til cout
ostream& operator<<(ostream& os, const GenetiskSpiller& enGenetiskSpiller)
{
 os << enGenetiskSpiller.m_Name << ":\t";
 
 vector<Kort*>::const_iterator pKort;
 
 if(!enGenetiskSpiller.m_Kort.empty())
 {
  for (pKort = enGenetiskSpiller.m_Kort.begin(); pKort != enGenetiskSpiller.m_Kort.end(); ++pKort)
   os << *(*pKort) << "\t";
   
  if (enGenetiskSpiller.HentTotal() != 0)
   cout << "(" << enGenetiskSpiller.HentTotal() << ")";
 }
 else
 {
  os << "<empty>";
 }
return os;
} 
[/showoff] lolol, no autografx rite now plix, i ar teh w1n, and u r teh nubcake roflolmao. [/brag] thanks for your time :)*exited*

Share this post


Link to post
Share on other sites
Quote:
Original post by blueapple
Is this considered spam?


In terms of content, I don't think so -- similar posts have received good responses in the past from a variety of members. The presentation is, however, a little misguided.

Share this post


Link to post
Share on other sites
I think the post was delivered with sufficient sarcasm to fly under my spamdar [wink].

Congratulations, Mads.
Are you looking for critique, or just encouragement?

Admiral

Share this post


Link to post
Share on other sites
Grats on the game.

I didn't know the compiler could handle the letters æ, ø and å.
I don't think my Borland 3.1 compiler back in the days did.
Wonder if a non scandinavian compiler will let this pass...

Share this post


Link to post
Share on other sites
Gotta love the Slet() fuction, lol.
My Dutch comrades would probably agree.

But nice work finishing your first real game. I'm still on my way there.

Share this post


Link to post
Share on other sites
Quote:
Original post by pulpfist
Grats on the game.

I didn't know the compiler could handle the letters æ, ø and å.
I don't think my Borland 3.1 compiler back in the days did.
Wonder if a non scandinavian compiler will let this pass...

MSVC7.1 puked all over me and didn't compile it. Testing it in VC8 now... hur hur.

Whoo, compiles fine in 8. Hooray.

Share this post


Link to post
Share on other sites

This topic is 3860 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this