Разработка игр на C++: от консольной змейки до создания движка

#include <iostream>
#include <conio.h>
#include <windows.h>
using namespace std;

bool gameOver;
const int width = 20;
const int height = 20;
int x, y, fruitX, fruitY, score;
enum eDirection { STOP = 0, LEFT, RIGHT, UP, DOWN };
eDirection dir;
int tailX[100], tailY[100];
int nTail;

void Setup() {
gameOver = false;
dir = STOP;
x = width / 2;
y = height / 2;
fruitX = rand() % width;
fruitY = rand() % height;
score = 0;
}

void Draw() {
system("cls");
for (int i = 0; i < width+2; i++)
cout << "#";
cout << endl;

for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
if (j == 0)
cout << "#";
if (i == y && j == x)
cout << "O";
else if (i == fruitY && j == fruitX)
cout << "F";
else {
bool print = false;
for (int k = 0; k < nTail; k++) {
if (tailX[k] == j && tailY[k] == i) {
cout << "o";
print = true;
}
}
if (!print)
cout << " ";
}
if (j == width – 1)
cout << "#";
}
cout << endl;
}

for (int i = 0; i < width+2; i++)
cout << "#";
cout << endl;
cout << "Score:" << score << endl;
}

#include <SDL.h>

int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_EVERYTHING);

SDL_Window* window = SDL_CreateWindow(
"Моя первая игра",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
640, 480,
SDL_WINDOW_SHOWN
);

SDL_Renderer* renderer = SDL_CreateRenderer(
window, -1, SDL_RENDERER_ACCELERATED
);

bool isRunning = true;
SDL_Event event;

// Игровой цикл
while (isRunning) {
// Обработка событий
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
isRunning = false;
}
}

// Обновление состояния игры

// Отрисовка
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);

// Здесь рисуем игровые объекты

SDL_RenderPresent(renderer);

// Ограничение FPS
SDL_Delay(1000/60);
}

SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();

return 0;
}

class Tetromino {
private:
int x, y; // Позиция
int type; // Тип фигуры (I, J, L, O, S, T, Z)
int rotation; // Текущий поворот

// Массивы форм для каждого типа тетрамино
const int shapes[7][4][4][4] = { ... };

public:
Tetromino(int type) : type(type), rotation(0), x(5), y(0) {}

// Проверяет, можно ли переместить фигуру
bool canMove(int dx, int dy, const int field[20][10]) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (shapes[type][rotation][i][j] != 0) {
int newX = x + j + dx;
int newY = y + i + dy;

if (newX < 0 || newX >= 10 || newY >= 20) 
return false;

if (newY >= 0 && field[newY][newX] != 0) 
return false;
}
}
}
return true;
}

// Перемещает фигуру
void move(int dx, int dy) {
x += dx;
y += dy;
}

// Поворачивает фигуру
void rotate() {
rotation = (rotation + 1) % 4;
}

// Размещает фигуру на поле
void placeOnField(int field[20][10]) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (shapes[type][rotation][i][j] && y + i >= 0) {
field[y + i][x + j] = shapes[type][rotation][i][j];
}
}
}
}
};

class TetrisGame {
private:
int field[20][10] = {0};
Tetromino* currentPiece;
bool gameOver = false;
int score = 0;

public:
TetrisGame() {
spawnNewPiece();
}

void update() {
if (gameOver) return;

// Попытка сдвинуть фигуру вниз
if (currentPiece->canMove(0, 1, field)) {
currentPiece->move(0, 1);
} else {
// Если движение невозможно, размещаем фигуру на поле
currentPiece->placeOnField(field);

// Проверяем заполненные ряды
checkLines();

// Создаём новую фигуру
spawnNewPiece();

// Проверяем условие окончания игры
if (!currentPiece->canMove(0, 0, field)) {
gameOver = true;
}
}
}

void spawnNewPiece() {
int randomType = rand() % 7;
delete currentPiece;
currentPiece = new Tetromino(randomType);
}

void checkLines() {
for (int i = 19; i >= 0; i--) {
bool fullLine = true;

for (int j = 0; j < 10; j++) {
if (field[i][j] == 0) {
fullLine = false;
break;
}
}

if (fullLine) {
// Удаляем заполненную линию
for (int k = i; k > 0; k--) {
for (int j = 0; j < 10; j++) {
field[k][j] = field[k-1][j];
}
}

// Очищаем верхнюю линию
for (int j = 0; j < 10; j++) {
field[0][j] = 0;
}

// Увеличиваем счёт
score += 100;

// Проверяем эту же линию снова
i++;
}
}
}
};

