结对项目：SudokuGame

// Core
_declspec(dllexport) int sum(int a, int b);
_declspec(dllexport) void generate(int number, int mode, int result[][]);
_declspec(dllexport) void generate(int number, int lower, int upper, bool unique, int result[][]);
_declspec(dllexport) bool solve(int puzzle[], int solution[]);
_declspec(dllexport) void generate(int number, int result[][]);// Table
extern const unsigned int BufferSize;
class Table
{private:
int cells[][];
public:
/*
1.This class is used to generate or solve sudokus in large amount.
2.Use Generate to generate and it overrides with different destinations.Solve also overrides.
3.Solve(SdkBuffer*) will modify the input to tell you the result.If an sudoku is not solvable,it will
remain as it was.The Solve function will return the number of sudokus tha can be solved.
*/
Table();
void Generate(unsigned int total, SdkBuffer* sdb);
void GenerateRandomly(unsigned int total, SdkBuffer * sdb);
void Generate(unsigned int total, FileHandler* fh);
void GenerateRandomly(unsigned int total, FileHandler* fh);
int Solvable(SdkBuffer* sdb, int index);
unsigned int Solve(SdkBuffer* pBoard);
//Modified:Solve(SdkBuffer* src,SdkBuffer* dst)==> Solve(SdkBuffer* pBoard);
void Solve(FileHandler* src, FileHandler*dst);
void DigRandomCells(SdkBuffer* pBoards,unsigned int lower,
unsigned int upper,bool isAnswerUnique);
~Table();
private:
/*
*/
void setZero();
void digSpecNum(int[][],unsigned int num);
void digSpecNumUniquely(int[][], unsigned int num);
unsigned int startSolving(unsigned int maxAnswer,SdkBuffer*pResult);
void solve(int subt, int num,unsigned int &total,unsigned int &top,SdkBuffer* pResult);
int* lookUp(int rst, int cst, int num);
};

bool IsDiffer(int line[], int(*record)[], int nowsize)
{
for (int i = ; i < nowsize; i++)
{
bool r = true;
for (int j = ; j < ; j++)
{
r &= line[j] == record[i][j];
}
if (r)
return false;
}
return true;
}
void Shuffle(int line[], int(*record)[], int nowsize)
{
int r, mid;
do {
for (int i = ; i >= ; i--)
{
r = rand() % (i + );//0-i
mid = line[i];
line[i] = line[r];
line[r] = mid;
}
} while (!IsDiffer(line, record, nowsize));
}
void Table::GenerateRandomly(unsigned int total, SdkBuffer* sdb)
{
srand(clock());
int firstLine[] = { ,,,,,,,, };
int(*record)[] = new int[total][];
setZero();
for (unsigned int i = ; i < total; i++)
{
Shuffle(firstLine,record,i);
for (int j = ; j < ; j++)
{
cells[][j] = firstLine[j];
record[i][j] = firstLine[j];
}
startSolving(, sdb);
}
delete[] record;
}

class DifficultyEvaluation
{
public:
DifficultyEvaluation();
~DifficultyEvaluation();
Difficulty Evaluate(int p[][]);
void GetPuzzle(int p[][]);
private:
int puzzle[][];
// candidate[i][j][num]==1 means num is candidate to puzzle[i][j].
// candidate[i][j][0]==k means puzzle[i][j] has k candidates.
int candidate[][][];
// 唯余法排除：某位置出现某数，则同行/宫/列其他位置该数排除候选
void UpdateSingle();
// 宫内排除：宫内某数只出现在某行/列，则该行/列其他位置该数排除候选
void UpdateCell();
// 行/列/宫显性数对排除法：
// 行/列/宫某两个位置只出现两个相同的候选数，则若行列内则排除同行列的其余位置这两个数的候选
// 若这两个位置同宫，则还可排除宫内与两个位置同行列的其余位置这两个数的候选
void UpdateNakedPair();
// 行/列/宫隐性数对排除法：
// 某两个数只出现在某行/列/宫的两个位置，则两位置其余候选数排除
void UpdateHiddenPair();
// X-Wing排除法：
// 若某数在某两行/列中只出现在该两行/列的两个相同位置，则构成X-Wing，排除四边形边上所有位置的该数候选
void UpdateXWing(); void CandidateDelete(int row, int col, int num); void PuzzleInit(int p[][]); bool IsFinished();
void Fill(int row, int col, int num);
bool FillNakedSingle();
bool FillHiddenSingle();
bool TryToFill(int &updateCount, int &fillCount1, int &fillCount2);
};

