mutatris::Piece Class Reference

#include <examples/mutatris/piece.hpp>

Public Member Functions
const Block *	at (int index) const
bool	checkLocation (int next_x, int next_y) const
bool	drop ()
int	getDirection () const
int	getX () const
int	getY () const
bool	moveDown ()
void	moveLeft ()
void	moveRight ()
	Piece (GameGrid *owner)
void	reset ()
bool	setBlock ()
void	shiftColors ()
void	shiftDirection ()

Detailed Description

Definition at line 13 of file piece.hpp.

Constructor & Destructor Documentation

Piece()

mutatris::Piece::Piece ( GameGrid * owner )

explicit

Definition at line 11 of file piece.cpp.

        : grid(owner) {
    }

Member Function Documentation

at()

const Block * mutatris::Piece::at ( int index ) const

inlinenodiscard

Definition at line 30 of file piece.hpp.

                                                       {
            return index >= 0 && index < static_cast<int>(blocks.size()) ? &blocks[static_cast<std::size_t>(index)] : nullptr;
        }

checkLocation()

bool mutatris::Piece::checkLocation ( int next_x, int next_y ) const

nodiscard

Definition at line 33 of file piece.cpp.

                                                          {
        std::array<const Block *, 3> target{};
        switch (direction) {
        case 0:
            target = {grid->at(next_x, next_y), grid->at(next_x, next_y + 1), grid->at(next_x, next_y + 2)};
            break;
        case 1:
            target = {grid->at(next_x, next_y), grid->at(next_x + 1, next_y), grid->at(next_x + 2, next_y)};
            break;
        case 2:
            target = {grid->at(next_x, next_y), grid->at(next_x - 1, next_y), grid->at(next_x - 2, next_y)};
            break;
        case 3:
            target = {grid->at(next_x, next_y), grid->at(next_x, next_y - 1), grid->at(next_x, next_y - 2)};
            break;
        default:
            break;
        }
 
        return std::all_of(target.begin(), target.end(), [](const Block *block) {
            return block != nullptr && block->color == 0;
        });
    }

drop()

bool mutatris::Piece::drop ( )

nodiscard

Definition at line 78 of file piece.cpp.

                     {
        while (checkLocation(x, y + 1)) {
            ++y;
        }
        return setBlock();
    }

getDirection()

int mutatris::Piece::getDirection ( ) const

inlinenodiscard

Definition at line 29 of file piece.hpp.

{ return direction; }

getX()

int mutatris::Piece::getX ( ) const

inlinenodiscard

Definition at line 27 of file piece.hpp.

{ return x; }

getY()

int mutatris::Piece::getY ( ) const

inlinenodiscard

Definition at line 28 of file piece.hpp.

{ return y; }

moveDown()

bool mutatris::Piece::moveDown ( )

nodiscard

Definition at line 69 of file piece.cpp.

                         {
        if (checkLocation(x, y + 1)) {
            ++y;
            return false;
        } else {
            return setBlock();
        }
    }

moveLeft()

void mutatris::Piece::moveLeft

(

)

Definition at line 57 of file piece.cpp.

                         {
        if (checkLocation(x - 1, y)) {
            --x;
        }
    }

moveRight()

void mutatris::Piece::moveRight

(

)

Definition at line 63 of file piece.cpp.

                          {
        if (checkLocation(x + 1, y)) {
            ++x;
        }
    }

reset()

void mutatris::Piece::reset

(

)

Definition at line 15 of file piece.cpp.

                      {
        x = grid->width() / 2;
        y = 0;
        do {
            for (Block &block : blocks) {
                block.color = 1 + (std::rand() % 7);
            }
        } while (blocks[0].color == blocks[1].color && blocks[0].color == blocks[2].color);
        direction = 0;
    }

setBlock()

bool mutatris::Piece::setBlock ( )

nodiscard

Definition at line 93 of file piece.cpp.

                         {
        std::array<Block *, 3> target{};
        switch (direction) {
        case 0:
            target = {grid->at(x, y), grid->at(x, y + 1), grid->at(x, y + 2)};
            break;
        case 1:
            target = {grid->at(x, y), grid->at(x + 1, y), grid->at(x + 2, y)};
            break;
        case 2:
            target = {grid->at(x, y), grid->at(x - 1, y), grid->at(x - 2, y)};
            break;
        case 3:
            target = {grid->at(x, y), grid->at(x, y - 1), grid->at(x, y - 2)};
            break;
        default:
            break;
        }
 
        for (std::size_t i = 0; i < target.size(); ++i) {
            if (target[i] == nullptr || target[i]->color != 0) {
                return false;
            }
            target[i]->color = blocks[i].color;
            target[i]->clearElapsedMs = 0;
        }
        reset();
        return true;
    }

shiftColors()

void mutatris::Piece::shiftColors

(

)

Definition at line 26 of file piece.cpp.

                            {
        const std::array<Block, 3> previous = blocks;
        blocks[0] = previous[2];
        blocks[1] = previous[0];
        blocks[2] = previous[1];
    }

shiftDirection()

void mutatris::Piece::shiftDirection

(

)

Definition at line 85 of file piece.cpp.

                               {
        const int oldDirection = direction;
        direction = (direction + 1) % 4;
        if (!checkLocation(x, y)) {
            direction = oldDirection;
        }
    }

---

The documentation for this class was generated from the following files:

• examples/mutatris/piece.hpp
• examples/mutatris/piece.cpp