// Базовый компонент
class Component {
public:
virtual ~Component() {}
virtual void Update(float deltaTime) {}
virtual void Render() {}
};

// Класс игрового объекта
class GameObject {
private:
std::vector<Component*> components;
bool active = true;
std::string name;
Vector2 position;

public:
GameObject(const std::string& name, const Vector2& position)
: name(name), position(position) {}

~GameObject() {
for (auto component : components) {
delete component;
}
components.clear();
}

template<typename T, typename... Args>
T* AddComponent(Args&&... args) {
T* component = new T(std::forward<Args>(args)...);
components.push_back(component);
return component;
}

template<typename T>
T* GetComponent() {
for (auto component : components) {
T* castedComponent = dynamic_cast<T*>(component);
if (castedComponent) return castedComponent;
}
return nullptr;
}

void Update(float deltaTime) {
if (!active) return;
for (auto component : components) {
component->Update(deltaTime);
}
}

void Render() {
if (!active) return;
for (auto component : components) {
component->Render();
}
}

void SetActive(bool value) { active = value; }
bool IsActive() const { return active; }
Vector2 GetPosition() const { return position; }
void SetPosition(const Vector2& newPosition) { position = newPosition; }
};

// Менеджер сцены
class Scene {
private:
std::vector<GameObject*> gameObjects;

public:
~Scene() {
for (auto object : gameObjects) {
delete object;
}
gameObjects.clear();
}

GameObject* CreateGameObject(const std::string& name, const Vector2& position) {
GameObject* object = new GameObject(name, position);
gameObjects.push_back(object);
return object;
}

void Update(float deltaTime) {
for (auto object : gameObjects) {
object->Update(deltaTime);
}
}

void Render() {
for (auto object : gameObjects) {
object->Render();
}
}
};

// Пример компонента – спрайт
class SpriteComponent : public Component {
private:
SDL_Texture* texture;
SDL_Rect sourceRect;
SDL_Rect destRect;
GameObject* gameObject;

public:
SpriteComponent(GameObject* gameObject, SDL_Texture* texture)
: gameObject(gameObject), texture(texture) {
sourceRect = {0, 0, 32, 32};
destRect = {0, 0, 32, 32};
}

void Update(float deltaTime) override {
Vector2 position = gameObject->GetPosition();
destRect.x = static_cast<int>(position.x);
destRect.y = static_cast<int>(position.y);
}

void Render() override {
SDL_RenderCopy(renderer, texture, &sourceRect, &destRect);
}
};

// Уникальный идентификатор для каждой сущности
using EntityID = std::uint32_t;

// Базовый класс для всех компонентов
struct Component {
virtual ~Component() = default;
};

// Пример компонента позиции
struct PositionComponent : Component {
float x, y;
PositionComponent(float x, float y) : x(x), y(y) {}
};

// Пример компонента скорости
struct VelocityComponent : Component {
float x, y;
VelocityComponent(float x, float y) : x(x), y(y) {}
};