TEST_METHOD(TestMethod5)
{
// -r 23~29 -u -n 124
int argc = ;
char *argv[] = { "sudoku.exe", "-r", "23~29", "-u" ,"-n","" };
ArgumentHandler ah;
ah.ParseInput(argc, argv);
bool r = ah.GetCount() == &
ah.GetState() == State::GEG_RU&
ah.GetLower() == &
ah.GetUpper() == &
ah.GetPathName() == NULL&
ah.GetDifficulty() == Difficulty::UNS;
Assert::AreEqual(r, true);
}

// test API generetor
TEST_METHOD(TestMethod11)
{
int p[][] = {
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, },
{ ,,,,,,,, }
};
int puzzle[];
Transform(p, puzzle);
int solution[];
bool r = solve(puzzle, solution);
r &= IsTrueAnswer(puzzle, solution);
r &= IsValid(solution);
Assert::AreEqual(r, true);
}

TEST_METHOD(TestMethod13)
{
int size = ;
int(*result)[] = new int[size][];
generate(size, result);
bool r = IsDiffer(result, size);
for (int i = ; i < size; i++)
r &= IsValid(result[i]);
delete[] result;
Assert::AreEqual(r, true);
}
TEST_METHOD(Test14)
{
// -n 100 -r 23~29
int size = ;
int(*result)[] = new int[size][];
generate(size, , , false, result);
bool r = IsInRange(, , result, size);
int solution[];
for (int i = ; i < size; i++)
{
r &= solve(result[i], solution);
r &= IsValid(solution);
}
Assert::AreEqual(r, true);
}

TEST_METHOD(Test15)
{
// -n 100 -r 40~50 -u
int size = ;
int(*result)[] = new int[size][];
generate(size, , , true, result);
bool r = IsInRange(, , result, size);
int solution[];
for (int i = ; i < size; i++)
{
r &= solve(result[i], solution);
r &= IsValid(solution);
}
Table table;
for (int k = ; k < size; k++)
{
for (int i = ; i < ; i++)
{
table.cells[i / ][i % ] = result[k][i];
}
r &= table.startSolving(, NULL) == ;
} Assert::AreEqual(r, true);
}

