コード例 #1
0
ファイル: Game.cpp プロジェクト: brummetj/ucd-csci2312-pa4
void Game::play(bool verbose)
    {
        
        while(getNumResources() > 0 && getNumPieces() > 1)
            round();
        
    }
コード例 #2
0
ファイル: Game.cpp プロジェクト: hoangk/ucd-csci2312-pa4
    // play game until over
    void Game::play(bool verbose) {
        __verbose = verbose;
        round();

        if(getNumPieces()>1 && getNumResources() > 0) {
            play(verbose);
        }
    }
コード例 #3
0
ファイル: Game.cpp プロジェクト: SamridKC/ucd-csci2312-pa4
    void Game::play(bool verbose) {
        __verbose = verbose;
        __status = PLAYING;
        round();

        if (getNumResources() > 0) {
            if (getNumPieces() > 0) {
                play(verbose);
            }
        }
    }
コード例 #4
0
 void Game::round() {
     //using the set example algorithm from the read me
     std::set<Piece*> board;
     Position pos, Newpos;
     ActionType action;
     Piece* pptr;
     int location;
     for (auto it = __grid.begin(); it < __grid.end(); ++it) {
         if (*it != nullptr) {
             board.insert(board.end(),*it);
             (*it)->setTurned(false);                                            //resets the pieces so that they can take a turn this will reset after each round
         }
     }
     for (auto it = board.begin(); it != board.end(); ++it) {
         if ((*it)->isViable()&& (*it)->getTurned()) {
             (*it)->age();
             (*it)->setTurned(true);
             pos = (*it)->getPosition();                                          //will pass a pieces position or location in
             action = (*it)->takeTurn(getSurroundings(pos));                     //piece takes a turn for each
             Newpos = this->move(pos, action);                                   //passes the new location into the new variabale
             location = Newpos.y + (Newpos.x * __width);
             pptr = __grid[location];
             if(pos.x != Newpos.x && pos.y != Newpos.y){                         //checks if new pos and the current pos arent n the same location
                 if (pptr != nullptr) {                                                  //this happens if the piece wants to move to annother spot hwere there is another piece in it soit will challnege or cosume if its a resource
                     (*(*it)* *pptr);                                            //this means that the pieces interact and we will pass some if statmnts
                  if ((*it)->isViable()) {                                    //if it didn't get consumed we pass it set new position
                     (*it)->setPosition(Newpos);
                     __grid[Newpos.y + (Newpos.x * __width)] = *it;                //will change the grid and set equal to it and also set it equal to nullptr
                     __grid[pos.y + (pos.x * __width)] = nullptr;
                 }
                 else {                                                      //when a resource gets consumed you set that location = to null ptr
                     __grid[pos.y + (pos.x * __width)] = nullptr;
                 }
             }
             }
             else {
                 __grid[Newpos.y + (Newpos.x * __width)] = *it;              //else to the other staments if the position is emoyty
             }
         }
     }
     for (int i = 0; i < __grid.size(); ++i) {
         //if (!__grid[i]->isViable() && __grid[i] != nullptr) {
         if(__grid[i] != nullptr && !__grid[i]->isViable()){
             delete __grid[i];
             __grid[i] = nullptr;
         }
     }
     if (getNumResources() == 0)
         this->__status = OVER;
     //we need to increment the round after it is over
     __round++;
 }
コード例 #5
0
ファイル: Game.cpp プロジェクト: travinh/ucd-csci2312-pa4
    void Game::play(bool verbose)
    {
        __status = PLAYING;
        if(verbose)
        {
             __verbose = verbose;
             while(getNumResources())
             {
                 std::cout << *this << std::endl;
                 round();
             }
            __status = OVER;
            std::cout << *this << std::endl;
        }
        else
        {
            while(getNumResources())
                round();
            __status = OVER;
        }

    }
