Snake_Game/SnakeModel.cpp at main · WatchDog-156/Snake_Game · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
//
// Created by c on 4/24/24.
//

#include "SnakeModel.h"
#include <algorithm>

SnakeModel::SnakeModel(GameMode gamemode): gamemode(gamemode) {
    snake.emplace_back(0,0);
    snake.emplace_front(0,1);
    switch (gamemode){
        case EASY: velocity=8.0f; break;
        case NORMAL: velocity=10.0f; break;
        case HARD: velocity=20.0f; break;
        case DEBUG: velocity=10.0f; break;
    }
    direction=RIGHT;
    eatenFood=0;
}

bool SnakeModel::isTail(int row, int col) const {
    for(int tailNr=1; tailNr<static_cast<int>(snake.size()); ++tailNr)
        if(snake[tailNr].first==row and snake[tailNr].second==col) return true;
    return false;
}

bool SnakeModel::isTailEnd(int row, int col) const {
    int tailEnd=static_cast<int>(snake.size())-1;
    return snake[tailEnd].first==row and snake[tailEnd].second==col;
}

void SnakeModel::moveSnake() {
    int headRow=snake[0].first;
    int headCol=snake[0].second;
    switch (direction) {
        case UP: snake.emplace_front(headRow-1,headCol); break;
        case DOWN: snake.emplace_front(headRow+1,headCol); break;
        case RIGHT: snake.emplace_front(headRow,headCol+1); break;
        case LEFT: snake.emplace_front(headRow,headCol-1); break;
    }
}

void SnakeModel::reduceSnakeTail(bool hasFood) {
    if(hasFood) ++eatenFood;
    else snake.pop_back();
}

void SnakeModel::turn(Direction turnDirection) {
    if(turnDirection==RIGHT) {
        switch (direction) {
            case UP: direction=RIGHT; break;
            case RIGHT: direction=DOWN; break;
            case DOWN: direction=LEFT; break;
            case LEFT: direction=UP; break;
        }
    }
    if(turnDirection==LEFT) {
        switch (direction) {
            case UP: direction=LEFT; break;
            case RIGHT: direction=UP; break;
            case DOWN: direction=RIGHT; break;
            case LEFT: direction=DOWN; break;
        }
    }
}

//if on the field is snake head and tail      - return 'x' character
//if on the field is snake head               - return 'H' character
//if on the field is snake tail end           - return 'T' character
//if on the field is snake tail               - return 'B' character
//if on the field isn't snake                 - return ' ' character
char SnakeModel::getSnakeInfo(int row, int col) const {
    if(isHead(row,col) and isTail(row,col)) return 'x';
    if(isHead(row,col)) return 'H';
    if(isTailEnd(row,col)) return 'T';
    if(isTail(row,col)) return 'B';
    return ' ';
}

//function has to get a field with snake part and snake can't have gaps in itself
Direction SnakeModel::getSnakePartDirection(int row, int col) const {
    for(int tailNr=static_cast<int>(snake.size())-1; tailNr>0; --tailNr)
        if(snake[tailNr].first==row and snake[tailNr].second==col) {
            if(snake[tailNr].first-snake[tailNr-1].first==-1) return DOWN;
            if(snake[tailNr].first-snake[tailNr-1].first==1) return UP;
            if(snake[tailNr].second-snake[tailNr-1].second==-1) return RIGHT;
            if(snake[tailNr].second-snake[tailNr-1].second==1) return LEFT;
        }
    //if snake has anomaly(e.g. snake go left and next go right) or field doesn't have a snake part, function return direction
    return direction;
}

//function has to get a field with snake part and snake can't have gaps in itself
Direction SnakeModel::turnDirection(int row, int col) const {
    for(int tailNr=static_cast<int>(snake.size())-2; tailNr>0; --tailNr)
        if(snake[tailNr].first==row and snake[tailNr].second==col) {
            //snake go straight
            if(getSnakePartDirection(row,col)==getSnakePartDirection(snake[tailNr+1].first, snake[tailNr+1].second))
                return UP;

            //snake turn left
            switch(getSnakePartDirection(row,col)) {
                case UP:
                    if(getSnakePartDirection(snake[tailNr+1].first, snake[tailNr+1].second)==RIGHT) return LEFT;
                    break;
                case RIGHT:
                    if(getSnakePartDirection(snake[tailNr+1].first, snake[tailNr+1].second)==DOWN) return LEFT;
                    break;
                case DOWN:
                    if(getSnakePartDirection(snake[tailNr+1].first, snake[tailNr+1].second)==LEFT) return LEFT;
                    break;
                case LEFT:
                    if(getSnakePartDirection(snake[tailNr+1].first, snake[tailNr+1].second)==UP) return LEFT;
                    break;
            }

            //snake turn right
            return RIGHT;
        }
    //if snake has anomaly(e.g. snake go left and next go right) or field doesn't have a snake part, function return direction
    return direction;
}