Пример #1
0
KrecikApp::Result KrecikApp::run()
{
    init();

    all.restart();
    lastTouch.restart();
    running = true;
    while(running)
    {
        win.clear();
        events();
        update();
        if(isWin() || isLose())
            running = false;
        display();
    }
    running = false;

    Result r;
    r.pts = pts;
    r.distance = getCarPos().x;
    r.time = all.getElapsedTime();
    r.win = isWin();
    return r;
}
Пример #2
0
bool GameScene::isGameOver() {
    if (isWin()) {
        return false;
    }

    if (mIsGameOver) {
        return true;
    }

    // do the check
    mIsGameOver = true;
    for (int y = 0; y < 4; ++y) {
        for (int x = 0; x < 4; ++x) {
            if (mCards[x][y]->getNumber() == 0
                || (x < 3 && mCards[x][y]->getNumber() == mCards[x + 1][y]->getNumber())
                || (x > 0 && mCards[x][y]->getNumber() == mCards[x - 1][y]->getNumber())
                || (y < 3 && mCards[x][y]->getNumber() == mCards[x][y + 1]->getNumber())
                || (y > 0 && mCards[x][y]->getNumber() == mCards[x][y - 1]->getNumber())) {
                mIsGameOver = false;
                break;
            }
        }
    }
    return mIsGameOver;
}
Пример #3
0
Файл: rand1.c Проект: cp3/cp3
/******************************************************************************\
* main                                                                         *
\******************************************************************************/
int main(void)
{
	int col;
	char p;
	struct timeval tv;

	gettimeofday(&tv, NULL);
	srandom(getpid() ^ ~getuid() ^ tv.tv_sec ^ tv.tv_usec);

	readboard();

	do
		col = random() % columns;
	while (board[col * rows + rows - 1] != 's');

	if (random() % 8)
		p = 'b';
	else
		p = 'g';

	printBoard(board);
	isWin(board);

	freeboard();

	printf("(%d,%c)", col+1, p);

	return 0;
} /* main */
Пример #4
0
void MiniMax::minimize(tree& state, int depth, int alpha, int beta) {

    /* Their turn:
     * Find the worst (for us, best for opponent) move from here and take its
     * score for the current state
     */

    scoreState(state);
    if (isWin(state.score)) {
        return;
    }
    if (boardFull(state)) {
        state.score = 0;
        return;
    }

    if (depth <= 0) {       // Base case.  Run the heuristic.
        return;
    }

    // Recursive case.  Take the min of the maxes.
    int v = std::numeric_limits<int>::max();
    size_t numChildren = state.children.size();
    for (size_t i = 0; i < numChildren; ++i) {
        try {
            state.children[i] = makeMove(state, i, false);
        } catch (const std::runtime_error&) {
            continue;
        }
        state.children[i].move = i;
        maximize(state.children[i], --depth, alpha, beta);
        //favor moves in the middle
        if (i == state.children.size() / 2 && !isWin(state.children[i].score)) {
            --state.children[i].score;
        }
        v = std::min(v, state.children[i].score);
        if (v <= alpha) {   // ***PRUNE***
            state.score = v;
            return;
        }
        beta = std::min(beta, v);
    }
    // We didn't prune.
    state.score = v;

}
Пример #5
0
void GameScene::doCheck()
{
    bool isGameOver = true;
    
    //结束边界  4*4的card数值>0 且  相邻card没有相同数值
    //4*4的card数值>0 不能在创建Number
    //判断每一个的上下左右和自己是否相同
    for (int y = 0; y < 4; y++)
    {
        for (int x = 0; x < 4; x++)
        {
            if (cardArr[x][y]->getNumber() == 0 ||
                (x<3 && cardArr[x][y]->getNumber() == cardArr[x+1][y]->getNumber()) ||
                (x>0 && cardArr[x][y]->getNumber() == cardArr[x-1][y]->getNumber()) ||
                (y<3 && cardArr[x][y]->getNumber() == cardArr[x][y+1]->getNumber()) ||
                (y>0 && cardArr[x][y]->getNumber() == cardArr[x][y-1]->getNumber()) )
            {
                isGameOver = false;
            }
        }
    }
    if (isWin()) {
        
        successLayer = LayerColor::create(Color4B(0, 0, 0, 180));
        Size winSize = Director::getInstance()->getWinSize();
        Point centerPos = Point(winSize.width / 2, winSize.height / 2);
        auto gameOverTitle = Label::createWithSystemFont("YOU WIN","Consolas",80);
        gameOverTitle->setPosition(centerPos);
        successLayer->addChild(gameOverTitle);
        
        getParent()->addChild(successLayer,1);
        
        scheduleOnce(SEL_SCHEDULE(&GameScene::removeSuccessLayer), 2);
        return;
    }
    
    //isGameOver = true;
    if (isGameOver)
    {
        log("game over");
        UserDefault::getInstance()->setBoolForKey("history", false);
        
        HighScore::getInstance()->setScore(score);
        GameOverLayer *gameoverLayer = GameOverLayer::create(Color4B(0, 0, 0, 180));
        getParent()->addChild(gameoverLayer,1);
        
        Director::getInstance()->pause();
    }
    else
    {
        if (shouldCreateCardNumber()) {
            createCardNumber();
            
            saveStatus();
        }
    }
}
Пример #6
0
int main()
{
#ifdef debug
    printf("%X %X\n",&player,main);
#endif
	do
	{
		printf("请选择走棋次序。\n输入1先走,或者-1后走。");
		scanf("%d",&player);
	}
	while(player!=1&&player!=-1);	
	int pl;                      //落子位置
	DrawField();
	int i;
	for(i=1;i<=9;i++)
	{
		if(isWin())break;
		if(player==1)
		{
			printf("请输入落子位置:");
			scanf("%d",&pl);
			if(pl>9||pl<1||field[pl]!=0)
			{
				printf("输入错误,无此格子或格内已有子\n请重新输入:");
				i--;
				DrawField();
				continue;
			}
			else
			{
				field[pl]=player;
				
				player=-player;
				if(isWin())break;
			}
		}
		else AI();
	}
	if(i>=9)printf("平局\n");
	else printf("赢家是%d\n",sym(-player));
	getchar();getchar();                       //延迟窗口关闭 
	return 0;
}
Пример #7
0
void PorkSendPage::on_PromptButton_clicked()
{
    if(!isStart)
        return;

    for(int i = 1; i < map_row - 1; i++)
    {
        for(int j = 1; j < map_col - 1; j++)
        {
            for(int x = 1; x < map_row - 1; x++)
            {
                for(int y = 1; y < map_col - 1; y++)
                {
                    if(i == j&&x == y)
                    {
                        continue;
                    }

                    if(arr_map[i][x] == EMPTY)
                    {
                        continue;
                    }

                    if(arr_map[j][y] == EMPTY)
                    {
                        continue;
                    }


                    if(arr_map[i][x] != arr_map[j][y])
                    {
                         continue;
                    }

                    if(isWin(i,j,x,y))
                    {
                        rects.clear();
                        rects.push_back(QPoint(PHWIDTH * x,PHHEIGHT *i));
                        rects.push_back(QPoint(PHWIDTH * y,PHHEIGHT * j));

                        update();
                        QEventLoop loop;
                        QTimer::singleShot(300, &loop, SLOT(quit()));
                        loop.exec();

                        rects.clear();
                        lines.clear();
                        update();  return true;
                    }
                }
            }
        }
    }
}
Пример #8
0
void MyGame::move(int i,int j,bool click){
    if(!click){
    if(actUserField[i][j]==0)actUserField[i][j]=1;
    if(field[i][j]==-1&&actUserField[i][j]!=2){
        emit gameOver(false);
        boom();
    }
    else if(field[i][j]==0&&actUserField[i][j]!=2){
        expand(i,j);
        if(isWin()){

            emit gameOver(true);
            boom();
        }
    }
    else{
        if(isWin()&&actUserField[i][j]!=2){

            emit gameOver(true);
            boom();
        }
    }
    }
    else{
        if(actUserField[i][j]!=1&&actUserField[i][j]!=2){

            actUserField[i][j]=2;
            counting--;
            emit changeBomb(counting);
        }
        else if(actUserField[i][j]==2){

            actUserField[i][j]=0;
            counting++;
            emit changeBomb(counting);
        }
    }

}
Пример #9
0
void AI()
{
	for(int j=1;j<=9;j++)
	{
		if(field[j]==0)
		{
			field[j]=player;
			if(isWin())goto finish;
			field[j]=0;
		}
	}
	for(int j=1;j<=9;j++)
	{
		if(field[j]==0)
		{
			field[j]=-player;
			if(isWin()){field[j]=player;goto finish;}
			field[j]=0;
		}
	}
	if(field[5]==0){field[5]=player;goto finish;}
	// the next can be inprove
	if((field[1]!=0||field[9]!=0)&&field[3]==0){field[3]=player;goto finish;}
	if(field[3]!=0&&field[9]==0){field[9]=player;goto finish;}
	if(field[7]!=0&&field[1]==0){field[1]=player;goto finish;}
	if(field[2]!=0&&field[4]==0){field[4]=player;goto finish;}
	if(field[4]!=0&&field[2]==0){field[2]=player;goto finish;}
	if(field[8]!=0&&field[4]==0){field[4]=player;goto finish;}
	if(field[6]!=0&&field[8]==0){field[8]=player;goto finish;}
	for(int q=1;q<=9;q++)
	{
		if(field[q]==0)
		  {
		    field[q]=player;break;
		  }
	}
	finish:player=-player;DrawField();
}
Пример #10
0
//采用博弈树来分析
//调用c语言
void AiGame::ComMoveChess()
{
    if(!win){
     QPoint whiteGo;//电脑的颜色

     int x,y;
     int level = 2;
     x = 0;
     y = 0;
     int flag = 1;
     if(clickcount == 1){ //电脑第一次落子
         while(flag){
           int  flag_randomPick = qrand()%7;
            FindFirstChess(&x,&y,chess,flag_randomPick);
        if(Position(x,y,chess) == 0) //直到落子合法才使flag=0退出循环
            flag = 0;
         }
     }
     else{
         switch(level){ //因为level是采用下拉框,所以不用做异值判断
            case 1:{
                    robot_level1(level,&x,&y,chess);//只会防守
                    break;
                }
            case 2:{
                    robot_level2(level,&x,&y,chess);//会适当进攻
                    break;
                }
            case 3:{
                    //todo
                    //采用棋谱
                    break;
               }
         }
     }
     clickcount++;
    movechess(x,y);
    win = isWin(x,y);
        if(win)
        {
            QMessageBox::information(this, "RobotWin", "RobotWin", QMessageBox::Ok);
            qDebug()<<"win";
        }
    }
    else
    {
        QMessageBox::information(this, "YouWin", "YouWin", QMessageBox::Ok);
        qDebug()<<"win";
    }
 }
 bool validTicTacToe(vector<string>& board) {
     const auto FIRST = 'X', SECOND = 'O';
     const auto x_count =
         accumulate(board.cbegin(), board.cend(), 0,
                    [&FIRST](int accu, const string& s) {
                        return accu + count(s.cbegin(), s.cend(), FIRST);
                    });
     const auto o_count =
         accumulate(board.cbegin(), board.cend(), 0,
                    [&SECOND](int accu, const string& s) {
                        return accu + count(s.cbegin(), s.cend(), SECOND);
                    });
     if (o_count != x_count - 1 && o_count != x_count) {
         return false;
     }
     if (isWin(board, FIRST) && o_count != x_count - 1) {
         return false;
     }
     if (isWin(board, SECOND) && o_count != x_count) {
         return false;
     }
     return true;
 }
