tsixmine.cpp

自己用C编写的小游戏

#ifndef  __BenBear_SixMine_TMine_cpp
#define  __BenBear_SixMine_TMine_cpp

#include <vector>
#include <cstdlib>
#include <ctime>
using namespace std;
#include "HoneyHole.h"

const int dDefaultFloor = 5;
const double dlDefaultRotia = 0.2;

enum TState { hsCover, hsOpen, hsMark, hsError };
enum TValue { hv0 = 0, hv1 = 1, hv2 = 2,
              hv3 = 3, hv4 = 4, hv5 = 5,
              hv6 = 6, hvMine = 7
            };
//enum TReturn   { hrOK, hrNull, hrWin, hrDie };
typedef  int  TReturn;
const int  hrOK=0,hrNull=1,hrWin=2,hrDie=3;
struct TMineHole
{
  TValue v;
  TState s;
};
const TMineHole MineHoleEmpty = { hv0, hsCover };

//////////////////////////////////////////////////
//        the prototype of TSixMine
//////////////////////////////////////////////////
struct TSixMine
{
  vector<TMineHole>  holes;
  CHoneyHole pos;
  int floor, hole, mine;
  int left_mine, open_hole;

  TReturn set( int  dFloor = dDefaultFloor,
               double  dlRotia = dlDefaultRotia );
  TReturn set( int  dFloor, int  dMine );

  TReturn win();
  TReturn die();

  TReturn reset();
  TReturn lay  ()  {  return  lay(hole);  }
  TReturn lay  ( CHoneyHole  p );
  
  TReturn move( int  dDirection );
  
  TReturn dig     ( CHoneyHole  p );
  TReturn wide_dig( CHoneyHole  p );
  TReturn mark    ( CHoneyHole  p );
  TReturn dig()       {  return  dig( pos );  }
  TReturn wide_dig()  {  return  wide_dig( pos );  }
  TReturn mark()      {  return  mark( pos );  }
  
public:
  // constructor, destructor define
  TSixMine( int dFloor = dDefaultFloor, double dlRotia = dlDefaultRotia )
  {
    set( dFloor, dlRotia );
    reset();
  }
  
  ~TSixMine() {}
};

//////////////////////////////////////////////////
//       the implemetation of TSixMine
//////////////////////////////////////////////////

/******************** die() *********************/
TReturn TSixMine::die()
{
  int i;
  for( i = 0; i < hole; i++ )
    if( holes[ i ].v != hvMine && holes[ i ].s == hsMark )
      holes[i].s = hsError;
  pos = hole;
  return hrDie;
}

/******************** dig() *********************/
TReturn TSixMine::dig( CHoneyHole p )
{
  if( p >= hole )
    return hrNull;
  if( holes[ p ].s != hsCover )
    return hrNull;

  if( holes[ p ].v == hvMine )
  {
    holes[ p ].s = hsError;
    return die();
  }

  holes[ p ].s = hsOpen;
  open_hole++;
  if( open_hole + mine == hole )
  {
//    return win();
    win();
    return  hrWin;
  }

  if( holes[ p ].v == hv0 )
  {
    CHoneyHole h;
    int i;
    TReturn re;
    for( i = 0; i < 6; i++ )
    {
      h = p;
      h.move( i );
      if( h >= hole )
        continue;
      re = dig( h );
      if( re == hrWin )
        return re;
    }
  }
  return hrOK;
}

/********************* lay() ********************/
TReturn TSixMine::lay( CHoneyHole  p )
{
  int i, d;
  int r;
  CHoneyHole h;

  srand( time(0) );
  for( i = 0; i < hole; i++ )
    holes[i] = MineHoleEmpty;

  for( i = 0; i < mine; i++ )
  {
    do
    {
      r = rand()%hole;
    }
    while( holes[r].v == hvMine || r == p );

    holes[r].v = hvMine;
    for( d = 0; d < 6; d++ )
    {
      h = r;
      h.move( d );
      if(( h >= hole ) || ( holes[h].v == hvMine ))
        continue;
      holes[h].v = static_cast<TValue>(holes[h].v + 1);
    }
  }
  return hrOK;
}

/******************** mark() *******************/
TReturn TSixMine::mark( CHoneyHole  p )
{
  if( ( holes[ p ].s == hsOpen )
      || ( holes[ p ].s == hsCover && left_mine <= 0 ) )
    return hrNull;

  if( holes[ p ].s == hsCover )
  {
    holes[ p ].s = hsMark;
    left_mine--;
  }
  else
  {
    holes[ p ].s = hsCover;
    left_mine++;
  }
  return hrOK;
}

/******************** move() ********************/
TReturn TSixMine::move( int dDirection )
{
  CHoneyHole h = pos;
  h.move( dDirection );
  if( h >= hole )
    return hrNull;
  
  pos = h;
  
  return hrOK;
}

/******************** reset() *******************/
TReturn TSixMine::reset()
{
  left_mine = mine;
  open_hole = 0;
  pos = 0;
  lay();

  return hrOK;
}

/********************* set() ********************/
TReturn TSixMine::set( int dFloor, double dlRotia )
{
  if( dFloor < 1 )
    dFloor = dDefaultFloor;
  if( dlRotia < 0.0 || dlRotia > 1.0 )
    dlRotia = dlDefaultRotia;
  
  floor = dFloor;
  hole = floor * ( floor + 1 ) * 3 + 1;
  mine = static_cast <int> ( hole * dlRotia );
  
  if( holes.size() < hole )
    holes.resize( hole );
  reset();
  return hrOK;
}

/****************** set_mine() ******************/
TReturn TSixMine::set( int  dFloor, int  dMine )
{
  if( dFloor < 1 )
    dFloor = dDefaultFloor;
  
  floor = dFloor;
  hole = floor * ( floor + 1 ) * 3 + 1;
  
  if( dMine < 1 || dMine >= hole )
    dMine = static_cast<int>(hole*dlDefaultRotia);
  
  mine = dMine;
  
  if( holes.size() < hole )
    holes.resize( hole );
  
  return  hrOK;
}

/****************** wide_dig() ******************/
TReturn TSixMine::wide_dig( CHoneyHole  p )
{
  if( holes[ p ].s != hsOpen )
    return hrNull;
  int i, s=0, d=0, t=0;
  CHoneyHole h;
  for( i = 0; i < 6; i++ )
  {
    h = p;
    h.move( i );
    if( h >= hole )
      continue;
    t++;
    if( holes[ h ].s == hsMark )
      s++;
    if( holes[ h ].s == hsOpen )
      d++;
  }
  if(( s != holes[ p ].v )&&( d != t - holes[ p ].v ))
    return hrNull;
  TReturn re;
  if( s == holes[ p ].v )
    for( i = 0; i < 6; i++ )
    {
      h = p;
      h.move( i );
      if( h > hole )
        continue;
      if( holes[ h ].s == hsMark )
        continue;
      re = dig( h );
      if( re == hrWin || re == hrDie )
        return re;
    }
  else
  {
    CHoneyHole h2 = p;
    for( i = 0; i < 6; i++ )
    {
      p = h2;
      p.move( i );
      if( p > hole )
        continue;
      if( holes[ p ].s != hsCover )
        continue;
      mark(p);
    }
    p = h2;
  }
  return hrOK;
}

/******************** win() *********************/
TReturn TSixMine::win()
{
  int i;
  for( i = 0; i < hole; i++ )
    if( holes[ i ].v == hvMine )
      holes[ i ].s == hsMark;
  pos = hole;
  return  hrWin;
}

#endif