Что изучать для совершенствования знаний по C++

Describe(Tests)
{
    It(ExampleTests)
    {
        Assert::That(sequenceSum(2, 6, 2), Is().EqualTo(12));
        Assert::That(sequenceSum(1, 5, 1), Is().EqualTo(15));
        Assert::That(sequenceSum(1, 5, 3), Is().EqualTo(5));
        Assert::That(sequenceSum(0, 15, 3), Is().EqualTo(45));
        Assert::That(sequenceSum(16, 15, 3), Is().EqualTo(0));
        Assert::That(sequenceSum(2, 24, 22), Is().EqualTo(26));
        Assert::That(sequenceSum(2, 2, 2), Is().EqualTo(2));
        Assert::That(sequenceSum(2, 2, 1), Is().EqualTo(2));
        Assert::That(sequenceSum(1, 15, 3), Is().EqualTo(35));
        Assert::That(sequenceSum(15, 1, 3), Is().EqualTo(0));    
    }
};;

Assert::That(sequenceSum(16, 15, 3), Is().EqualTo(0));

#include <gtest/gtest.h>
#include "Kata.h"
 
TEST(Kata, Test01)
{
    ASSERT_EQ(Kata::SequenceSum(2, 6, 2), 12);
}
 
TEST(Kata, Test02)
{
    ASSERT_EQ(Kata::SequenceSum(1, 5, 1), 15);
}

for (auto it = ++snake.begin(); it != snake.end();)
        {
            int snakeX = (*it).x;
            int snakeY = (*it).y;
            if (newPos.x == snakeX && newPos.y == snakeY)
            {
                dirSnake = false;
            }
        }

for (auto it = ++snake.begin(); it != snake.end(); ++it)
        {
            int snakeX = (*it).x;
            int snakeY = (*it).y;
            if (newPos.x == snakeX && newPos.y == snakeY)
            {
                dirSnake = false;
            }
        }

dirSnake = false;

    bool dirSnake = true;
    for (auto it = ++snake.begin(); it != snake.end(); ++it)
    {
        int snakeX = (*it).x;
        int snakeY = (*it).y;
        if (newPos.x == snakeX && newPos.y == snakeY)
        {
            dirSnake = false;
            std::cout << "Hello" << std::endl;
        }
    }

void update(int value)
{
    Vector2i newPos;
    newPos.x = snake.front().x + snakeDir.x;
    newPos.y = snake.front().y + snakeDir.y;
    snake.push_front(newPos);
    snake.pop_back();
 
    int xHead = snake.front().x;
    int yHead = snake.front().y;
 
    if (xHead == food.x && yHead == food.y)
    {
        Vector2i cell = { food.x, food.y };
        snake.push_back(cell);
 
        // Generate a new food
        food.x = getRandomInt(gameFieldSize);
        food.y = getRandomInt(gameFieldSize);
    }
 
    glutTimerFunc(250, update, 0);
    glutPostRedisplay(); // Draw all game objects
}

        for (auto it = ++snake.begin(); it != snake.end(); ++it)
        {
            int snakeX = (*it).x;
            int snakeY = (*it).y;
            if (newPos.x == snakeX && newPos.y == snakeY)
            {
                dirSnake = false;
            }
        }

#include <gtest/gtest.h>
#include "Kata.h"
 
TEST(Kata, Test01)
{
    ASSERT_EQ(Kata::SequenceSum(2, 6, 2), 12);
}
 
TEST(Kata, Test02)
{
    ASSERT_EQ(Kata::SequenceSum(1, 5, 1), 15);
}

#include <gtest/gtest.h>
#include "Kata.h"
 
TEST(Kata, Test01)
{
    ASSERT_EQ(Kata::SequenceSum(2, 6, 2), 12);
}
 
