feat(game): В класс Game добавлен метод update вызывающий функцию tick

src/entities/ball/ball.js

@@ -0,0 +1,27 @@
+/**
+ * Класс сущности "мяч"
+ * @class
+ */
+export class Ball {
+  /**
+   * @param {number} x координата положения мяча по оси X
+   * @param {number} y координата положения мяча по оси Y
+   * @param {number} radius положительное числовое значение радиуса мяча
+   */
+  constructor(x, y, radius) {
+    this.x = x;
+    this.y = y;
+    this.horizontalSpeed = 0;
+    this.verticalSpeed = 0;
+    this.radius = radius;
+  }
+
+  /**
+   * Изменяет координаты в зависимости от скорости и времени
+   * @param {*} deltaTime изменение времени из Ticker
+   */
+  moveForward(deltaTime) {
+    this.x += this.horizontalSpeed * deltaTime;
+    this.y += this.verticalSpeed * deltaTime;
+  }
+}

src/entities/brick/brick.js

@@ -0,0 +1,24 @@
+/**
+ * Класс сущности "кирпич"
+ * @class
+ */
+export class Brick {
+  /**
+   *
+   * @param {number} x координата положения кирпича по оси X
+   * @param {number} y координата положения кирпича по оси Y
+   * @param {number} width положительное числовое значение ширины кирпича
+   * @param {number} height положительное числовое значение высоты кирпича
+   */
+  constructor(x, y, width, height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.alive = true;
+  }
+
+  kill() {
+    this.alive = false;
+  }
+}

src/entities/brick/layBricks/layBricks.js

@@ -0,0 +1,41 @@
+import { Brick } from '../brick';
+
+/**
+ * Ложит кирпичи по заданым размерам
+ * @param {number} columnAmount количество кирпичей по оси X, неотрицателное, целое число
+ * @param {number} rowAmount количество кирпичей по оси Y, неотрицателное, целое число
+ * @param {number} brickWidth ширина кирпича, неотрицателное число
+ * @param {number} brickHeight длина кирпича, неотрицателное число
+ * @returns {Brick[][]} массив с массивами кирпичей
+ */
+export function layBricks(columnAmount, rowAmount, brickWidth, brickHeight) {
+  try {
+    const someArgsArentNumbers = [columnAmount, rowAmount, brickWidth, brickHeight].some(
+      (arg) => typeof arg !== 'number',
+    );
+    if (someArgsArentNumbers) {
+      throw new Error('Параметры кладки кирпичей должны являться числами');
+    }
+
+    const someArgsLessThanZero = [columnAmount, rowAmount, brickWidth, brickHeight].some((arg) => arg < 0);
+    if (someArgsLessThanZero) {
+      throw new Error('Параметры кладки кирпичей должны являться положительными целыми числами');
+    }
+
+    const rowsOrColumnsAreFloat = [columnAmount, rowAmount].some((amount) => amount % 1 !== 0);
+    if (rowsOrColumnsAreFloat) {
+      throw new Error('Размеры рядов и колонок должны являться целыми числами');
+    }
+
+    const bricks = Array.from({ length: rowAmount }).map((_, rowIndex) =>
+      Array.from({ length: columnAmount }).map(
+        (_, columnIndex) => new Brick(columnIndex * brickWidth, rowIndex * brickHeight, brickWidth, brickHeight),
+      ),
+    );
+
+    return bricks;
+  } catch (err) {
+    console.error(err);
+    return null;
+  }
+}

src/entities/brick/layBricks/layBricks.test.js

