Snake/SnakeClient/SnakeApp/back-end/snake.cpp

#include "snake.h"
#include "guiobject.h"

#include <QDateTime>
#include <QMap>
#include <QRectF>
#include <cmath>

Snake::Snake() {
}

const QVector<Head *> &Snake::getItems() const {
    return items;
}

void Snake::render() {

    auto centerX = [](const Head* head) {
        return head->x()/* + (head->w() / 2)*/;
    };

    auto centerY = [](const Head* head) {
        return head->y() /*+ (head->h() / 2)*/;
    };

    for (int i = items.length() - 1; i >= 0; --i) {

        if (dead) {
            items[i]->render();
            continue;
        }

        if (i == 0) {
            if (isClick) {
                if (countClick & 1){
                    items[i]->setAngle(45);
                } else {
                    items[i]->setAngle(315);
                }
                isClick = false;
            }
        } else  {

            double _atan2 = atan2(centerY(items[i - 1]) - centerY(items[i]),
                    centerX(items[i - 1]) - centerX(items[i])) * 90;

            items[i]->setAngle(_atan2);
        }

        items[i]->render();
    }
}

double Snake::checDistance(int i) {

    auto result = (items[i]->rect().y() -
    items[i - 1]->rect().y()) / rataticonDistance;

    return result;

}

double Snake::getRataticonDistance() const {
    return rataticonDistance;
}

void Snake::setRataticonDistance(double value) {
    rataticonDistance = value;
}

void Snake::unPause() {
    for ( int i = 0; i < items.size(); ++i ) {
        items[i]->unPause();
    }
}

double Snake::sizeByLvl(double lvl , int count) const {
    double maxSize = 9;
    double minSize = 5;

    double pos = (1 - (lvl / count));

    QList<QPair<double, double>> snakeGradientSize {
        {1, 4},
        {0.99, 7},
        {0.8, 5},
        {0.6, 6},
        {0.0, 3}
    };

    double local = 0;
    int index = 0;

    while (index + 1 < snakeGradientSize.size()
           && pos <= snakeGradientSize[index].first) {

        maxSize = snakeGradientSize[index].second;
        minSize = snakeGradientSize[index + 1].second;

        auto range = snakeGradientSize[index].first -
                snakeGradientSize[index + 1].first;

        local = ( range - (snakeGradientSize[index].first - pos)) /
                   range;

        index++;
    }

    return local * (maxSize - minSize) + minSize;
}

void Snake::changeCountObjects(int count) {
    if (count > 0) {
        double margin = 60.0 / count;
        for ( int i = 0; i < count; ++i ) {

            auto size = sizeByLvl(i, count);
            auto obj = new Head(margin * (count - i),
                                50, size , size,
                                this->speed);

            obj->setY(50 + obj->h() / 2);

            items.push_back(obj);
        }

    } else {
        for ( int i = count; i < 0; ++i ) {
            auto obj = items.first();
            items.removeFirst();
            delete obj;
        }
    }
}

QMap<int, GuiObject*> Snake::init(int size, double *speed) {

    QMap<int, GuiObject*> res;

    if (size <= 0) {
        return res;
    }

    this->speed = speed;

    changeCountObjects(size - items.size());

    for (auto i : items) {
        res[i->guiId()] = i;
    }

    dead = false;

    return res;
}

bool Snake::isInited() const {
    return items.size();
}

void Snake::clearItems() {
    for (auto i : items) {
        delete i;
    }
    items.clear();
}

void Snake::resetPosotion() {
    double margin = 60.0 / items.size();

    for ( int i = 0; i < items.size(); ++i ) {
        items[i]->setX(margin * (items.size() - i));
        items[i]->setY(50 + items[i]->h() / 2);
        items[i]->setAngle(0);
    }
}

void Snake::kill() {
    dead = true;
}

bool Snake::isDead() const {
    return dead;
}

Snake::~Snake() {
    clearItems();
}

void Snake::clear() {
    clearItems();
}

void Snake::reverse() {
    if (isClick) {
        return;
    }
    isClick = true;
    countClick++;
}
Class Snake & Header Controller 2018-09-11 20:10:37 +03:00			`#include "snake.h"`
world is done 2018-10-11 00:04:52 +03:00			`#include "guiobject.h"`
Class Snake & Header Controller 2018-09-11 20:10:37 +03:00
added texture 2018-11-28 22:17:30 +03:00			`#include <QDateTime>`
world is done 2018-10-11 00:04:52 +03:00			`#include <QMap>`
			`#include <QRectF>`
fix animation 2018-11-25 03:24:41 +03:00			`#include <cmath>`
fix snake class v2 2018-09-11 22:15:30 +03:00
fix animation 2018-11-25 03:24:41 +03:00			`Snake::Snake() {`
fix snake class v2 2018-09-11 22:15:30 +03:00			`}`