コード例 #6
0
ファイル: Game.cpp プロジェクト: qkowens/ucd-csci2312-pa4
    void Game::round()   // play a single round
    {
		std::set<Piece*> pieces;
		for (auto it = __grid.begin(); it != __grid.end(); ++it)
		{
			if (*it)
			{
				pieces.insert(pieces.end(), *it);
				(*it)->setTurned(false);
			}
		}

		// Take turns
		for (auto it = pieces.begin(); it != pieces.end(); ++it)
		{
			if (!(*it)->getTurned())
			{
				(*it)->setTurned(true);
				(*it)->age();

				ActionType ac = (*it)->takeTurn(getSurroundings((*it)->getPosition()));
				Position pos0 = (*it)->getPosition();
				Position pos1 = move(pos0, ac);

				if (pos0.x != pos1.x || pos0.y != pos1.y)
				{
					Piece *p = __grid[pos1.y + (pos1.x * __width)];
					if (p)
					{
						(*(*it)) * (*p);
						if ((*it)->getPosition().x != pos0.x || (*it)->getPosition().y != pos0.y)
						{
							// piece moved
							__grid[pos1.y + (pos1.x * __width)] = (*it);
							__grid[pos0.y + (pos0.x * __width)] = p;
						}
					}
					else
					{
						// empty move
						(*it)->setPosition(pos1);
						__grid[pos1.y + (pos1.x * __width)] = (*it);
						__grid[pos0.y + (pos0.x * __width)] = nullptr;
					}
				}
			}
		}

		// Update positions and delete unviable first
		for (unsigned int i = 0; i < __grid.size(); ++i)
			if (__grid[i] && !(__grid[i]->isViable()))
			{
				delete __grid[i];
				__grid[i] = nullptr;
			}

		// Check game over
		if (getNumResources() <= 0)
			__status = Status::OVER;

		__round++;
    }
コード例 #7
0
ファイル: Game.cpp プロジェクト: EvanDague/ucd-csci2312-pa3
    void Game::round(){
        
        if(__round == 0 && __verbose){
            __status = PLAYING;
            cout << endl << *this;
        }
        for (int i = 0; i < __grid.size(); ++i) {
            if(__grid[i]!= nullptr){
                if(__grid[i]->isViable()) {
                    if (!__grid[i]->getTurned()) {
                        Agent * agent = dynamic_cast<Agent*>(__grid[i]);
                        if(agent) {
                            __grid[i]->setTurned(true);
                            Position currentPos = __grid[i]->getPosition();
                            Surroundings surround = getSurroundings(currentPos);
                            ActionType action = __grid[i]->takeTurn(surround);
                            if (action != STAY) {
                                Position newPos = move(currentPos, action);
                                int newPosIndx = (newPos.x * __width + newPos.y);
                                (*__grid[i]) * (*__grid[newPosIndx]);
                                if(!__grid[i]->isViable()){
                                    delete __grid[i];
                                    __grid[i]= nullptr;
                                }
                                else {
                                    __grid[i]->setPosition(newPos);
                                    if (__grid[newPosIndx] != nullptr) {
                                        delete __grid[newPosIndx];
                                        __grid[newPosIndx] = __grid[i];
                                        __grid[i] = nullptr;
                                    }
                                    else {
                                        __grid[newPosIndx] = __grid[i];
                                        __grid[i] = nullptr;
                                    }
                                }
                                if(!__grid[newPosIndx]->isViable()){
                                    delete __grid[newPosIndx];
                                    __grid[newPosIndx]= nullptr;
                                }
                            }
                        }
                    }
                }
            }
        }
        for (int j = 0; j < __grid.size(); ++j) {
            if(__grid[j] != nullptr) {
                if (!__grid[j]->isViable()) {
                    delete __grid[j];
                    __grid[j] = nullptr;
                }
                else {
                    __grid[j]->setTurned(false);
                    __grid[j]->age();
                }
            }
        }
        if(getNumPieces()< 2 || getNumResources() < 1)
            __status = OVER;
        ++__round; //

        if(__verbose)
            cout << endl << *this;

    }