void ArgumentHandler::ParseInput(int argc, char** args)
{
if (argc < )
{
cout << "The number of arguments is not correct!" << endl;
return;
}
if (strcmp(args[], "-c") == )
{
state = State::GEN;
try
{
if (argc != )
{
throw invalid_argument("Argument \"-c\" shouldn't be used with other arguments!");
}
else if (!IsDigit(args[]))
{
throw invalid_argument("The argument of \"-c\" should be a positive integer!");
}
sscanf_s(args[], "%d", &count);
if (count > maxCounts||count<=)
{
throw invalid_argument("The argument of \"-c\" should be in range [1,1000000]!");
}
}
catch (invalid_argument err)
{
state = State::INV;
cout << err.what() << endl;
}
}
else if (strcmp(args[], "-s") == )
{
state = State::SOV;
try
{
if (argc != )
{
throw invalid_argument("Argument \"-s\" shouldn't be used with other arguments!");
}
pathname = args[];
}
catch (invalid_argument err)
{
state = State::INV;
cout << err.what() << endl;
}
}
else
{
state = GEG_M;
int nUsed = ;
int mUsed = ;
int rUsed = ;
int uUsed = ;
for (int i = ; i < argc; ++i)
{
if (strcmp(args[i], "-n") == )
{
nUsed++;
try
{
if (i + == argc)
{
throw invalid_argument("Required argument of \"-n\" missing!");
}
if (!IsDigit(args[i + ]))
{
throw invalid_argument("The argument of \"-n\" should be a positive integer!");
}
sscanf_s(args[i + ], "%d", &count);
if (count > maxN||count<=)//test int.max+1 {
throw invalid_argument("The argument of \"-n\" should be in range [1,10000]!");
}
i++;
}
catch (invalid_argument err)
{
cout << err.what() << endl;
state = State::INV;
break;
}
}
else if (strcmp(args[i], "-m") == )
{
mUsed++;
try
{
if (i + == argc)
{
throw invalid_argument("Required argument of \"-m\" missing!");
}
if (args[i+][]!='\0')
{
throw invalid_argument("The argument of \"-m\" should be only a digit!");
}
switch (args[i + ][])
{
case '':
difc = Difficulty::EASY;
break;
case '':
difc = Difficulty::NORMAL;
break;
case '':
difc = Difficulty::HARD;
break;
default:
throw invalid_argument("The argument of \"-m\" should be only 1, 2 or 3!");
break;
}
i++;
}
catch (invalid_argument err)
{
cout << err.what() << endl;
state = State::INV;
break;
}
}
else if (strcmp(args[i], "-u") == )
{
uUsed++;
unique = true;
}
else if (strcmp(args[i], "-r") == )
{
rUsed++;
try
{
if (i + == argc)
{
throw invalid_argument("Required argument of \"-r\" missing!");
}
if (!JudgeR(args[i + ]) || (sscanf_s(args[i + ], "%d~%d", &lower, &upper) != ))
{
throw invalid_argument("The argument of \"-r\" should be in format: \
lower~upper, and lower/upper must be a positive integer!");
}
if (lower < minR || lower > maxR || upper < minR || upper > maxR || lower > upper)
{
throw invalid_argument("The two arguments of \"-r\" should be in range [20, 55]\
, and the first number must be no more than the second number!");
}
i++;
}
catch (invalid_argument err)
{
cout << err.what() << endl;
state = State::INV;
break;
}
}
else
{
state = State::INV;
cout << "We only support the arguments as follows: -c, -s, -n, -r, -m, -u! And -c/-s can only be used alone!" << endl;
break;
}
}
if (state == State::GEG_M)
{
if (nUsed > || uUsed > || mUsed > || rUsed > )
{
cout << "Every argument should be used only once!" << endl;
state = State::INV;
}
else if (mUsed&rUsed || mUsed&uUsed)
{
cout << "Argument -m shouldn't be used with -r or -u!" << endl;
state = State::INV;
}
else if (!nUsed || (nUsed & !mUsed & !rUsed & !uUsed))
{
cout << "Argument -n must be used at least once, and it should be used together with -m/-r/-u!" << endl;
state = State::INV;
}
else if(rUsed> && uUsed>)
{
state = GEG_RU;
}
else if (rUsed > )
{
state = GEG_R;
}
else if (uUsed > )
{
state = GEG_U;
}
} }
}

void generate(int number, int lower, int upper, bool unique, int result[][])
{
if (number < )
{
throw invalid_argument("The argument of \"-n\" shouldn`t be less than zero");
}
else if (number > gMaxGenRanAmount)
{
throw invalid_argument("The argument of \"-n\" shouldn`t be bigger than 10000");
}
else if (lower < gGenRangeLower || lower >gGenRangeUpper ||
upper < gGenRangeLower || upper >gGenRangeUpper)
{
throw invalid_argument("The argument of \"-r\" should be in the range of [20,55]");
}
else if (lower > upper)
{
throw invalid_argument("The argument of \"-r\" should be like lower~upper.");
}
else if (result == NULL)
{
throw invalid_argument("The argument of result shouldn`t be NULL");
}
////////////////////////////后面省略
}