TEST(Kata, Test02)
{
    ASSERT_EQ(Kata::SequenceSum(1, 5, 1), 15);
}
TEST(Kata, Test03)
{
    ASSERT_EQ(Kata::basicOp('+', 5, 4), 9);
    
}
TEST(Kata, Test04)
{
    ASSERT_EQ(Kata::basicOp('-', 11, 8), 3);  
}
TEST(Kata, Test05)
{
    ASSERT_EQ(Kata::basicOp('*', 3, 4), 12);
}
TEST(Kata, Test06)
{
    ASSERT_EQ(Kata::basicOp('/', 16, 4), 4);
}

TEST(Kata, Test01)
{
    ASSERT_EQ(Kata::SequenceSum(2, 6, 2), 12);
}
 
TEST(Kata, Test02)
{
    ASSERT_EQ(Kata::SequenceSum(1, 5, 1), 15);
}

#include "Kata.h"

Describe(Tests)
{
    It(ExampleTests)
    {
        Assert::That(sequenceSum(2, 6, 2), Is().EqualTo(12));
        Assert::That(sequenceSum(1, 5, 1), Is().EqualTo(15));
        Assert::That(sequenceSum(1, 5, 3), Is().EqualTo(5));
        Assert::That(sequenceSum(0, 15, 3), Is().EqualTo(45));
        Assert::That(sequenceSum(16, 15, 3), Is().EqualTo(0));
        Assert::That(sequenceSum(2, 24, 22), Is().EqualTo(26));
        Assert::That(sequenceSum(2, 2, 2), Is().EqualTo(2));
        Assert::That(sequenceSum(2, 2, 1), Is().EqualTo(2));
        Assert::That(sequenceSum(1, 15, 3), Is().EqualTo(35));
        Assert::That(sequenceSum(15, 1, 3), Is().EqualTo(0));    
    }
};;

#include <GL/freeglut.h>
#include <iostream>
#include <string>
#include <list>
#include <ctime>
 
using namespace std;
 
bool dirSnake = true;
int lives = 3;
int score = 0;
 
const int gameFieldSize = 20;
 
int fieldWidth = 260;
int fieldHeight = 260;
 
struct Color3f
{
    float r = 0.5f;
    float g = 0.5f;
float b = 0.5f;
};
 
struct Vector2i
{
    int x, y;
};
 
Vector2i snakeDir{ 1, 0 };
 
list<Vector2i> snake;
 
Vector2i food;
 
void drawText(float x, float y, string text)
{
    glColor3f(1.0f, 1.0f, 1.0f);
 
    glRasterPos2f(x, y);
    glutBitmapString(GLUT_BITMAP_8_BY_13, (const unsigned char*)text.c_str());
}
 
void drawSquare(int x, int y, int size, Color3f color)
{
    const float padding = 0.1f;
 
    glColor3f(color.r, color.g, color.b);
 
    glBegin(GL_QUADS);
    glVertex2f(x + padding, y + padding);
    glVertex2f(x + size - padding, y + padding);
    glVertex2f(x + size - padding, y + size - padding);
    glVertex2f(x + padding, y + size - padding);
    glEnd();
}
 
void drawFood()
{
    Color3f foodColor;
    foodColor.r = 0.0f;
    foodColor.g = 0.5f;
    foodColor.b = 0.5f;
    drawSquare(food.x, food.y, 1, foodColor);
}
 
void drawSnake()
{
    Color3f snakeColor;
    snakeColor.r = 0.0f;
    snakeColor.g = 1.0f;
    snakeColor.b = 0.0f;
    for (auto const& cell : snake)
    {
        drawSquare(cell.x, cell.y, 1, snakeColor);
    }
}
 
void drawRectangle(float x, float y, float width, float height)
{
    glBegin(GL_QUADS);
    glVertex2f(x, y);
    glVertex2f(x + width, y);
    glVertex2f(x + width, y + height);
    glVertex2f(x, y + height);
    glEnd();
}
 