@@ -0,0 +1,59 @@
+import { expect } from 'vitest';
+import { layBricks } from './layBricks';
+
+describe('layBricks', () => {
+  it('Возвращает корректное значение в случае неверного типа параметра', () => {
+    const wrongType = 'wrong';
+
+    expect(layBricks(wrongType, 1, 1, 1)).toBeNull();
+    expect(layBricks(1, wrongType, 1, 1)).toBeNull();
+    expect(layBricks(1, 1, wrongType, 1)).toBeNull();
+    expect(layBricks(1, 1, 1, wrongType)).toBeNull();
+  });
+
+  it('Возвращает корректное значение в случае неверных размеров кирпича', () => {
+    const wrongWidth = -1;
+    const wrongHeight = -1;
+
+    expect(layBricks(1, 1, wrongWidth, 1)).toBeNull();
+    expect(layBricks(1, 1, 1, wrongHeight)).toBeNull();
+  });
+
+  it('Возвращает корректное значение в случае неверных значений рядов и колонок', () => {
+    const negativeRow = -1;
+    const negativeColumn = -1;
+    const decimalRow = 1.5;
+    const decimalColumn = 1.5;
+
+    expect(layBricks(negativeRow, 1, 1, 1)).toBeNull();
+    expect(layBricks(1, negativeColumn, 1, 1)).toBeNull();
+    expect(layBricks(decimalRow, 1, 1, 1)).toBeNull();
+    expect(layBricks(1, decimalColumn, 1, 1)).toBeNull();
+  });
+
+  it('Возвращает массив корректных размеров', () => {
+    const columnAmount = 10;
+    const rowAmount = 5;
+
+    const bricks = layBricks(columnAmount, rowAmount, 1, 1);
+    expect(bricks.length).toEqual(rowAmount);
+    for (const row of bricks) {
+      expect(row.length).toEqual(columnAmount);
+    }
+  });
+
+  it('Задает корректные координаты кирпичам', () => {
+    const bricks = layBricks(3, 3, 1, 1);
+    const columnAmount = 10;
+    const rowAmount = 5;
+
+    const brickss = layBricks(columnAmount, rowAmount, 1, 1);
+
+    for (let i = 0; i < rowAmount; i++) {
+      for (let j = 0; j < columnAmount; j++) {
+        expect(brickss[i][j].x).toEqual(j);
+        expect(brickss[i][j]?.y).toEqual(i);
+      }
+    }
+  });
+});

src/entities/paddle/paddle.js

