snake.cpp

Go to the documentation of this file.

#include "snake.h"

bool Snake::init(Point begin, short dir, int length)
{
    begin.style.letter = '*';
    if (dir == MVLEFT || dir == MVRIGHT || dir == MVUP || dir == MVDOWN)
    {
        /*
         * Pointer to the variable we want to change, depending on the dir variable
         * @type {short*}
         */
        short* changable;
        if (dir == MVLEFT || dir == MVRIGHT)
        {
            changable = &begin.x;
        }
        else
        {
            changable = &begin.y;
        }

        /*
         * The amount we will change the changable variable, depending on the dir variable
         * @type {short}
         */
        short value;
        if (dir == MVRIGHT || dir == MVDOWN)
        {
            value = 1;
        }
        else
        {
            value = -1;
        }

        /*
         * Snake can not exist in non-positive coords
         */
        if (*changable + value * length + 1 < 1 || begin.x < 1 || begin.y < 1)
        {
            return false;
        }

        for (int i = 0; i < length; i++)
        {
            snakeBody.push_front(begin);
            *changable += value;
        }
        direction = dir;
        return true;
    }
    return false;
}

bool Snake::move(Labyrinth* labyrinth)
{
    Point frCoords = snakeBody.front();
    Point bCoords = snakeBody.back();

    /*
     * Getting the future head coords to check intersections
     */
    switch (direction)
    {
        case MVRIGHT:
        {
            frCoords.x++;
            break;
        }
        case MVLEFT:
        {
            frCoords.x--;
            break;
        }
        case MVDOWN:
        {
            frCoords.y++;
            break;
        }
        case MVUP:
        {
            frCoords.y--;
            break;
        }
        default:
        {
            return false;
        }
    }

    /*
     * Flag of whether there was a wall collision and therefor
     * we need to teleport snake's head to the opposite side of the labyrinth
     */
    bool wallFlag = 0;

    /*
     * Checking intersections with borders, obstacles and Ball and deciding where to put the head of the snake
     */
    switch (checkIntersection(frCoords, labyrinth))
    {
        case WALLUP:
        {
            frCoords.y = gameFieldSize.y - 2;
            wallFlag = 1;
            break;
        }
        case WALLBOT:
        {
            frCoords.y = 1;
            wallFlag = 1;
            break;
        }
        case WALLLEFT:
        {
            frCoords.x = gameFieldSize.x - 2;
            wallFlag = 1;
            break;
        }
        case WALLRIGHT:
        {
            frCoords.x = 1;
            wallFlag = 1;
            break;
        }
        case COLL:
        {
            moveBack(bCoords, &labyrinth->change);
            return true;
        }
        case NOCOLL:
        {
            break;
        }
        case BALL:
        {
            bCoords.x = -1;
            bCoords.y = -1;
            //Change to a single call to labyrinth(like labyrinth->newBall())
            labyrinth->change.rmPoint(labyrinth->ball.getCoords());
            labyrinth->generateBall();
            labyrinth->change.addPoint(labyrinth->ball.getCoords());
            break;
        }
        default:
        {
            break;
        }
    }

    /*
     * If there was a wall collision, then we need to check
     * the new head position of the snake for colliding with Ball or obstacles
     */
    if(wallFlag)
    {
        switch (checkIntersection(frCoords, labyrinth))
        {
            case COLL:
            {
                moveBack(bCoords, &labyrinth->change);
                return true;
            }
            case NOCOLL:
            {
                break;
            }
            case BALL:
            {
                bCoords.x = -1;
                bCoords.y = -1;
                labyrinth->generateBall();
                break;
            }
            default:
            {
                break;
            }
        }
    }

    /*
     * If there was no obstacle collision then proceed and add Points to the
     * change array, staging them for addition/removal to/from labyrinth
     */
    moveHead(frCoords, &labyrinth->change);
    moveBack(bCoords, &labyrinth->change);
    return false;

}

void Snake::moveHead(Point p, Change* change)
{
    change->addPoint(p);
    snakeBody.push_front(p);
}

void Snake::moveBack(Point p, Change* change)
{
    if(change->rmPoint(p))
    {
        snakeBody.pop_back();
    }
}

short Snake::checkIntersection(Point check, Labyrinth* labyrinth)
{
    if ((!labyrinth->isFree(check)) == 1)
    {
        return checkWisely(check, labyrinth->ball.getCoords());
    }
    return NOCOLL;

}

short Snake::checkWisely(Point check, Point bCoords)
{
    if(check.x == bCoords.x && check.y == bCoords.y)
    {
        return BALL;
    }
    else if (check.x == gameFieldSize.x - 1)
    {
        return WALLRIGHT;
    }
    else if (check.x == 0)
    {
        return WALLLEFT;
    }
    else if (check.y == gameFieldSize.y - 1)
    {
        return WALLBOT;
    }
    else if (check.y == 0)
    {
        return WALLUP;
    }
    return COLL;
}

bool Snake::setDirection(int direction)
{
    if (direction == MVRIGHT || direction == MVLEFT || direction == MVUP || direction == MVDOWN){
        /*
         * If directions are opposite, do nothing
         */
        if (this->direction + direction == 0)
        {
            return false;
        }

        this->direction = direction;
    }
    return true;
}

short Snake::getDirection()
{
    return this->direction;
}

Point Snake::getHeadCoords()
{
    Point headCoords = snakeBody.front();
    return headCoords;
}

void Snake::getCoords(std::list<Point>* currBody)
{
    currBody->assign(snakeBody.begin(), snakeBody.end());
}