Пример #12
0
bool GameScene::checkWin() {
    if (isWin()) {
        updateBestScore();

        const Point& visibleOrigin = Director::getInstance()->getVisibleOrigin();
        const Size& visibleSize = Director::getInstance()->getVisibleSize();
        const Point& center = Point(visibleOrigin.x + visibleSize.width / 2.0f,
                                    visibleOrigin.y + visibleSize.height / 2.0f);

        auto sucessLayer = LayerColor::create(Color4B(0, 0, 0, 220));

        auto winGameLabel =
                Label::createWithSystemFont("YOU WIN", "Consolas", 100);
        winGameLabel->setPosition(Point(center.x, center.y + 180));
        sucessLayer->addChild(winGameLabel);

        char score[64];
        sprintf(score, "SCORE %d", mScore);
        auto bestScoreLabel = Label::createWithSystemFont(score, "Consolas", 80);
        bestScoreLabel->setColor(Color3B(128, 0, 128));
        bestScoreLabel->setPosition(Point(center.x, center.y + 20.0f));
        sucessLayer->addChild(bestScoreLabel);

        sprintf(score, "BEST  %d", mBestScoreCache);
        auto scoreLabel = Label::createWithSystemFont(score, "Consolas", 80);
        scoreLabel->setColor(Color3B(80, 160, 100));
        scoreLabel->setPosition(Point(center.x, center.y - 100.0f));
        sucessLayer->addChild(scoreLabel);

        getParent()->addChild(sucessLayer, 1);

        // setup touch event listener for sucessLayer, it swallows all touch events
        auto touchListener = EventListenerTouchOneByOne::create();
        touchListener->setSwallowTouches(true);
        touchListener->onTouchBegan =
                [](Touch* touch, Event* event) -> bool { return true; };
        touchListener->onTouchMoved = [] (Touch* touch, Event* event) {};
        touchListener->onTouchCancelled = [] (Touch* touch, Event* event) {};
        touchListener->onTouchEnded =
                [sucessLayer] (Touch* touch, Event* event) {
                    sucessLayer->removeFromParent();
                };
        Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(
                touchListener, sucessLayer);

        return true;
    }

    return false;
}
void MainWindow::openover(){
    if (isWin()==1){
        isGameRun=0;
        windlg->setStyleSheet("QWidget {  background-color: brown;border-style: outset; border-width: 2px;border-radius: 10px;border-color: beige;font: bold 14px;min-width: 10em;padding: 6px; }");
        windlg->setModal(true);
        windlg->show();

    }
    if (gameScore==0)
    {isGameRun=0;
        losedlg->setStyleSheet("QWidget {  background-color: brown;border-style: outset; border-width: 2px;border-radius: 10px;border-color: beige;font: bold 14px;min-width: 10em;padding: 6px; }");
        losedlg->setModal(true);
        losedlg->show();
    }
}
Пример #14
0
void GameScene::onTouchEnded(Touch* touch, Event* event) {
    if (isWin() || isGameOver()) {
        return;
    }

    GestureDetector::GestureType gesture = mGestureDetector.endPoint(touch->getLocation());
    bool gestureValid = true;
    bool moved = false;
    switch (gesture) {
    case GestureDetector::MoveLeft:
        moved = moveLeft();
        break;
    case GestureDetector::MoveRight:
        moved = moveRight();
        break;
    case GestureDetector::MoveUp:
        moved = moveUp();
        break;
    case GestureDetector::MoveDown:
        moved = moveDown();
        break;
    case GestureDetector::Unknown:
    default:
        gestureValid = false;
        break;
    }

    if (gestureValid) {
        if (moved) {
            generateCard(true);
            CocosDenshion::SimpleAudioEngine::getInstance()->playEffect(
                    MOVE_SUCESS_SOUND, false);
        } else {
            CocosDenshion::SimpleAudioEngine::getInstance()->playEffect(
                    MOVE_FAILED_SOUND, false);
        }
        doCheck();
    }
}
Пример #15
0
void AiGame::mousePressEvent(QMouseEvent *event){
    int x;
    int y;
  if(event->button() == Qt::LeftButton){
    offset = event->pos();//获取鼠标的坐标
            //棋盘区域
            if(!win && offset.rx()>186&&offset.rx()<600&&offset.ry()>39&&offset.ry()<445)
            {
                    if(chess[(offset.rx()-210)/27][(offset.ry()-60)/27])//如果鼠标点击的地方有旗子
                        return;
                    x = (offset.rx()-210)/27;
                    y = (offset.ry()-60)/27;
                    if (offset.ry() > 415 && !chess[x][14])//补偿最后一格的误差
                        y = 14;

                    clickcount++;//记录步数

                    movechess(x,y);
                    win = isWin(x,y);
                    ComMoveChess();
                }
        }

};
Пример #16
0
void GameBattle::update()
{
	switch (state_) {
	case kStateStart:
		stateCounter_++;
		if (stateCounter_ > 60) {
			setState(firstAttack_? kStateFirstAttack : kStateMenu);
		}
		break;
	case kStateFirstAttack:
		stateCounter_++;
		if (stateCounter_ > 60) {
			setState(kStateMenu);
		}
		break;
	case kStateMenu:
		if (menu_.decided()) {
			switch (menu_.partyCommand()) {
			case GameBattleMenu::kPartyCommandManual:
				setState(kStateAnimation);
				break;
			case GameBattleMenu::kPartyCommandAuto:
				for (uint i = 0; i < players_.size(); i++) {
					players_[i]->setAttackInfoAuto(enemies_, players_, turnNum_);
				}
				setState(kStateAnimation);
				break;
			case GameBattleMenu::kPartyCommandEscape:
				setState(kStateEscape);
				break;
			}
			turnNum_++;
		}
		break;
	case kStateEscape:
		stateCounter_++;
		if (stateCounter_ > 60) {
			if (escapeSuccess_) {
				setState(kStateEnd);
			} else {
				for (uint i = 0; i < players_.size(); i++) {
					AttackInfo info;
					info.target = NULL;
					info.type = kAttackTypeNone;
					info.id = 0;
					players_[i]->setAttackInfo(info);
				}
				setState(kStateAnimation);
			}
		}
		break;
	case kStateAnimation:
		if (animationTargetIndex_ < 0) {
			if ((!skillAnime_ || skillAnime_->isFinished()) && !battleOrder_[currentAttacker_]->isAnimated()) {
				if (skillAnime_) {
					skillAnime_->release();
					skillAnime_ = NULL;
				}
				if (animationTargetIndex_ < 0) {
					animationTargetIndex_ = 0;
					if (animationTargetIndex_ < (int)attackedTargets_.size()) {
						attackedTargets_[animationTargetIndex_]->playDamageAnime();
					}
				}
				messageWindow_.setLineLimit(messageWindow_.lineLimit() + 1);
			}
		} else {
			if (animationTargetIndex_ < (int)attackedTargets_.size()) {
				if (!attackedTargets_[animationTargetIndex_]->isAnimated()) {
					if (attackedTargets_[animationTargetIndex_]->status().isDead()
					&& !attackedTargets_[animationTargetIndex_]->isExcluded()) {
						attackedTargets_[animationTargetIndex_]->playDeadAnime();
					} else {
						animationTargetIndex_++;
						if (animationTargetIndex_ < (int)attackedTargets_.size()) {
							attackedTargets_[animationTargetIndex_]->playDamageAnime();
						}
					}
					messageWindow_.setLineLimit(messageWindow_.lineLimit() + 1);
				}
			} else {
				if (isLose()) {
					setState(kStateLose);
				} else if (isWin()) {
					setState(kStateResult);
				} else {
					currentAttacker_++;
					while (currentAttacker_ < (int)battleOrder_.size() && battleOrder_[currentAttacker_]->isExcluded()) {
						currentAttacker_++;
					}
					if (currentAttacker_ < (int)battleOrder_.size()) {
						stateCounter_ = 0;
						messageWindow_.reset();
						setAnimationMessage();
					} else {
						setState(kStateMenu);
					}
				}
			}
		}
		break;
	case kStateLose:
		stateCounter_++;
		if (messageWindow_.clicked()) {
			setState(kStateEnd);
		}
		break;
	case kStateResult:
		stateCounter_++;
		if (stateCounter_ > 20) {
			if (messageWindow_.lineLimit() < (int)messageWindow_.messageSize()) {
				messageWindow_.setLineLimit(messageWindow_.lineLimit() + 1);
				stateCounter_ = 0;
			} else {
				messageWindow_.enableClick();
				if (messageWindow_.clicked()) {
					setState(kStateEnd);
				}
			}
		}
		break;
	case kStateEnd:
		break;
	}
}
Пример #17
0
void MiniMax::scoreState(tree& state) {

    /* Score the given state */

    int m = state.board.size();                     // num columns
    int n = state.board[0].length() - 1;            // num rows
    int R = state.R;                                // for my convenience
    int d = ((m - R) + (n - R) + 1);                // num diags (usable)
    int s = n - R;                                  // anchor point for diags
    int score = 0;                                  // the score we will assign

    std::vector<std::string> rows;                  // board rows
    std::vector<std::string> diaD;                  // board down diags (usable)
    std::vector<std::string> diaU;                  // board up diags (usable)

    // this prevents multiple resize operations and initializes all values
    // in each vector
    rows.resize(n);
    diaD.resize(d);
    diaU.resize(d);

    // fill in rows, diaD, and diaU
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            rows[j] += state.board[i][j];
            if ((-1 * s) - (m - n) <= (j - i) && (j - i) <= s) {     // up diags
                diaU[s - (j - i)] += state.board[i][j];
            }
            if (s < (i + j) && (i + j) < (s + d)) {      // down diags
                diaD[(i + j) - (s + 1)] += state.board[i][j];
            }
        }
    }

    int col = state.move;
    if (col < 0 || col >= (int) state.board.size()) {
        state.score = 0;
        return;
    }
    int row = state.board[col].find_last_of("XO");
    int diU = s - (col - row);
    int diD = (col + row) - (s + 1);
    std::string c = state.board[col];
    std::string r = rows[row];
    char placed = c.at(row);
    bool blocked = false;
    std::string D;
    if (diD >= 0 && diD < (int) diaD.size()) {
        D = diaD[diD];
        int x = (col + row >= s + R) ? col - ((col + row) - n) : col;
        blocked |= checkblock(D, placed, x, R);
    }
    std::string U;
    if (diU >=0 && diU < (int) diaU.size()) {
        U = diaU[diU];
        int x = (col - row >= 1) ? col - (col - row) : col;
        blocked |= checkblock(U, placed, x, R);
    }
    blocked |= (
        checkblock(c, placed, row, R) ||
        checkblock(r, placed, col, R)
    );
    if (blocked) {
        state.score =  (placed == 'X') ?
            std::numeric_limits<int>::max() - 2 :
            std::numeric_limits<int>::min() + 2;
        return;
    }

    // score all the things
    for (std::string& column : state.board) {
        int s = scoreLine(column, R);
        if (isWin(s)) {
            state.score = s;
            return;
        }
        score += s;
    }
    for (std::string& row : rows) {
        int s = scoreLine(row, R);
        if (isWin(s)) {
            state.score = s;
            return;
        }
        score += s;
    }
    for (std::string& diag : diaD) {
        int s = scoreLine(diag, R);
        if (isWin(s)) {
            state.score = s;
            return;
        }
        score += s;
    }
    for (std::string& diag : diaU) {
        int s = scoreLine(diag, R);
        if (isWin(s)) {
            state.score = s;
            return;
        }
        score += s;
    }

    state.score = score;

}
Пример #18
0
int main()
{
	REG_DISPCTL = MODE3 | BG2_ENABLE;

	//Draw Start Screen
	drawImage3(0, 0, TITLESCREEN_WIDTH, TITLESCREEN_HEIGHT, titleScreen);

	//var to keep track of current position in game
	int inGame = 0;
	int inTitle = 1;

	while(1)
	{

		//START GAME
		if(inTitle == 1 && KEY_DOWN_NOW(BUTTON_START)) {
			inGame = 1;
			inTitle = 0;
			int bgcolor = GRAY;
			DMA[3].src = &bgcolor;
			DMA[3].dst = videoBuffer;
			DMA[3].cnt = 38400 | DMA_SOURCE_FIXED | DMA_DESTINATION_INCREMENT | DMA_ON;

			drawLevel1Board();
			refillLives();
			resetBoard();
		}

		//JUMP BACK TO TITLE SCREEN
		if(KEY_DOWN_NOW(BUTTON_SELECT)) {
			inGame = 0;
			inTitle = 1;
			drawImage3(0, 0, TITLESCREEN_WIDTH, TITLESCREEN_HEIGHT, titleScreen);
		}

		//GAME PLAY
		if(inGame == 1) {
			if(KEY_DOWN_NOW(BUTTON_RIGHT)) {
				moveRight();
			} else if(KEY_DOWN_NOW(BUTTON_LEFT)) {
				moveLeft();
			} else if(KEY_DOWN_NOW(BUTTON_UP)) {
				moveUp();
			} else if(KEY_DOWN_NOW(BUTTON_DOWN)) {
				moveDown();
			}

			waitForVblank();
			clearOld();
			drawCurr();

			//test if reach end of level
			if(isWin() == 1) {
				drawImage3(0, 0, YOUWIN_WIDTH, YOUWIN_HEIGHT, youwin);
				inGame = 0;
				inTitle = 0;
			}

			//test for Collisions with Enemies
			if(isCollide() > 0) {
				if(currLives() > 0) {
					resetBoard();
				} else {
					//out of lives = game over
					inGame = 0;
					inTitle = 0;
					drawImage3(0, 0, GAMEOVER_WIDTH, GAMEOVER_HEIGHT, gameover);
				}
			}

		}
	}
	return 0;

}
Пример #19
0
int alphaBeta(int depth, int alpha, int beta, bool whiteToPlay)
{
	int val, i;
	EVALUATE_INFO_t eval = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
	uint32_t legalMoves = 0;
	PIECE_t pieceBackup;
	PIECE_e piece;
	
#if ENABLE_TRANSPOSITION_TABLE
	int hashFlag = ALPHA_HASH_RESULT;
	if (val = probeHash(depth, alpha, beta) != UNKNOWN_HASH_RESULT)
	{
		cacheHits++;
		return val;
	}
	else
	{
		cacheMisses++;	
	}
	
#endif // ENABLE_TRANSPOSITION_TABLE
	
	// calculate all of the moves
	MOVE_t moves[MOVE_LIST_SIZE];
	legalMoves += AddAllLegalMovesToMoveList(moves, &eval, whiteToPlay);

	if (!legalMoves && depth == currentDepth)
	{
		printf("pass");
		exit(0);
	}
	
	if (depth == 0)
	{
		numberEvaluations++;
		AddAllLegalMovesToMoveList(&moves[legalMoves-1], &eval, !whiteToPlay);
		val = evaluateBoard(&eval);
#if ENABLE_TRANSPOSITION_TABLE
		recordHash(depth, val, EXACT_HASH_RESULT);
#endif //ENABLE_TRANSPOSITION_TABLE
		if (!whiteToPlay)
			val = val * -1;
		return val;
	}

	numberNodes++;
	// for each move
	for (i = 0; i < legalMoves; i++)
	{
		// backup piece so we can undo the move later
		piece = (moves[i].move & PIECE_MASK) >> PIECE_SHIFT;
		pieceBackup.piece = pieces[piece].piece;
		
		// play the  move
		playMove(moves, i);
		
		// Check to see if this position is a win
		val = isWin();
		
		if (!whiteToPlay)
		{
			val = val*-1;
		}

		if (val > DRAW_SCORE)
		{
			val = val + depth;
		}
		else if (val < 0)
		{
			val = val - depth;
		}
		else if (val == DRAW_SCORE)
		{
			val = 0;
		}
		else 
		{
			// not a win or draw; search deeper
			//val = alphaBeta(depth - 1, alpha, beta, !whiteToPlay);
			val = -alphaBeta(depth - 1, -beta, -alpha, !whiteToPlay);	
		}
		
		// undo move
		undoMove(pieceBackup, piece);
		
		// alpha beta pruning:

		if (val >= beta)
		{
#if ENABLE_TRANSPOSITION_TABLE
			recordHash(depth, beta, BETA_HASH_RESULT);
#endif //ENABLE_TRANSPOSITION_TABLE			
			return beta;
		}
		if (val > alpha)
		{
			alpha = val;
			if (depth == currentDepth)
			{
				currMove.move = moves[i].move;				
				currentScore = val;
			}
#if ENABLE_TRANSPOSITION_TABLE
			hashFlag = EXACT_HASH_RESULT;
#endif //ENABLE_TRANSPOSITION_TABLE			
		}
	}
	

#if ENABLE_TRANSPOSITION_TABLE
		recordHash(depth, alpha, hashFlag);
#endif //ENABLE_TRANSPOSITION_TABLE		
	return alpha;
}
int main(){
	int i,j;
	bool mark;
	int n =8;
    fillBox(n);
	fillBox(n);
    output(n);

    printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);
	printf("%d\n",myrandom() % n);

    while (true){
		char ch;
		scanf("%c%*c", &ch);
		if (ch == 'a'){
			// mark = left(n);
			left_remove_blank(n);
			left(n);
		}
		else if (ch == 'd'){
			// mark = right(n);
			right_remove_blank(n);
			right(n);
		}
		else if (ch == 'w'){
			// mark = up(n);
			up_remove_blank(n);
			up(n);
		}
		else if (ch == 's'){
			// mark = down(n);
			down_remove_blank(n);
			down(n);
		}
		else{
			continue;
		}
		system("clear");
		//printf("Move:\n");
		//output();
		// if (!mark){
		// 	continue;
		// }
		fillBox(n);
		printf("Fill:\n");
		output(n);

		if (isOver(n)){
			printf("\n\nGame Over!\n\n");
			break;
		}
		if (isWin(n))
		{
			printf("\n\n Wow You Win!\n\n");
			break;
			/* code */
		}
	}
	
	return 0;
}
Пример #21
0
void GameField::handleEvent(SDL_Event* event, SmileBar* smileBar)
{
	if (gameState != GameState::IN_PROGRESS && gameState != GameState::INIT)
	{
		return;
	}
	int x = (event->button).x;
	int y = (event->button).y;

	const SDL_Rect* clip = cfg->getClip(Clip::CELL_INIT);
	size_t row = (y - topBarHeight) / clip->h;
	size_t col = x / clip->w;
	auto btnType = (event->button).button;

	if (event->type == SDL_MOUSEBUTTONDOWN)
	{
		if (insideField(x, y))
		{
			if (gameState == GameState::INIT)
			{
				gameState = GameState::IN_PROGRESS;
				smileBar->startTimer();
			}
			pressedRow = row;
			pressedCol = col;

			switch (front[pressedRow][pressedCol])
			{
				case Clip::CELL_INIT:
					front[pressedRow][pressedCol] = Clip::CELL_PRESSED;
					if (btnType == SDL_BUTTON_LEFT)
					{
						smileBar->smileState = Clip::SMILE_WONDER;
					}
					break;
				case Clip::CELL_FLAG:
					front[pressedRow][pressedCol] = Clip::CELL_FLAG_PRESSED;
					break;
				case Clip::CELL_QM:
					front[pressedRow][pressedCol] = Clip::CELL_QM_PRESSED;
					break;
				default:
					pressedRow = INF;
					pressedCol = INF;
					break;
			}
		}
	}
	else if (event->type == SDL_MOUSEBUTTONUP)
	{
		if (pressedRow < INF && pressedCol < INF)
		{
			switch (front[pressedRow][pressedCol])
			{
				case Clip::CELL_FLAG_PRESSED:
					if (btnType == SDL_BUTTON_LEFT)
					{
						front[pressedRow][pressedCol] = Clip::CELL_FLAG;
					}
					if (btnType == SDL_BUTTON_RIGHT)
					{
						front[pressedRow][pressedCol] = Clip::CELL_QM;
						smileBar->incrMines();
					}
					break;
				case Clip::CELL_QM_PRESSED:
					if (btnType == SDL_BUTTON_LEFT)
					{
						front[pressedRow][pressedCol] = Clip::CELL_QM;
					}
					else if (btnType == SDL_BUTTON_RIGHT)
					{
						front[pressedRow][pressedCol] = Clip::CELL_INIT;
					}
					break;
				case Clip::CELL_PRESSED:
					if (btnType == SDL_BUTTON_LEFT)
					{
						switch (back[pressedRow][pressedCol])
						{
							case Clip::CELL_PRESSED:
								smileBar->smileState = Clip::SMILE_INIT;
								openEmptyCells();
								break;
							case Clip::CELL_MINE:
								smileBar->smileState = Clip::SMILE_LOSE;
								openAllCells();
								break;
							default:
								smileBar->smileState = Clip::SMILE_INIT;
								front[pressedRow][pressedCol] = back[pressedRow][pressedCol];
								break;
						}
					}
					else if (btnType == SDL_BUTTON_RIGHT)
					{
						front[pressedRow][pressedCol] = Clip::CELL_FLAG;
						smileBar->decrMines();
					}
					break;
				default:
					break;
			}
			pressedRow = INF;
			pressedCol = INF;
		}
	}
	if (isWin())
	{
		gameState = GameState::WIN;
		smileBar->smileState = Clip::SMILE_WIN;
		openAllFlags();
	}
	if (gameState == GameState::WIN || gameState == GameState::LOSE)
	{
		smileBar->stopTimer();
	}
}
Пример #22
0
int main(int argc, char *argv[])
{
	SDL_Init(SDL_INIT_VIDEO);
	displayWindow = SDL_CreateWindow("Simon Project 1", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); // SDL Window, title, position,position,width,height, type of graphics?
	SDL_GLContext context = SDL_GL_CreateContext(displayWindow);
	SDL_GL_MakeCurrent(displayWindow, context);

	glClearColor(0.5, 0.5, 0.0, .9);//Green-color

	//Setup
	glViewport(0, 0, 800, 600);
	glMatrixMode(GL_PROJECTION);
	glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0);
	glMatrixMode(GL_MODELVIEW);
	glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0);

	//LoadTextures
	GLuint paddleID = LoadTexture("pngs/paddle.png");
	GLuint ballID = LoadTexture("pngs/ball.png");
	GLuint leftwinID = LoadTexture24("pngs/leftwin.png");
	GLuint rightwinID = LoadTexture24("pngs/rightwin.png");
	//Init Entities
	initBall(ballID);
	initPaddleLeft(paddleID);
	initPaddleRight(paddleID);
	initRightwin(rightwinID);
	initLeftwin(leftwinID);

	//Time
	float lastFrameTicks = 0.0;
	
	SDL_Event event;
	bool done = false;
	while (!done) {
		glClear(GL_COLOR_BUFFER_BIT);
		float ticks = (float)SDL_GetTicks() / 1000.0f;
		float elapsed = ticks - lastFrameTicks;
		lastFrameTicks = ticks;

		//Read Input and Update World
		while (SDL_PollEvent(&event)) { // a lot of events could cue up, no?, could also get all keyboard states and check for those. I think I like that better. - specially for pong
			if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) {
				done = true;
			}
		}
		const Uint8 *keys = SDL_GetKeyboardState(NULL);
		if (keys[SDL_SCANCODE_UP]) {
			paddleright.y += elapsed*paddleright.velocity_y;
			if (paddleright.y > (1 - .2)){ paddleright.y = 1 - .2; }
		}
		else if (keys[SDL_SCANCODE_DOWN]) {
			paddleright.y -= elapsed*paddleright.velocity_y;
			if (paddleright.y < (-1 + .2)){ paddleright.y = -1 + .2; }
		}
		if (keys[SDL_SCANCODE_W]) {
			paddleleft.y += elapsed*paddleleft.velocity_y;
			if (paddleleft.y >(1 - .2)){ paddleleft.y = 1 - .2; }
		}
		else if (keys[SDL_SCANCODE_S]) {
			paddleleft.y -= elapsed*paddleleft.velocity_y;
			if (paddleleft.y < (-1 + .2)){ paddleleft.y = -1 + .2; }
		}

		updateBall(elapsed);
		isWin();

		//Render World
		ball.Draw();
		paddleleft.Draw();
		paddleright.Draw();
		if (rightwin)
		{
			endGame();
			rightwinE.Draw();
		}
		if (leftwin)
		{
			endGame();
			leftwinE.Draw();
		}

		SDL_GL_SwapWindow(displayWindow);//Swaps old modelview with new one?
	}

	SDL_Quit();
	return 0;
}