fix snake class 2018-09-11 22:08:08 +03:00			`const QVector<Head *> &Snake::getItems() const {`
render fix 2018-09-14 22:06:34 +03:00			`return items;`
Class Snake & Header Controller 2018-09-11 20:10:37 +03:00			`}`

fix snake class v2 2018-09-11 22:15:30 +03:00			`void Snake::render() {`
added texture 2018-11-28 22:17:30 +03:00
first work version 2018-12-01 22:39:03 +03:00			`auto centerX = [](const Head* head) {`
			`return head->x()/* + (head->w() / 2)*/;`
			`};`

			`auto centerY = [](const Head* head) {`
			`return head->y() /+ (head->h() / 2)/;`
			`};`

fix: guiobject 2018-11-14 23:15:36 +03:00			`for (int i = items.length() - 1; i >= 0; --i) {`
fix animation 2018-11-25 03:24:41 +03:00
added texture 2018-11-28 22:17:30 +03:00			`if (dead) {`
			`items[i]->render();`
			`continue;`
			`}`

fix discord of snake 2019-02-11 16:42:52 +03:00			`if (i == 0) {`
			`if (isClick) {`
			`if (countClick & 1){`
fix bug renders 2018-09-14 22:13:47 +03:00			`items[i]->setAngle(45);`
fix discord of snake 2019-02-11 16:42:52 +03:00			`} else {`
fix bug renders 2018-09-14 22:13:47 +03:00			`items[i]->setAngle(315);`
render fix 2018-09-14 22:06:34 +03:00			`}`
fix: remove el& add snake on scene 2018-11-16 02:08:35 +03:00			`isClick = false;`
render fix 2018-09-14 22:06:34 +03:00			`}`
first work version 2018-12-01 22:39:03 +03:00			`} else {`

			`double _atan2 = atan2(centerY(items[i - 1]) - centerY(items[i]),`
fix discord of snake 2019-02-11 16:42:52 +03:00			`centerX(items[i - 1]) - centerX(items[i])) * 90;`
fix animation 2018-11-25 03:24:41 +03:00
			`items[i]->setAngle(_atan2);`
render fix 2018-09-14 22:06:34 +03:00			`}`
fix animation 2018-11-25 03:24:41 +03:00
fix: remove el& add snake on scene 2018-11-16 02:08:35 +03:00			`items[i]->render();`
render fix 2018-09-14 22:06:34 +03:00			`}`
Class Snake & Header Controller 2018-09-11 20:10:37 +03:00			`}`

fix animation 2018-11-25 03:24:41 +03:00			`double Snake::checDistance(int i) {`

			`auto result = (items[i]->rect().y() -`
			`items[i - 1]->rect().y()) / rataticonDistance;`

			`return result;`

			`}`

			`double Snake::getRataticonDistance() const {`
			`return rataticonDistance;`
			`}`

			`void Snake::setRataticonDistance(double value) {`
			`rataticonDistance = value;`
			`}`

first work version 2018-12-01 22:39:03 +03:00			`void Snake::unPause() {`
			`for ( int i = 0; i < items.size(); ++i ) {`
			`items[i]->unPause();`
			`}`
			`}`

fix snake 2018-12-01 21:06:40 +03:00			`double Snake::sizeByLvl(double lvl , int count) const {`
			`double maxSize = 9;`
			`double minSize = 5;`

			`double pos = (1 - (lvl / count));`

			`QList<QPair<double, double>> snakeGradientSize {`
refactor 2018-12-06 22:49:35 +03:00			`{1, 4},`
			`{0.99, 7},`
			`{0.8, 5},`
			`{0.6, 6},`
fix snake 2018-12-01 21:06:40 +03:00			`{0.0, 3}`
			`};`

first work version 2018-12-01 22:39:03 +03:00			`double local = 0;`
fix snake 2018-12-01 21:06:40 +03:00			`int index = 0;`

			`while (index + 1 < snakeGradientSize.size()`
			`&& pos <= snakeGradientSize[index].first) {`

first work version 2018-12-01 22:39:03 +03:00			`maxSize = snakeGradientSize[index].second;`
			`minSize = snakeGradientSize[index + 1].second;`
fix snake 2018-12-01 21:06:40 +03:00
first work version 2018-12-01 22:39:03 +03:00			`auto range = snakeGradientSize[index].first -`
			`snakeGradientSize[index + 1].first;`
fix snake 2018-12-01 21:06:40 +03:00
first work version 2018-12-01 22:39:03 +03:00			`local = ( range - (snakeGradientSize[index].first - pos)) /`
fix snake 2018-12-01 21:06:40 +03:00			`range;`

			`index++;`
			`}`