void draw()
{
    glClear(GL_COLOR_BUFFER_BIT);
    drawText(0, 19, "Score: " + to_string(score));
    drawText(15, 19, "Lives: " + to_string(lives));
    if (score >= 10)
    {
        drawText(gameFieldSize / 3, gameFieldSize / 2, "You win the game");
    }
    if (dirSnake == false)
    {
        drawText(gameFieldSize / 3, gameFieldSize / 2, "You lose the game");
    }
    drawFood();
    drawSnake();
 
    glutSwapBuffers();
}
 
int getRandomInt(int max)
{
    srand(time(0));
    return rand() % max;
    return 0;
}
 
void update(int value)
{
    if (score >= 10)
    {
        dirSnake = false;
    }
    if (dirSnake)
    {
        Vector2i newPos;
        int xHead = snake.front().x;
        int yHead = snake.front().y;
        if (xHead >= gameFieldSize)
        {
        snake.front().x = -1;
        }
        else if (xHead == -1)
        {
        snake.front().x = gameFieldSize;
        }
        else if (yHead >= gameFieldSize)
        {
            snake.front().y = -1;
        }
        else if (yHead == -1)
        {
        snake.front().y = gameFieldSize;
        }
 
        newPos.x = snake.front().x + snakeDir.x;
        newPos.y = snake.front().y + snakeDir.y;
        snake.push_front(newPos);
        snake.pop_back();
 
        for (auto it = ++snake.begin(); it != snake.end(); ++it)
        {
            int snakeX = (*it).x;
            int snakeY = (*it).y;
            if (newPos.x == snakeX && newPos.y == snakeY)
            {
                dirSnake = false;
                cout << "Warning" << endl;
            }
        }
 
        if (xHead == food.x && yHead == food.y)
        {
            score++;
            Vector2i cell = { food.x, food.y };
            snake.push_back(cell);
 
            // Generate a new food
            food.x = getRandomInt(gameFieldSize);
            food.y = getRandomInt(gameFieldSize);
        }
 
        glutTimerFunc(150, update, 0);
        glutPostRedisplay();
    }
    
}
 
void specialKeyHandler(int key, int x, int y)
{
    switch (key)
    {
    case GLUT_KEY_UP:
        if (snakeDir.y == 0) {
            snakeDir.x = 0;
            snakeDir.y = 1;
        }
        break;
    case GLUT_KEY_LEFT:
        if (snakeDir.x == 0) {
            snakeDir.x = -1;
            snakeDir.y = 0;
        }
        break;
    case GLUT_KEY_DOWN:
        if (snakeDir.y == 0) {
            snakeDir.x = 0;
            snakeDir.y = -1;
        }
        break;
    case GLUT_KEY_RIGHT:
        if (snakeDir.x == 0) {
            snakeDir.x = 1;
            snakeDir.y = 0;
        }
        break;
    }
}
 
void normalKeyHandler(unsigned char key, int x, int y)
{
    switch (key)
    {
    case 'w':
        if (snakeDir.y == 0) {
            snakeDir.x = 0;
            snakeDir.y = 1;
        }
        break;
    case 'a':
        if (snakeDir.x == 0) {
            snakeDir.x = -1;
            snakeDir.y = 0;
        }
        break;
    case 's':
        if (snakeDir.y == 0) {
            snakeDir.x = 0;
            snakeDir.y = -1;
        }
        break;
    case 'd':
        if (snakeDir.x == 0) {
            snakeDir.x = 1;
            snakeDir.y = 0;
        }
        break;
    default:
        cout << "This key is not used: " << key << endl;
        break;
    }
}
 
void setNewCoordSystem(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0f, gameFieldSize, 0.0f, gameFieldSize, 0.0f, 1.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
 
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(fieldWidth, fieldHeight);
    glutCreateWindow("Snake");
    glutDisplayFunc(draw);
    glutTimerFunc(250, update, 0);
 
    glutKeyboardFunc(normalKeyHandler);
    glutSpecialFunc(specialKeyHandler);
 
    setNewCoordSystem(fieldWidth, fieldHeight);
 
    Vector2i head = { 4, 1 };
    snake.push_back(head);
    
    glutMainLoop();
    return 0;
}