コード例 #8
0
ファイル: game.cpp プロジェクト: kangrace/ucd-csci2312-pa4
    void Game::round()
    {
        if (__verbose && __round == 0)
            __status = Status::PLAYING;

        for (int count = 0; count < __grid.size(); ++count)
        {
            if (__grid[count] != nullptr && !__grid[count]->getTurned() && __grid[count]->isViable())
            {

                Agent *a = dynamic_cast<Agent *>(__grid[count]);

                if (a)
                {
                    __grid[count]->setTurned(true);

                    Position p = __grid[count]->getPosition();
                    Surroundings s = getSurroundings(p);
                    ActionType act = __grid[count]->takeTurn(s);


                    if (act != STAY)
                    {
                        Position newp = move(p, act);
                        int i = (newp.x * __width + newp.y);

                        (*__grid[count]) * (*__grid[i]);


                        if (!__grid[count]->isViable())
                        {
                            delete __grid[count];
                            __grid[count] = nullptr;
                        }

                        else
                        {
                            __grid[count]->setPosition(newp);

                            if (__grid[i] == nullptr)
                            {
                                __grid[i] = __grid[count];
                                __grid[count] = nullptr;
                            }

                            else
                            {
                                delete __grid[i];
                                __grid[i] = __grid[count];
                                __grid[count] = nullptr;

                            }
                        }

                        if (!__grid[i]->isViable())
                        {
                            delete __grid[i];
                            __grid[i] = nullptr;
                        }
                    }
                }
            }
        }

        for (int i = 0; i < __grid.size(); ++i)
        {
            if (__grid[i] != nullptr)
            {
                if (__grid[i]->isViable())
                {
                    __grid[i]->setTurned(false);
                    __grid[i]->age();

                }

                else
                {
                    delete __grid[i];
                    __grid[i] = nullptr;
                }
            }
        }

        if (getNumResources() < 1)
        {
            __status = Status::OVER;
        }

        __round++;
    }
コード例 #9
0
ファイル: Game.cpp プロジェクト: hoangk/ucd-csci2312-pa4
    // play a single round
    void Game::round() {

        if(__round == 0 && __verbose) {
            __status = PLAYING;
            std::cout << std::endl << *this;
        }
        for (int count = 0; count < __grid.size(); ++count) {
            if(__grid[count]!= nullptr) {
                if(__grid[count]->isViable()) {
                    if (! __grid[count]->getTurned()) {
                        Agent * agent = dynamic_cast<Agent*>(__grid[count]);
                        if(agent) {
                            __grid[count]->setTurned(true);
                            Position currPosition = __grid[count]->getPosition();
                            Surroundings s = getSurroundings(currPosition);
                            ActionType aT = __grid[count]->takeTurn(s);

                            if (aT != STAY) {
                                Position newPosition = move(currPosition, aT);
                                int newPosIndex = (newPosition.x * __width + newPosition.y);
                                (*__grid[count]) * (*__grid[newPosIndex]);

                                if(! __grid[count]->isViable())
                                {
                                    delete __grid[count];
                                    __grid[count]= nullptr;
                                }

                                else
                                {
                                    __grid[count]->setPosition(newPosition);

                                    if (__grid[newPosIndex] != nullptr)
                                    {
                                        delete __grid[newPosIndex];
                                        __grid[newPosIndex] = __grid[count];
                                        __grid[count] = nullptr;
                                    }

                                    else
                                    {
                                        __grid[newPosIndex] = __grid[count];
                                        __grid[count] = nullptr;
                                    }
                                }

                                if(! __grid[newPosIndex]->isViable())
                                {
                                    delete __grid[newPosIndex];
                                    __grid[newPosIndex]= nullptr;
                                }
                            }
                        }
                    }
                }
            }
        }
        for (int i = 0; i < __grid.size(); i++) {
            if(__grid[i] != nullptr) {
                if (!__grid[i]->isViable()) {
                    delete __grid[i];
                    __grid[i] = nullptr;
                }
                else
                {
                    __grid[i]->setTurned(false);
                    __grid[i]->age();
                }
            }
        }
        if(getNumPieces()< 2 || getNumResources() < 1)
        {
            __status = OVER;
        }
        ++__round;

        if(__verbose)
        {
            std::cout << std::endl << *this;
        }

    }
コード例 #10
0
ファイル: Game.cpp プロジェクト: hoangk/ucd-csci2312-pa4
 // getters
 unsigned int Game::getNumPieces() const {
     return getNumAgents() +getNumResources();
 }