first work version 2018-12-01 22:39:03 +03:00			`return local * (maxSize - minSize) + minSize;`
fix snake 2018-12-01 21:06:40 +03:00			`}`

added funcrionaliti of diff objects on back-end 2018-11-04 16:11:55 +03:00			`void Snake::changeCountObjects(int count) {`
			`if (count > 0) {`
fix animation 2018-11-25 03:24:41 +03:00			`double margin = 60.0 / count;`
added funcrionaliti of diff objects on back-end 2018-11-04 16:11:55 +03:00			`for ( int i = 0; i < count; ++i ) {`
fix snake 2018-12-01 21:06:40 +03:00
			`auto size = sizeByLvl(i, count);`
fix animation 2018-11-25 03:24:41 +03:00			`auto obj = new Head(margin * (count - i),`
demo version (android, ubuntu) 2018-12-02 14:06:48 +03:00			`50, size , size,`
fix snake 2018-12-01 21:06:40 +03:00			`this->speed);`

			`obj->setY(50 + obj->h() / 2);`
added funcrionaliti of diff objects on back-end 2018-11-04 16:11:55 +03:00
			`items.push_back(obj);`
			`}`

			`} else {`
			`for ( int i = count; i < 0; ++i ) {`
			`auto obj = items.first();`
			`items.removeFirst();`
			`delete obj;`
			`}`
			`}`
			`}`

fix animation 2018-11-25 03:24:41 +03:00			`QMap<int, GuiObject> Snake::init(int size, double speed) {`
world is done 2018-10-11 00:04:52 +03:00
			`QMap<int, GuiObject*> res;`
fix snake class 2018-09-11 22:08:08 +03:00
fix animation 2018-11-25 03:24:41 +03:00			`if (size <= 0) {`
world is done 2018-10-11 00:04:52 +03:00			`return res;`
Class Snake & Header Controller 2018-09-11 20:10:37 +03:00			`}`

render fix 2018-09-14 22:06:34 +03:00			`this->speed = speed;`
fix snake class 2018-09-11 22:08:08 +03:00
added first android version 2018-11-25 18:10:08 +03:00			`changeCountObjects(size - items.size());`
refactor 2018-10-11 18:09:35 +03:00
added funcrionaliti of diff objects on back-end 2018-11-04 16:11:55 +03:00			`for (auto i : items) {`
			`res[i->guiId()] = i;`
fix snake class 2018-09-11 22:08:08 +03:00			`}`
added texture 2018-11-28 22:17:30 +03:00
			`dead = false;`

world is done 2018-10-11 00:04:52 +03:00			`return res;`
Class Snake & Header Controller 2018-09-11 20:10:37 +03:00			`}`
fix snake class v2 2018-09-11 22:15:30 +03:00
added funcrionaliti of diff objects on back-end 2018-11-04 16:11:55 +03:00			`bool Snake::isInited() const {`
			`return items.size();`
			`}`

fix animation 2018-11-25 03:24:41 +03:00			`void Snake::clearItems() {`
render fix 2018-09-14 22:06:34 +03:00			`for (auto i : items) {`
fix snake class v2 2018-09-11 22:15:30 +03:00			`delete i;`
			`}`
render fix 2018-09-14 22:06:34 +03:00			`items.clear();`
fix animation 2018-11-25 03:24:41 +03:00			`}`
fix snake class v2 2018-09-11 22:15:30 +03:00
added first android version 2018-11-25 18:10:08 +03:00			`void Snake::resetPosotion() {`
			`double margin = 60.0 / items.size();`

			`for ( int i = 0; i < items.size(); ++i ) {`
			`items[i]->setX(margin * (items.size() - i));`
fix snake 2018-12-01 21:06:40 +03:00			`items[i]->setY(50 + items[i]->h() / 2);`
added first android version 2018-11-25 18:10:08 +03:00			`items[i]->setAngle(0);`
			`}`
			`}`

added texture 2018-11-28 22:17:30 +03:00			`void Snake::kill() {`
			`dead = true;`
			`}`

			`bool Snake::isDead() const {`
			`return dead;`
			`}`

fix animation 2018-11-25 03:24:41 +03:00			`Snake::~Snake() {`
			`clearItems();`
			`}`

			`void Snake::clear() {`
			`clearItems();`
fix snake class v2 2018-09-11 22:15:30 +03:00			`}`
world is done 2018-10-11 00:04:52 +03:00
fix: remove el& add snake on scene 2018-11-16 02:08:35 +03:00			`void Snake::reverse() {`
			`if (isClick) {`
			`return;`
			`}`
			`isClick = true;`
			`countClick++;`
			`}`