Язык C в игровой индустрии: от Doom до современных хитов

typedef struct {
float x, y; // Позиция
float health; // Здоровье
float speed; // Скорость
int inventory[10]; // Инвентарь
bool isJumping; // Состояние прыжка
} Player;

#define MAX_BULLETS 100
Bullet bullets[MAX_BULLETS;

// Функция для поиска свободного слота и создания нового снаряда
int createBullet(float x, float y, float angle) {
for (int i = 0; i < MAX_BULLETS; i++) {
if (!bullets[i].active) {
bullets[i].x = x;
bullets[i].y = y;
bullets[i].angle = angle;
bullets[i].active = true;
return i;
}
}
return -1; // Нет свободных слотов
}

typedef struct GameObject {
float x, y;
void (*update)(struct GameObject*); // Функция обновления
void (*render)(struct GameObject*); // Функция рендеринга
struct GameObject* next; // Указатель на следующий объект
} GameObject;

typedef enum {
STATE_MENU,
STATE_PLAYING,
STATE_GAMEOVER
} GameState;

// Указатели на функции для каждого состояния
void (*updateFunctions[3])(float) = {updateMenu, updatePlaying, updateGameover};
void (*renderFunctions[3])(void) = {renderMenu, renderPlaying, renderGameover};

// Главный игровой цикл
void gameLoop() {
GameState currentState = STATE_MENU;
float deltaTime;

while (!shouldQuit) {
deltaTime = calculateDeltaTime();
processInput();

// Вызов функции обновления для текущего состояния
updateFunctions[currentState](deltaTime);

// Рендеринг текущего состояния
renderFunctions[currentState]();
}
}

// Плавное перемещение к цели
void moveToTarget(GameObject* obj, float targetX, float targetY, float speed, float deltaTime) {
float dx = targetX – obj->x;
float dy = targetY – obj->y;
float distance = sqrt(dx*dx + dy*dy);

if (distance > 1.0f) { // Если не достигли цели
obj->x += (dx / distance) * speed * deltaTime;
obj->y += (dy / distance) * speed * deltaTime;
}
}

// Проверка столкновения персонажа с препятствиями
bool checkCollisions(Player* player) {
for (int i = 0; i < numObstacles; i++) {
if (rectanglesOverlap(player->x, player->y, player->width, player->height,
obstacles[i].x, obstacles[i].y, 
obstacles[i].width, obstacles[i].height)) {
return true; // Столкновение обнаружено
}
}
return false; // Столкновений нет
}

// Инициализация OpenGL и создание простого треугольника
void setupTriangle() {
// Вершины треугольника
GLfloat vertices[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f
};

// Создание буфера вершин
GLuint VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

// Установка атрибутов вершин
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
}

// Загрузка и отображение спрайта с помощью SDL2
SDL_Texture* loadTexture(const char* path, SDL_Renderer* renderer) {
SDL_Surface* surface = IMG_Load(path);
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_FreeSurface(surface);
return texture;
}

void renderSprite(SDL_Texture* texture, SDL_Renderer* renderer, int x, int y) {
SDL_Rect dest = {x, y, 64, 64}; // Позиция и размер
SDL_RenderCopy(renderer, texture, NULL, &dest);
}

// Пример анимации спрайта в Raylib
void updateAndRenderCharacter(Character* character) {
// Обновление кадра анимации
character->frameCounter++;
if (character->frameCounter >= character->frameSpeed) {
character->frameCounter = 0;
character->currentFrame++;
if (character->currentFrame >= character->maxFrames) 
character->currentFrame = 0;
}

// Отрисовка текущего кадра анимации
Rectangle frameRect = { character->currentFrame * character->width, 0, 
character->width, character->height };
DrawTextureRec(character->texture, frameRect, 
(Vector2){ character->position.x, character->position.y }, WHITE);
}

// Загрузка и воспроизведение звуков через SDL_mixer
Mix_Chunk* loadSound(const char* path) {
return Mix_LoadWAV(path);
}

Mix_Music* loadMusic(const char* path) {
return Mix_LoadMUS(path);
}

void playSound(Mix_Chunk* sound, int channel, int loops) {
Mix_PlayChannel(channel, sound, loops);
}

void playMusic(Mix_Music* music, int loops) {
Mix_PlayMusic(music, loops);
}

// Простой менеджер текстур
#define MAX_TEXTURES 100

typedef struct {
char path[256];
SDL_Texture* texture;
int referenceCount;
} TextureAsset;

TextureAsset textureCache[MAX_TEXTURES];
int textureCount = 0;

SDL_Texture* getTexture(const char* path, SDL_Renderer* renderer) {
// Поиск в кэше
for (int i = 0; i < textureCount; i++) {
if (strcmp(textureCache[i].path, path) == 0) {
textureCache[i].referenceCount++;
return textureCache[i].texture;
}
}

// Загрузка новой текстуры
if (textureCount < MAX_TEXTURES) {
strcpy(textureCache[textureCount].path, path);
textureCache[textureCount].texture = loadTexture(path, renderer);
textureCache[textureCount].referenceCount = 1;
return textureCache[textureCount++].texture;
}

return NULL; // Кэш переполнен
}

void releaseTexture(const char* path) {
for (int i = 0; i < textureCount; i++) {
if (strcmp(textureCache[i].path, path) == 0) {
textureCache[i].referenceCount--;
if (textureCache[i].referenceCount <= 0) {
SDL_DestroyTexture(textureCache[i].texture);
// Перемещаем последнюю текстуру на место удаленной
if (i < textureCount – 1) {
textureCache[i] = textureCache[textureCount – 1];
}
textureCount--;
}
break;
}
}
}

CC = gcc
CFLAGS = -Wall -std=c99
LDFLAGS = -lSDL2 -lSDL2_image -lSDL2_mixer -lm

SRC_DIR = src
BUILD_DIR = build
SRCS = $(wildcard $(SRC_DIR)/*.c)
OBJS = $(SRCS:$(SRC_DIR)/%.c=$(BUILD_DIR)/%.o)
EXEC = $(BUILD_DIR)/game

$(EXEC): $(OBJS)
$(CC) $(OBJS) -o $(EXEC) $(LDFLAGS)

$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
mkdir -p $(BUILD_DIR)
$(CC) $(CFLAGS) -c $< -o $@

clean:
rm -rf $(BUILD_DIR)

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_mixer.h>
#include <stdbool.h>
#include <stdio.h>

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
#define FPS 60
#define FRAME_DELAY (1000 / FPS)

int main(int argc, char* argv[]) {
// Инициализация SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) != 0) {
printf("SDL initialization failed: %s\n", SDL_GetError());
return 1;
}

// Инициализация SDL_image
if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) {
printf("SDL_image initialization failed: %s\n", IMG_GetError());
SDL_Quit();
return 1;
}

// Инициализация SDL_mixer
if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0) {
printf("SDL_mixer initialization failed: %s\n", Mix_GetError());
IMG_Quit();
SDL_Quit();
return 1;
}

// Создание окна и рендерера
SDL_Window* window = SDL_CreateWindow(
"Space Shooter", 
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
WINDOW_WIDTH, WINDOW_HEIGHT,
SDL_WINDOW_SHOWN
);

if (!window) {
printf("Window creation failed: %s\n", SDL_GetError());
Mix_CloseAudio();
IMG_Quit();
SDL_Quit();
return 1;
}

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

if (!renderer) {
printf("Renderer creation failed: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
Mix_CloseAudio();
IMG_Quit();
SDL_Quit();
return 1;
}

// Главный игровой цикл
bool running = true;
SDL_Event event;
Uint32 frameStart, frameTime;

while (running) {
frameStart = SDL_GetTicks();

// Обработка событий
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
}
}

// Обновление игровой логики

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

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

SDL_RenderPresent(renderer);

// Контроль FPS
frameTime = SDL_GetTicks() – frameStart;
if (frameTime < FRAME_DELAY) {
SDL_Delay(FRAME_DELAY – frameTime);
}
}

// Освобождение ресурсов
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
Mix_CloseAudio();
IMG_Quit();
SDL_Quit();

return 0;
}

#ifndef GAME_H
#define GAME_H

#include <SDL2/SDL.h>
#include <stdbool.h>

#define MAX_BULLETS 100
#define MAX_ENEMIES 50

typedef struct {
float x, y;
float dx, dy;
float speed;
float health;
SDL_Texture* texture;
SDL_Rect hitbox;
bool active;
} Player;

typedef struct {
float x, y;
float dx, dy;
float speed;
SDL_Texture* texture;
SDL_Rect hitbox;
bool active;
} Bullet;

typedef struct {
float x, y;
float dx, dy;
float speed;
float health;
SDL_Texture* texture;
SDL_Rect hitbox;
bool active;
} Enemy;

typedef struct {
Player player;
Bullet bullets[MAX_BULLETS];
Enemy enemies[MAX_ENEMIES];
int score;
bool gameOver;
SDL_Texture* backgroundTexture;
// Звуковые эффекты
Mix_Chunk* shootSound;
Mix_Chunk* explosionSound;
Mix_Music* backgroundMusic;
} Game;

// Прототипы функций
void initGame(Game* game, SDL_Renderer* renderer);
void updateGame(Game* game, float deltaTime);
void renderGame(Game* game, SDL_Renderer* renderer);
void handleInput(Game* game, const Uint8* keystate);
void spawnEnemy(Game* game);
void fireBullet(Game* game);
bool checkCollision(SDL_Rect a, SDL_Rect b);
void cleanupGame(Game* game);

#endif /* GAME_H */

#include "game.h"
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_mixer.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

SDL_Texture* loadTexture(const char* path, SDL_Renderer* renderer) {
SDL_Surface* surface = IMG_Load(path);
if (!surface) {
printf("Failed to load image %s: %s\n", path, IMG_GetError());
return NULL;
}

SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
if (!texture) {
printf("Failed to create texture: %s\n", SDL_GetError());
}

SDL_FreeSurface(surface);
return texture;
}

void initGame(Game* game, SDL_Renderer* renderer) {
srand(time(NULL));

// Инициализация игрока
game->player.x = 400;
game->player.y = 500;
game->player.dx = 0;
game->player.dy = 0;
game->player.speed = 200;
game->player.health = 100;
game->player.texture = loadTexture("assets/player.png", renderer);
game->player.hitbox = (SDL_Rect){game->player.x – 16, game->player.y – 16, 32, 32};
game->player.active = true;

// Инициализация пуль
for (int i = 0; i < MAX_BULLETS; i++) {
game->bullets[i].active = false;
game->bullets[i].texture = loadTexture("assets/bullet.png", renderer);
}

// Инициализация врагов
for (int i = 0; i < MAX_ENEMIES; i++) {
game->enemies[i].active = false;
game->enemies[i].texture = loadTexture("assets/enemy.png", renderer);
}

// Инициализация игрового состояния
game->score = 0;
game->gameOver = false;
game->backgroundTexture = loadTexture("assets/background.png", renderer);

// Загрузка звуков
game->shootSound = Mix_LoadWAV("assets/shoot.wav");
game->explosionSound = Mix_LoadWAV("assets/explosion.wav");
game->backgroundMusic = Mix_LoadMUS("assets/music.mp3");

// Воспроизведение фоновой музыки
Mix_PlayMusic(game->backgroundMusic, -1);
}

void updateGame(Game* game, float deltaTime) {
if (game->gameOver) return;

// Обновление позиции игрока
game->player.x += game->player.dx * deltaTime;
game->player.y += game->player.dy * deltaTime;

// Ограничение движения игрока
if (game->player.x < 16) game->player.x = 16;
if (game->player.x > 784) game->player.x = 784;
if (game->player.y < 16) game->player.y = 16;
if (game->player.y > 584) game->player.y = 584;

// Обновление хитбокса игрока
game->player.hitbox.x = game->player.x – 16;
game->player.hitbox.y = game->player.y – 16;

// Обновление пуль
for (int i = 0; i < MAX_BULLETS; i++) {
if (game->bullets[i].active) {
game->bullets[i].y -= game->bullets[i].speed * deltaTime;
game->bullets[i].hitbox.x = game->bullets[i].x – 4;
game->bullets[i].hitbox.y = game->bullets[i].y – 4;

// Деактивация пули при выходе за пределы экрана
if (game->bullets[i].y < -8) {
game->bullets[i].active = false;
}
}
}

// Обновление врагов
for (int i = 0; i < MAX_ENEMIES; i++) {
if (game->enemies[i].active) {
game->enemies[i].y += game->enemies[i].speed * deltaTime;
game->enemies[i].hitbox.x = game->enemies[i].x – 16;
game->enemies[i].hitbox.y = game->enemies[i].y – 16;

// Деактивация врага при выходе за пределы экрана
if (game->enemies[i].y > 616) {
game->enemies[i].active = false;
}

// Проверка столкновения с игроком
if (checkCollision(game->enemies[i].hitbox, game->player.hitbox)) {
game->player.health -= 10;
game->enemies[i].active = false;
Mix_PlayChannel(-1, game->explosionSound, 0);

if (game->player.health <= 0) {
game->gameOver = true;
}
}

// Проверка столкновения с пулями
for (int j = 0; j < MAX_BULLETS; j++) {
if (game->bullets[j].active && 
checkCollision(game->bullets[j].hitbox, game->enemies[i].hitbox)) {
game->enemies[i].health -= 10;
game->bullets[j].active = false;

if (game->enemies[i].health <= 0) {
game->enemies[i].active = false;
game->score += 100;
Mix_PlayChannel(-1, game->explosionSound, 0);
}
}
}
}
}

// Случайное появление врагов
if (rand() % 100 < 2) {
spawnEnemy(game);
}
}

void renderGame(Game* game, SDL_Renderer* renderer) {
// Отрисовка фона
SDL_RenderCopy(renderer, game->backgroundTexture, NULL, NULL);

// Отрисовка игрока
if (game->player.active) {
SDL_Rect destRect = {
game->player.x – 16,
game->player.y – 16,
32, 32
};
SDL_RenderCopy(renderer, game->player.texture, NULL, &destRect);
}

// Отрисовка пуль
for (int i = 0; i < MAX_BULLETS; i++) {
if (game->bullets[i].active) {
SDL_Rect destRect = {
game->bullets[i].x – 4,
game->bullets[i].y – 4,
8, 8
};
SDL_RenderCopy(renderer, game->bullets[i].texture, NULL, &destRect);
}
}

// Отрисовка врагов
for (int i = 0; i < MAX_ENEMIES; i++) {
if (game->enemies[i].active) {
SDL_Rect destRect = {
game->enemies[i].x – 16,
game->enemies[i].y – 16,
32, 32
};
SDL_RenderCopy(renderer, game->enemies[i].texture, NULL, &destRect);
}
}

// Здесь будет отрисовка UI (счет, здоровье)
}

void handleInput(Game* game, const Uint8* keystate) {
if (game->gameOver) return;

// Сброс скорости
game->player.dx = 0;
game->player.dy = 0;

// Движение игрока
if (keystate[SDL_SCANCODE_W] || keystate[SDL_SCANCODE_UP]) {
game->player.dy = -game->player.speed;
}
if (keystate[SDL_SCANCODE_S] || keystate[SDL_SCANCODE_DOWN]) {
game->player.dy = game->player.speed;
}
if (keystate[SDL_SCANCODE_A] || keystate[SDL_SCANCODE_LEFT]) {
game->player.dx = -game->player.speed;
}
if (keystate[SDL_SCANCODE_D] || keystate[SDL_SCANCODE_RIGHT]) {
game->player.dx = game->player.speed;
}

// Нормализация для диагонального движения
if (game->player.dx != 0 && game->player.dy != 0) {
float factor = 1.0f / sqrt(2.0f);
game->player.dx *= factor;
game->player.dy *= factor;
}
}

void fireBullet(Game* game) {
if (game->gameOver) return;

// Поиск неактивной пули
for (int i = 0; i < MAX_BULLETS; i++) {
if (!game->bullets[i].active) {
game->bullets[i].active = true;
game->bullets[i].x = game->player.x;
game->bullets[i].y = game->player.y – 16;
game->bullets[i].speed = 400;
game->bullets[i].hitbox = (SDL_Rect){
game->bullets[i].x – 4,
game->bullets[i].y – 4,
8, 8
};

// Воспроизведение звука выстрела
Mix_PlayChannel(-1, game->shootSound, 0);

break;
}
}
}

void spawnEnemy(Game* game) {
// Поиск неактивного врага
for (int i = 0; i < MAX_ENEMIES; i++) {
if (!game->enemies[i].active) {
game->enemies[i].active = true;
game->enemies[i].x = rand() % 700 + 50;
game->enemies[i].y = -32;
game->enemies[i].speed = 100 + rand() % 100;
game->enemies[i].health = 10;
game->enemies[i].hitbox = (SDL_Rect){
game->enemies[i].x – 16,
game->enemies[i].y – 16,
32, 32
};

break;
}
}
}

bool checkCollision(SDL_Rect a, SDL_Rect b) {
return (a.x < b.x + b.w &&
a.x + a.w > b.x &&
a.y < b.y + b.h &&
a.y + a.h > b.y);
}

void cleanupGame(Game* game) {
SDL_DestroyTexture(game->player.texture);
SDL_DestroyTexture(game->backgroundTexture);

for (int i = 0; i < MAX_BULLETS; i++) {
if (i == 0) { // Все пули используют одну текстуру
SDL_DestroyTexture(game->bullets[i].texture);
}
}

for (int i = 0; i < MAX_ENEMIES; i++) {
if (i == 0) { // Все враги используют одну текстуру
SDL_DestroyTexture(game->enemies[i].texture);
}
}

Mix_FreeChunk(game->shootSound);
Mix_FreeChunk(game->explosionSound);
Mix_FreeMusic(game->backgroundMusic);
}

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_mixer.h>
#include <stdbool.h>
#include <stdio.h>
#include "game.h"

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
#define FPS 60
#define FRAME_DELAY (1000 / FPS)

int main(int argc, char* argv[]) {
// ... Инициализация SDL (код из шага 2) ...

// Инициализация игры
Game game;
initGame(&game, renderer);

// Главный игровой цикл
bool running = true;
SDL_Event event;
Uint32 frameStart, frameTime;
const Uint8* keystate = SDL_GetKeyboardState(NULL);
Uint32 lastBulletTime = 0;
const int BULLET_DELAY = 200; // Задержка между выстрелами (мс)

while (running) {
frameStart = SDL_GetTicks();

// Обработка событий
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
}
else if (event.type == SDL_KEYDOWN) {
if (event.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
running = false;
}
else if (event.key.keysym.scancode == SDL_SCANCODE_R && game.gameOver) {
// Перезапуск игры при нажатии R после проигрыша
cleanupGame(&game);
initGame(&game, renderer);
}
}
}

// Обработка ввода
SDL_PumpEvents();
handleInput(&game, keystate);

// Автоматическая стрельба при удерживании пробела
Uint32 currentTime = SDL_GetTicks();
if (keystate[SDL_SCANCODE_SPACE] && 
currentTime – lastBulletTime > BULLET_DELAY) {
fireBullet(&game);
lastBulletTime = currentTime;
}

// Обновление игровой логики
updateGame(&game, 1.0f / FPS);

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

renderGame(&game, renderer);

SDL_RenderPresent(renderer);

// Контроль FPS
frameTime = SDL_GetTicks() – frameStart;
if (frameTime < FRAME_DELAY) {
SDL_Delay(FRAME_DELAY – frameTime);
}
}

// Освобождение ресурсов
cleanupGame(&game);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
Mix_CloseAudio();
IMG_Quit();
SDL_Quit();

return 0;
}

make

./build/game