@@ -0,0 +1,29 @@
+/**
+ * Класс сущности "ракетка"
+ */
+export class Paddle {
+  /**
+   * @param {number} x координата положения ракетки по оси X
+   * @param {number} y координата положения ракетки по оси Y
+   * @param {number} width положительное числовое значение ширины ракетки
+   * @param {number} height положительное числовое значение высоты ракетки
+   */
+  constructor(x, y, width, height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+
+  /**
+   * Ограничивает минимальные и максимальные координаты положения ракетки на оси X
+   * @param {number} containerWidth ширина игрового поля
+   */
+  clampTo(containerWidth) {
+    if (this.x <= 0) {
+      this.x = 0;
+    } else if (this.x >= containerWidth - this.width) {
+      this.x = containerWidth - this.width;
+    }
+  }
+}

src/game.js

@@ -0,0 +1,41 @@
+import {
+  BALL_INITIAL_ANGLE,
+  BALL_RADIUS,
+  BALL_SPEED,
+  BRICK_HEIGHT,
+  BRICK_WIDTH,
+  CONTAINER_HEIGHT,
+  CONTAINER_WIDTH,
+  PADDLE_HEIGHT,
+  PADDLE_WIDTH,
+} from './config';
+import { Ball } from './entities/ball/ball';
+import { layBricks } from './entities/brick/layBricks/layBricks';
+import { Paddle } from './entities/paddle/paddle';
+
+/**
+ * Класс игры c информацией о всех игровых сущностях
+ */
+export class Game {
+  /**
+   * @param {number} columnAmount количество кирпичей по оси X, неотрицателное, целое число
+   * @param {number} rowAmount количество кирпичей по оси Y, неотрицателное, целое число
+   */
+  constructor(columnAmount, rowAmount) {
+    this.ball = new Ball(100, 100, BALL_RADIUS);
+    this.ball.horizontalSpeed = BALL_SPEED * Math.cos(BALL_INITIAL_ANGLE);
+    this.ball.verticalSpeed = -1 * BALL_SPEED * Math.sin(BALL_INITIAL_ANGLE);
+
+    this.paddle = new Paddle(0, CONTAINER_HEIGHT - PADDLE_HEIGHT, PADDLE_WIDTH, PADDLE_HEIGHT);
+
+    this.bricks = layBricks(columnAmount, rowAmount, BRICK_WIDTH, BRICK_HEIGHT);
+  }
+
+  /**
+   * Изменяет значения сущностей в зависимости от времени
+   * @param {*} deltaTime изменение времени из Ticker
+   */
+  update(deltaTime) {
+    tick(this, CONTAINER_WIDTH, CONTAINER_HEIGHT, deltaTime);
+  }
+}

src/lib/tick/tick.js

@@ -0,0 +1,100 @@
+import { CONTAINER_HEIGHT, CONTAINER_WIDTH } from '../../config';
+import { Game } from '../../game';
+import { calculateCollision } from '../calculateCollision/calculateCollision';
+import { calculateDirection } from '../calculateDirection/calculateDirection';
+
+/**
+ * Функция для вычисления взаимодействий сущностей игры в зависимости от времени из Ticker
+ * @param {Game} game экземпляр класса игры
+ * @param {number} containerWidth ширина игрового контейнера в пикселях
+ * @param {number} containerHeight высота игрового контейнера в пикселях
+ * @param {number} deltaTime изменение времени из Ticker
+ */
+export function tick(game, containerWidth, containerHeight, deltaTime) {
+  try {
+    if (!(game instanceof Game)) {
+      throw new Error('Аргумент game должен быть экземпляром класса игры');
+    }
+
+    if ([containerWidth, containerHeight].some((element) => typeof element !== 'number')) {
+      throw new Error('Значения размеров игрового контейнера должены являться числами');
+    }
+
+    if (containerWidth <= 0 || containerHeight <= 0) {
+      throw new Error('Размеры игрового контейнера должены быть положительными числами');
+    }
+
+    if (typeof deltaTime !== 'number' || deltaTime <= 0) {
+      throw new Error('Значение изменения времени должно быть положительным числом');
+    }
+
+    const { ball, paddle, bricks } = game;
+
+    ball.moveForward(deltaTime);
+
+    const leftBoundary = ball.radius;
+    const rightBoundary = containerWidth - ball.radius;
+    const topBoundary = ball.radius;
+    const bottomBoundary = containerHeight - ball.radius;
+
+    // Не даем мячу выйти за границы стен слева / справав и меняем направление
+    if (ball.x <= leftBoundary || ball.x >= rightBoundary) {
+      ball.x = ball.x <= leftBoundary ? leftBoundary : rightBoundary;
+      ball.horizontalSpeed *= -1;
+    }
+
+    // Не даем мячу выйти за границы стен сверху / снизу и меняем направление
+    if (ball.y <= topBoundary || ball.y >= bottomBoundary) {
+      ball.y = ball.y <= topBoundary ? topBoundary : bottomBoundary;
+      ball.verticalSpeed *= -1;
+    }
+
+    // Базоввое взаимодействие мяча и кирпича
+    for (const row of bricks) {
+      for (const brick of row) {
+        if (!brick.alive) {
+          continue;
+        }
+
+        const ballLeft = ball.x - ball.radius;
+        const ballRight = ball.x + ball.radius;
+        const ballTop = ball.y - ball.radius;
+        const ballBottom = ball.y + ball.radius;
+
+        const brickLeft = brick.x;
+        const brickRight = brick.x + brick.width;
+        const brickTop = brick.y;
+        const brickBottom = brick.y + brick.height;
+
+        const ballObject = { left: ballLeft, right: ballRight, top: ballTop, bottom: ballBottom };
+        const brickObject = { left: brickLeft, right: brickRight, top: brickTop, bottom: brickBottom };
+
+        const isCollided = calculateCollision(ballObject, brickObject);
+
+        if (isCollided) {
+          const directions = calculateDirection(ballObject, brickObject);
+
+          if (directions !== null) {
+            ball.horizontalSpeed *= directions[0];
+            ball.verticalSpeed *= directions[1];
+            brick.kill();
+            break;
+          }
+        }
+      }
+    }
+
+    // Базоввое взаимодействие мяча и ракетки
+    if (
+      ball.verticalSpeed > 0 &&
+      ball.y + ball.radius >= paddle.y &&
+      ball.x >= paddle.x &&
+      ball.x <= paddle.x + paddle.width
+    ) {
+      verticalSpeed *= -1;
+    }
+  } catch (err) {
+    console.error(err);
+    return null;
+  }
+}

src/lib/tick/tick.test.js

@@ -0,0 +1,78 @@
+import { CONTAINER_HEIGHT, CONTAINER_WIDTH } from '../../config';
+import { Game } from '../../game';
+import { tick } from './tick';
+
+describe('tick', () => {
+  it('Возвращает корректное значние при неверных типах аргументов', () => {
+    expect(tick(null, 1, 1, 1)).toBeNull();
+    expect(tick(1, null, 1, 1)).toBeNull();
+    expect(tick(1, 1, null, 1)).toBeNull();
+    expect(tick(1, 1, 1, null)).toBeNull();
+  });
+
+  it('Возвращает корректное значние и не изменяет свойства game при неверых размерах контейнера', () => {
+    const game = new Game(1, 1);
+    const ballX = game.ball.x;
+    const ballY = game.ball.y;
+    expect(tick(game, -1, -1, 1)).toBeNull();
+    expect(game.ball.x).toBe(ballX);
+    expect(game.ball.y).toBe(ballY);
+  });
+
+  it('Возвращает корректное значние и не изменяет свойства game при неверном значении времени', () => {
+    const game = new Game(1, 1);
+    const ballX = game.ball.x;
+    const ballY = game.ball.y;
+    expect(tick(game, 1, 1, -1)).toBeNull();
+    expect(game.ball.x).toBe(ballX);
+    expect(game.ball.y).toBe(ballY);
+  });
+
+  it('Меняет направление мяча при столкновении со стеной', () => {
+    const game = new Game(1, 1);
+    game.ball.x = 0;
+    game.ball.horizontalSpeed = -10;
+    tick(game, CONTAINER_WIDTH, CONTAINER_HEIGHT, 1);
+    expect(game.ball.x).toBe(10);
+    expect(game.ball.horizontalSpeed).toBe(10);
+  });
+
+  it('Меняет направление мяча при столкновении с потолком', () => {
+    const game = new Game(0, 0);
+    game.ball.y = 0;
+    game.ball.verticalSpeed = -10;
+    tick(game, CONTAINER_WIDTH, CONTAINER_HEIGHT, 1);
+    expect(game.ball.y).toBe(game.ball.radius);
+    expect(game.ball.verticalSpeed).toBe(10);
+  });
+
+  it('Убивает кирпич при столкновении и отражает мяч', () => {
+    const game = new Game(1, 1);
+    const brick = game.bricks[0][0];
+
+    game.ball.x = brick.x + 1;
+    game.ball.y = brick.y + brick.height + game.ball.radius + 1;
+    game.ball.horizontalSpeed = 0;
+    game.ball.verticalSpeed = -10;
+
+    tick(game, CONTAINER_WIDTH, CONTAINER_HEIGHT, 0.1);
+
+    expect(brick.alive).toBe(false);
+    expect(game.ball.verticalSpeed).toBe(10);
+  });
+
+  it('Убивает только один кирпич за тик', () => {
+    const game = new Game(2, 1);
+    const [firstBrick, secondBrick] = game.bricks[0];
+
+    game.ball.x = firstBrick.x + 1;
+    game.ball.y = firstBrick.y + firstBrick.height + game.ball.radius + 1;
+    game.ball.horizontalSpeed = 0;
+    game.ball.verticalSpeed = -10;
+
+    tick(game, CONTAINER_WIDTH, CONTAINER_HEIGHT, 0.1);
+
+    const killedCount = game.bricks[0].filter((b) => !b.alive).length;
+    expect(killedCount).toBe(1);
+  });
+});