コード例 #11
0
ファイル: Game.cpp プロジェクト: YuanmingShi/ucd-csci2312-pa4
    void Game::round() {   // play a single round
        //__status = PLAYING;
        //std::cout << "Round started" << std::endl;
        std::set<Piece*> pieces;
        for (auto it = __grid.begin(); it != __grid.end(); ++it) {
            if (*it) {
                pieces.insert(pieces.end(), *it);
                //pieces.insert(*it);
                (*it)->setTurned(false);
            }
        }

        // Take turns
        for (auto it = pieces.begin(); it != pieces.end(); ++it) {
            if (!(*it)->getTurned()) {
                (*it)->setTurned(true);
                (*it)->age();
                ActionType ac = (*it)->takeTurn(getSurroundings((*it)->getPosition()));
                //std::cout << "------- Game::round -------" << std::endl;
                //std::cout << "Action: " << ac << std::endl;
                Position pos0 = (*it)->getPosition();
                //std::cout << "Pos0: " << pos0.x << "x" << pos0.y << std::endl;
                Position pos1 = move(pos0, ac);
                //std::cout << "Pos1: " << pos1.x << "x" << pos1.y << std::endl;
                if (pos0.x != pos1.x || pos0.y != pos1.y) {
                    Piece *p = __grid[pos1.y + (pos1.x * __width)];
                    if (p) {
                        (*(*it)) * (*p);
                        if ((*it)->getPosition().x != pos0.x || (*it)->getPosition().y != pos0.y) {
                            // piece moved
                            __grid[pos1.y + (pos1.x * __width)] = (*it);
                            __grid[pos0.y + (pos0.x * __width)] = p;
                        }
                    } else {
                        // empty move
                        (*it)->setPosition(pos1);
                        __grid[pos1.y + (pos1.x * __width)] = (*it);
                        __grid[pos0.y + (pos0.x * __width)] = nullptr;
                        //std::cout << "position updated of piece" << std::endl;
                    }
                }
            }
        }

        // Update positions and delete
        // Delete invalid first
        for (unsigned int i = 0; i < __grid.size(); ++i) {
            //if (__grid[i]) std::cout << "Piece viable: " << __grid[i]->isViable() << std::endl;
            if (__grid[i] && !(__grid[i]->isViable())) {
                delete __grid[i];
                __grid[i] = nullptr;
            }
            //if (__grid[i]) __grid[i]->age();
        }

        // Update positions of remaining
        /*for (unsigned int i = 0; i < __grid.size(); ++i) {
            Piece *currentPiece = __grid[i];
            if (currentPiece) {
                Position pos = currentPiece->getPosition();
                if (__grid[pos.y + (pos.x * __width)] != currentPiece) {
                    __grid[pos.y + (pos.x * __width)] = currentPiece;
                    __grid[i] = nullptr;
                    //std::cout << "place in __grid changed of a piece" << std::endl;
                }
            }
            i++;
        }*/

        // Check game over
        if (getNumResources() <= 0) {
            __status = Status::OVER;
        }
        __round++;
    }
コード例 #12
0
ファイル: Game.cpp プロジェクト: SoeOrl/ucd-csci2312-pa4
	void Game::round()
	{
		std::set<Piece*> gamePieces;
		for (auto reset = __grid.begin(); reset != __grid.end(); ++reset)
		{
			if (*reset)
			{
				gamePieces.insert(gamePieces.end(), *reset);
			
				(*reset)->setTurned(false);
			}
		}

	
		for (auto turn = gamePieces.begin(); turn != gamePieces.end(); ++turn) 
		{
			if (!(*turn)->getTurned()) 
			{
				(*turn)->setTurned(true);
				(*turn)->age();
				ActionType ac = (*turn)->takeTurn(getSurroundings((*turn)->getPosition()));
				Position pBefore = (*turn)->getPosition();
			
				Position pAfter = move(pBefore, ac);
			
				if (pBefore.x != pAfter.x || pBefore.y != pAfter.y) 
				{
					Piece *p = __grid[pAfter.y + (pAfter.x * __width)];
					if (p) 
					{
						(*(*turn)) * (*p);
						if ((*turn)->getPosition().x != pBefore.x || (*turn)->getPosition().y != pBefore.y) 
						{
						
							__grid[pAfter.y + (pAfter.x * __width)] = (*turn);
							__grid[pBefore.y + (pBefore.x * __width)] = p;
						}
					}
					else 
					{
						
						(*turn)->setPosition(pAfter);
						__grid[pAfter.y + (pAfter.x * __width)] = (*turn);
						__grid[pBefore.y + (pBefore.x * __width)] = nullptr;
						
					}
				}
			}
		}

		for (unsigned int i = 0; i < __grid.size(); ++i) 
		{
			
			if (__grid[i] && !(__grid[i]->isViable())) 
			{
				delete __grid[i];
				__grid[i] = nullptr;
			}
		
		}

		if (getNumResources() <= 0) 
		{
			__status = Status::OVER;
		}
		__round++;
	}