void GameScene::NumbutCallBack(Ref* pSender, Control::EventType type)
{
if (selected != - && !ShareGlobal()->grid[selected / ][selected % ].isGiven)
{
int i;
for (i = ; i < ; i++)
{
ControlButton* t = (ControlButton*)this->getChildByTag( + i);
if (t == pSender)
break;
}
Label* grid = (Label*)this->getChildByTag( + selected);
grid->setString(std::string(, char('' + i + )));
ShareGlobal()->grid[selected / ][selected % ].num = i + ;
// 若上次改变了颜色，则恢复之
if (lastCheck != -)
{
if (lastCheck < )
{
// 行恢复
for (int i = ; i < ; i++)
{
Sprite* s = (Sprite*)this->getChildByTag( + * lastCheck + i);
int isGiven = ShareGlobal()->grid[lastCheck][i].isGiven;
if (isGiven)
s->setColor(Color3B(, , ));
else
s->setColor(Color3B(, , ));
}
// 恢复后重置lastcheck
lastCheck = -;
}
else if (lastCheck < )
{
// 列恢复
lastCheck -= ;
for (int i = ; i < ; i++)
{
Sprite* s = (Sprite*)this->getChildByTag( + * i + lastCheck);
int isGiven = ShareGlobal()->grid[i][lastCheck].isGiven;
if (isGiven)
s->setColor(Color3B(, , ));
else
s->setColor(Color3B(, , ));
}
// 恢复后重置lastcheck
lastCheck = -;
}
else
{
// 宫恢复
lastCheck -= ;
int rs = * (lastCheck / );
int cs = * (lastCheck % );
for (int i = rs; i < rs + ; i++)
{
for (int j = cs; j < cs + ; j++)
{
Sprite* s = (Sprite*)this->getChildByTag( + * i + j);
int isGiven = ShareGlobal()->grid[i][j].isGiven;
if (isGiven)
s->setColor(Color3B(, , ));
else
s->setColor(Color3B(, , ));
}
}
// 恢复后重置lastcheck
lastCheck = -;
}
}
// 检测是否又不符合数独规则的行列宫，改变相应子结构的颜色
// 只改变第一个发现的子结构，待用户解决后，才会提示另外的错误
int line = ShareGlobal()->CheckLine();
int column = ShareGlobal()->CheckColumn();
int cell = ShareGlobal()->CheckCell();
if (line != -)
{
for (int i = ; i < ; i++)
{
Sprite* s = (Sprite*)this->getChildByTag( + * line + i);
s->setColor(Color3B(, , ));
}
lastCheck = line;
}
else if (column != -)
{
for (int i = ; i < ; i++)
{
Sprite* s = (Sprite*)this->getChildByTag( + * i + column);
s->setColor(Color3B(, , ));
}
lastCheck = + column;
}
else if (cell != -)
{
int rs = * (cell / );
int cs = * (cell % );
for (int i = rs; i < rs + ; i++)
{
for (int j = cs; j < cs + ; j++)
{
Sprite* s = (Sprite*)this->getChildByTag( + * i + j);
s->setColor(Color3B(, , ));
}
}
lastCheck = + cell;
}
// 如果上面的没有问题并且用户填完了,弹出对话框示意结束
else if (ShareGlobal()->IsFinished())
{
// 获取屏幕宽度和高度
auto visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
// 设置对话框颜色，位置，透明度
Director::getInstance()->getEventDispatcher()->pauseEventListenersForTarget(this, true);
auto colorLay = LayerColor::create(Color4B(, , , ));
colorLay->ignoreAnchorPointForPosition(false);
colorLay->setAnchorPoint(Vec2(0.5, 0.5));
colorLay->changeHeight(visibleSize.height / );
colorLay->changeWidth(visibleSize.width / );
colorLay->setPosition(Vec2(origin.x + visibleSize.width / , origin.y + visibleSize.height / ));
this->addChild(colorLay, );
// 显示文本
auto label = Label::createWithTTF("Congratulations!", "fonts/Marker Felt.ttf", );
label->setPosition(Vec2(origin.x + visibleSize.width / , origin.y + visibleSize.height / +));
label->setColor(Color3B(, , ));
colorLay->addChild(label, );
// 用时
std::string stime("You cost ");
char ctime[];
itoa(time, ctime, );
stime += ctime;
stime += " s";
auto tlabel = Label::createWithTTF(stime.c_str(), "fonts/Marker Felt.ttf", );
tlabel->setPosition(Vec2(origin.x + visibleSize.width / , origin.y + visibleSize.height / -));
tlabel->setColor(Color3B(, , ));
colorLay->addChild(tlabel, );
// 记录最佳时间
if (ShareGlobal()->degree == && (ShareGlobal()->bestRecordEasy > time || ShareGlobal()->bestRecordEasy == -))
{
// 如果没有记录或是好于最佳记录
CCUserDefault::sharedUserDefault()->setIntegerForKey("bestRecordEasy", time);
}
if (ShareGlobal()->degree == && (ShareGlobal()->bestRecordMedium > time || ShareGlobal()->bestRecordMedium == -))
{
// 如果没有记录或是好于最佳记录
CCUserDefault::sharedUserDefault()->setIntegerForKey("bestRecordMedium", time);
}
if (ShareGlobal()->degree == && (ShareGlobal()->bestRecordHard > time || ShareGlobal()->bestRecordHard == -))
{
// 如果没有记录或是好于最佳记录
CCUserDefault::sharedUserDefault()->setIntegerForKey("bestRecordHard", time);
}
// 返回主菜单的按钮
auto closeLabel = Label::createWithTTF("Exit", "fonts/Marker Felt.ttf", );
closeLabel->setColor(Color3B(, , ));
auto closeItem = MenuItemLabel::create(closeLabel, [=](Ref* pSender)
{// 销毁图层，恢复监听，返回主菜单
colorLay->removeFromParent();
Director::getInstance()->getEventDispatcher()->resumeEventListenersForTarget(this, true);
auto scene = HelloWorld::createScene();
Director::getInstance()->replaceScene(TransitionCrossFade::create(0.4, scene));
});
closeItem->setPosition(Vec2(origin.x + visibleSize.width / , origin.y + visibleSize.height / - ));
auto menu = Menu::create(closeItem, NULL);
menu->setPosition(Vec2::ZERO);
colorLay->addChild(menu, );
}
}
}

static Global* m_global = NULL;
Global* ShareGlobal()
{
if (m_global == NULL)
{
m_global = new Global();
}
return m_global;
}

class Global
{
public:
Global();
~Global();
typedef struct table
{
int num;
bool isGiven;
}Table;
Table grid[][];
bool Check();
bool IsFinished();
int degree;
void GenerateGame();
// 返回 -1 表示没有发现错误，返回 0-8 表示某行列宫存在错误
int CheckLine();
int CheckColumn();
int CheckCell();
// 初始化时记录时间
int time;
// 最佳记录
int bestRecordEasy;
int bestRecordMedium;
int bestRecordHard;
// 生成当前数独的解，用于提示功能
void GenerateSolution();
int solution[][];};

void Global::GenerateGame()
{
int result[][];
generate(, degree, result);
for (int i = ; i < ; i++)
{
grid[i / ][i % ].num = result[][i];
grid[i / ][i % ].isGiven = result[][i] != ? true : false;
}
}
void Global::GenerateSolution()
{
int puzzle[];
int result[];
for (int i = ; i < ; i++)
{
puzzle[i] = grid[i / ][i % ].num;
}
solve(puzzle, result);
for (int i = ; i < ; i++)
{
solution[i / ][i % ] = result[i];
}
}