// Регистр компонентов
class ComponentRegistry {
private:
std::unordered_map<std::type_index, std::unordered_map<EntityID, std::shared_ptr<Component>>> components;

public:
template<typename T>
void RegisterComponent(EntityID entity, std::shared_ptr<T> component) {
components[typeid(T)][entity] = component;
}

template<typename T>
std::shared_ptr<T> GetComponent(EntityID entity) {
auto& componentMap = components[typeid(T)];
auto it = componentMap.find(entity);
if (it != componentMap.end()) {
return std::static_pointer_cast<T>(it->second);
}
return nullptr;
}

template<typename T>
std::vector<std::pair<EntityID, std::shared_ptr<T>>> GetAllComponentsOfType() {
std::vector<std::pair<EntityID, std::shared_ptr<T>>> result;
auto& componentMap = components[typeid(T)];
for (auto& [entity, component] : componentMap) {
result.emplace_back(entity, std::static_pointer_cast<T>(component));
}
return result;
}
};

// Базовый класс для всех систем
class System {
protected:
ComponentRegistry& registry;

public:
System(ComponentRegistry& registry) : registry(registry) {}
virtual ~System() = default;
virtual void Update(float deltaTime) = 0;
};

// Система движения
class MovementSystem : public System {
public:
using System::System;

void Update(float deltaTime) override {
// Получаем все сущности с компонентами позиции и скорости
auto posComponents = registry.GetAllComponentsOfType<PositionComponent>();

for (auto& [entity, posComp] : posComponents) {
auto velComp = registry.GetComponent<VelocityComponent>(entity);
if (velComp) {
// Обновляем позицию на основе скорости
posComp->x += velComp->x * deltaTime;
posComp->y += velComp->y * deltaTime;
}
}
}
};

template<typename T>
class ObjectPool {
private:
std::vector<std::unique_ptr<T>> objects;
std::vector<T*> availableObjects;

public:
ObjectPool(size_t initialSize) {
Resize(initialSize);
}

void Resize(size_t newSize) {
size_t oldSize = objects.size();
if (newSize <= oldSize) return;

objects.reserve(newSize);
availableObjects.reserve(newSize);

for (size_t i = oldSize; i < newSize; ++i) {
objects.push_back(std::make_unique<T>());
availableObjects.push_back(objects.back().get());
}
}

T* Get() {
if (availableObjects.empty()) {
// Если пул пуст, увеличиваем его размер
Resize(objects.size() * 2);
}

T* object = availableObjects.back();
availableObjects.pop_back();
return object;
}

void Return(T* object) {
availableObjects.push_back(object);
}
};

// Пример использования:
class Bullet {
public:
void Reset() {
// Сбросить состояние пули
active = false;
x = 0;
y = 0;
}

void Fire(float startX, float startY, float dirX, float dirY) {
active = true;
x = startX;
y = startY;
velocityX = dirX;
velocityY = dirY;
}

void Update(float deltaTime) {
if (!active) return;
x += velocityX * deltaTime;
y += velocityY * deltaTime;
// Проверка столкновений и т.д.
}

private:
bool active = false;
float x = 0, y = 0;
float velocityX = 0, velocityY = 0;
};

// Создаем пул из 100 пуль
ObjectPool<Bullet> bulletPool(100);

// Выстрел
void FireBullet(float x, float y, float dirX, float dirY) {
Bullet* bullet = bulletPool.Get();
bullet->Reset();
bullet->Fire(x, y, dirX, dirY);
// Добавляем пулю в список активных пуль
}

// Когда пуля больше не нужна (вылетела за экран или попала в цель):
void DeactivateBullet(Bullet* bullet) {
bulletPool.Return(bullet);
}

class SpriteBatcher {
private:
struct SpriteData {
SDL_Texture* texture;
SDL_Rect sourceRect;
SDL_Rect destRect;
double angle;
SDL_RendererFlip flip;
};

std::map<SDL_Texture*, std::vector<SpriteData>> batches;

public:
void AddSprite(SDL_Texture* texture, const SDL_Rect& sourceRect, 
const SDL_Rect& destRect, double angle = 0, 
SDL_RendererFlip flip = SDL_FLIP_NONE) {
batches[texture].push_back({texture, sourceRect, destRect, angle, flip});
}

void Render(SDL_Renderer* renderer) {
for (auto& [texture, sprites] : batches) {
// Рисуем все спрайты с одинаковой текстурой за один вызов
for (auto& sprite : sprites) {
SDL_RenderCopyEx(
renderer, 
sprite.texture, 
&sprite.sourceRect, 
&sprite.destRect, 
sprite.angle, 
nullptr, 
sprite.flip
);
}
}

// Очищаем батчи после рендеринга
batches.clear();
}
};

#include <SFML/Graphics.hpp>

int main() {
// Создаем окно размером 800x600 с заголовком "SFML Game"
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Game");

// Загружаем текстуру
sf::Texture texture;
if (!texture.loadFromFile("sprite.png")) {
// Обработка ошибки загрузки
return -1;
}

// Создаем спрайт и привязываем к нему текстуру
sf::Sprite sprite(texture);

// Задаем начальное положение спрайта
sprite.setPosition(400, 300);

// Основной игровой цикл
while (window.isOpen()) {
sf::Event event;
while (window.pollEvent(event)) {
// Обработка событий
if (event.type == sf::Event::Closed) {
window.close();
}
}

// Очистка окна
window.clear();

// Отрисовка спрайта
window.draw(sprite);

// Отображение всего на экране
window.display();
}

return 0;
}

// Инициализация SDL и создание окна
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* window = SDL_CreateWindow("Game", SDL_WINDOWPOS_CENTERED, 
SDL_WINDOWPOS_CENTERED, 800, 600, 0);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

// Инициализация Box2D
b2World world(b2Vec2(0.0f, 9.8f)); // Гравитация

// Создаем тело в физическом мире
b2BodyDef bodyDef;
bodyDef.type = b2_dynamicBody;
bodyDef.position.Set(5.0f, 4.0f);
b2Body* body = world.CreateBody(&bodyDef);

// Добавляем форму к телу
b2PolygonShape box;
box.SetAsBox(1.0f, 1.0f);
b2FixtureDef fixtureDef;
fixtureDef.shape = &box;
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.3f;
body->CreateFixture(&fixtureDef);

// Игровой цикл
bool running = true;
while (running) {
// Обработка событий
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
}
}

// Обновление физики
world.Step(1.0f/60.0f, 6, 2);

// Рисование
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);

// Получаем позицию из физического мира и рисуем объект
b2Vec2 position = body->GetPosition();
SDL_Rect rect = {
static_cast<int>(position.x * 30), 
static_cast<int>(position.y * 30),
60, 60
};
SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
SDL_RenderFillRect(renderer, &rect);

SDL_RenderPresent(renderer);
}

// Очистка ресурсов
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();

// Пример простого класса актора в Unreal Engine
UCLASS()
class MYGAME_API AMyActor : public AActor {
GENERATED_BODY()

public: 
AMyActor();

virtual void Tick(float DeltaTime) override;

protected:
virtual void BeginPlay() override;

private:
UPROPERTY(VisibleAnywhere)
UStaticMeshComponent* MeshComponent;

UPROPERTY(EditAnywhere, Category = "Movement")
float MovementSpeed = 100.0f;
};

AMyActor::AMyActor() {
PrimaryActorTick.bCanEverTick = true;

MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComponent"));
RootComponent = MeshComponent;
}

void AMyActor::BeginPlay() {
Super::BeginPlay();
UE_LOG(LogTemp, Warning, TEXT("Actor began play!"));
}

void AMyActor::Tick(float DeltaTime) {
Super::Tick(DeltaTime);

// Перемещаем актера вперед
FVector NewLocation = GetActorLocation() + GetActorForwardVector() * MovementSpeed * DeltaTime;
SetActorLocation(NewLocation);
}