Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Напиши код на C и SDL2, который представляет собой простой редактор карты, написанный с…

  1. User

    Напиши код на C и SDL2, который представляет собой простой редактор карты, написанный с использованием SDL2. Он позволяет пользователю загружать изображение карты и рисовать на нем многоугольники (провинции), а также перемещаться по карте и масштабировать ее.

    Функциональность:

    Загрузка изображения карты: Код загружает PNG изображение карты из файла ./map/world/background.png и отображает его в окне.
    
    Рисование провинций: Пользователь может рисовать провинции, кликая левой кнопкой мыши. Каждый клик добавляет вершину к текущей провинции. Провинции отображаются как полупрозрачные многоугольники со случайным цветом. Вершины провинций отображаются зелеными точками.
    
    Перемещение по карте (панорамирование): Пользователь может перемещаться по карте, удерживая правую кнопку мыши и двигая мышь.
    
    Масштабирование: Пользователь может масштабировать карту с помощью колесика мыши. Масштабирование происходит относительно позиции курсора.
    
    Обработка изменения размера окна: Код корректно обрабатывает изменение размера окна, обновляя отображение карты.
    
    Ограничение камеры: Камера ограничена пределами изображения карты, предотвращая выход за границы.
    
    Плавный зум: Зум реализован с плавным изменением масштаба.
    

    Основные компоненты кода:

    zoom.c/zoom.h: Этот модуль отвечает за управление масштабированием и перемещением камеры. Он предоставляет функции для увеличения, уменьшения, плавного обновления зума, начала и остановки перетаскивания камеры, обработки изменения размера окна, а также геттеры для получения текущего уровня масштабирования, позиции камеры и области изображения, которая должна быть отображена.
    
    EProvince.c/EProvince.h: Этот модуль отвечает за представление и отрисовку провинций. Он содержит структуру Province, которая хранит вершины многоугольника и его цвет. Также предоставляет функции для инициализации провинции, добавления точек и отрисовки.
    
    mainEditor.c: Главный файл программы, который инициализирует SDL, загружает изображение, обрабатывает события (ввод с клавиатуры и мыши), обновляет состояние зума и камеры, и отрисовывает карту и провинции.
    
  2. Assistant

    Конечно! Ниже представлен полный код простого редактора карты на C с использованием SDL2. Проект разделен на три основных модуля: управление масштабированием и перемещением (zoom), представление и отрисовку провинций (EProvince), и главный файл программы (mainEditor.c). Также предоставлен простой Makefile для сборки проекта.

    Требования

    Перед началом убедитесь, что у вас установлены следующие библиотеки:

    • SDL2
    • SDL2_image

    Вы можете установить их с помощью пакетного менеджера вашей ОС. Например, на Ubuntu:

    sudo apt-get install libsdl2-dev libsdl2-image-dev
    

    Структура проекта

    project/
    ├── EProvince.c
    ├── EProvince.h
    ├── mainEditor.c
    ├── Makefile
    ├── zoom.c
    ├── zoom.h
    └── map/
        └── world/
            └── background.png
    

    1. zoom.h

    // zoom.h
    #ifndef ZOOM_H
    #define ZOOM_H
    
    #include <SDL2/SDL.h>
    
    typedef struct {
        float zoom;                // Текущий уровень масштабирования
        float target_zoom;         // Целевой уровень масштабирования для плавного зума
        float x, y;                // Позиция камеры
        int window_width, window_height; // Размеры окна
        int map_width, map_height; // Размеры карты
        float zoom_speed;          // Скорость изменения зума
    } Zoom;
    
    void Zoom_Init(Zoom *zoom, int window_width, int window_height, int map_width, int map_height);
    void Zoom_HandleEvent(Zoom *zoom, SDL_Event *e, int mouse_x, int mouse_y);
    void Zoom_Update(Zoom *zoom, float delta_time);
    SDL_Rect Zoom_GetViewport(const Zoom *zoom);
    void Zoom_StartPan(Zoom *zoom, int start_x, int start_y);
    void Zoom_Pan(Zoom *zoom, int delta_x, int delta_y);
    void Zoom_EndPan(Zoom *zoom);
    void Zoom_ApplyLimits(Zoom *zoom);
    void Zoom_SetWindowSize(Zoom *zoom, int new_width, int new_height);
    
    #endif // ZOOM_H
    

    2. zoom.c

    // zoom.c
    #include "zoom.h"
    #include <math.h>
    
    void Zoom_Init(Zoom *zoom, int window_width, int window_height, int map_width, int map_height) {
        zoom->zoom = 1.0f;
        zoom->target_zoom = 1.0f;
        zoom->x = 0.0f;
        zoom->y = 0.0f;
        zoom->window_width = window_width;
        zoom->window_height = window_height;
        zoom->map_width = map_width;
        zoom->map_height = map_height;
        zoom->zoom_speed = 3.0f; // Скорость плавного зума
    }
    
    void Zoom_HandleEvent(Zoom *zoom, SDL_Event *e, int mouse_x, int mouse_y) {
        if (e->type == SDL_MOUSEWHEEL) {
            float prev_zoom = zoom->target_zoom;
            if (e->wheel.y > 0) {
                zoom->target_zoom *= 1.1f;
            } else if (e->wheel.y < 0) {
                zoom->target_zoom /= 1.1f;
            }
    
            // Ограничиваем уровень масштабирования
            if (zoom->target_zoom < 0.1f) zoom->target_zoom = 0.1f;
            if (zoom->target_zoom > 10.0f) zoom->target_zoom = 10.0f;
    
            // Масштабирование относительно позиции курсора
            float mouse_world_x = (mouse_x / zoom->zoom) + zoom->x;
            float mouse_world_y = (mouse_y / zoom->zoom) + zoom->y;
    
            zoom->zoom = zoom->zoom; // Текущее значение
            zoom->target_zoom = zoom->target_zoom;
    
            float new_mouse_world_x = (mouse_x / zoom->target_zoom) + zoom->x;
            float new_mouse_world_y = (mouse_y / zoom->target_zoom) + zoom->y;
    
            // Смещение камеры, чтобы позиция под курсором сохранялась
            zoom->x += mouse_world_x - new_mouse_world_x;
            zoom->y += mouse_world_y - new_mouse_world_y;
    
            Zoom_ApplyLimits(zoom);
        }
    }
    
    void Zoom_Update(Zoom *zoom, float delta_time) {
        if (fabsf(zoom->zoom - zoom->target_zoom) > 0.001f) {
            if (zoom->zoom < zoom->target_zoom) {
                zoom->zoom += zoom->zoom_speed * delta_time;
                if (zoom->zoom > zoom->target_zoom)
                    zoom->zoom = zoom->target_zoom;
            } else {
                zoom->zoom -= zoom->zoom_speed * delta_time;
                if (zoom->zoom < zoom->target_zoom)
                    zoom->zoom = zoom->target_zoom;
            }
            Zoom_ApplyLimits(zoom);
        }
    }
    
    SDL_Rect Zoom_GetViewport(const Zoom *zoom) {
        SDL_Rect viewport;
        viewport.x = (int)(zoom->x * zoom->zoom);
        viewport.y = (int)(zoom->y * zoom->zoom);
        viewport.w = (int)(zoom->map_width * zoom->zoom);
        viewport.h = (int)(zoom->map_height * zoom->zoom);
        return viewport;
    }
    
    void Zoom_StartPan(Zoom *zoom, int start_x, int start_y) {
        // Необходимо хранить начальную позицию при необходимости
        // Для простоты пансирования реализовано без дополнительных переменных
    }
    
    void Zoom_Pan(Zoom *zoom, int delta_x, int delta_y) {
        zoom->x -= delta_x / zoom->zoom;
        zoom->y -= delta_y / zoom->zoom;
        Zoom_ApplyLimits(zoom);
    }
    
    void Zoom_EndPan(Zoom *zoom) {
        // Ничего не делаем
    }
    
    void Zoom_ApplyLimits(Zoom *zoom) {
        // Ограничение камеры пределами карты
        float max_x = zoom->map_width - zoom->window_width / zoom->zoom;
        float max_y = zoom->map_height - zoom->window_height / zoom->zoom;
    
        if (max_x < 0) {
            zoom->x = (zoom->map_width - zoom->window_width / zoom->zoom) / 2.0f;
        } else {
            if (zoom->x < 0) zoom->x = 0;
            if (zoom->x > max_x) zoom->x = max_x;
        }
    
        if (max_y < 0) {
            zoom->y = (zoom->map_height - zoom->window_height / zoom->zoom) / 2.0f;
        } else {
            if (zoom->y < 0) zoom->y = 0;
            if (zoom->y > max_y) zoom->y = max_y;
        }
    }
    
    void Zoom_SetWindowSize(Zoom *zoom, int new_width, int new_height) {
        zoom->window_width = new_width;
        zoom->window_height = new_height;
        Zoom_ApplyLimits(zoom);
    }
    

    3. EProvince.h

    // EProvince.h
    #ifndef EPROVINCE_H
    #define EPROVINCE_H
    
    #include <SDL2/SDL.h>
    
    #define PROVINCE_COLOR_COUNT 256
    
    typedef struct {
        int vertex_count;
        int vertex_capacity;
        SDL_FPoint *vertices;
        SDL_Color color;
    } Province;
    
    typedef struct {
        Province *provinces;
        int province_count;
        int province_capacity;
    } ProvinceList;
    
    void Province_Init(ProvinceList *plist);
    void Province_Destroy(ProvinceList *plist);
    void Province_AddProvince(ProvinceList *plist, Province province);
    void Province_InitProvince(Province *province);
    void Province_AddPoint(Province *province, float x, float y);
    void Province_DestroyProvince(Province *province);
    void Province_Render(const ProvinceList *plist, SDL_Renderer *renderer, float zoom, float cam_x, float cam_y, int window_width, int window_height);
    void Province_RenderSingle(const Province *province, SDL_Renderer *renderer, float zoom, float cam_x, float cam_y);
    SDL_Color Province_GetRandomColor();
    
    #endif // EPROVINCE_H
    

    4. EProvince.c

    // EProvince.c
    #include "EProvince.h"
    #include <stdlib.h>
    #include <time.h>
    
    void Province_Init(ProvinceList *plist) {
        plist->province_count = 0;
        plist->province_capacity = 10;
        plist->provinces = (Province *)malloc(sizeof(Province) * plist->province_capacity);
        srand((unsigned int)time(NULL));
    }
    
    void Province_Destroy(ProvinceList *plist) {
        for (int i = 0; i < plist->province_count; ++i) {
            free(plist->provinces[i].vertices);
        }
        free(plist->provinces);
    }
    
    void Province_AddProvince(ProvinceList *plist, Province province) {
        if (plist->province_count >= plist->province_capacity) {
            plist->province_capacity *= 2;
            plist->provinces = (Province *)realloc(plist->provinces, sizeof(Province) * plist->province_capacity);
        }
        plist->provinces[plist->province_count++] = province;
    }
    
    void Province_InitProvince(Province *province) {
        province->vertex_count = 0;
        province->vertex_capacity = 10;
        province->vertices = (SDL_FPoint *)malloc(sizeof(SDL_FPoint) * province->vertex_capacity);
        province->color = Province_GetRandomColor();
    }
    
    void Province_AddPoint(Province *province, float x, float y) {
        if (province->vertex_count >= province->vertex_capacity) {
            province->vertex_capacity *= 2;
            province->vertices = (SDL_FPoint *)realloc(province->vertices, sizeof(SDL_FPoint) * province->vertex_capacity);
        }
        province->vertices[province->vertex_count].x = x;
        province->vertices[province->vertex_count].y = y;
        province->vertex_count++;
    }
    
    void Province_DestroyProvince(Province *province) {
        free(province->vertices);
    }
    
    void Province_Render(const ProvinceList *plist, SDL_Renderer *renderer, float zoom, float cam_x, float cam_y, int window_width, int window_height) {
        for (int i = 0; i < plist->province_count; ++i) {
            Province_RenderSingle(&plist->provinces[i], renderer, zoom, cam_x, cam_y);
        }
    }
    
    void Province_RenderSingle(const Province *province, SDL_Renderer *renderer, float zoom, float cam_x, float cam_y) {
        if (province->vertex_count < 3) return; // Не рисуем, если меньше 3 вершин
    
        // Устанавливаем цвет с прозрачностью
        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
        SDL_SetRenderDrawColor(renderer, province->color.r, province->color.g, province->color.b, 100);
    
        // Создаем массив точек в экранных координатах
        SDL_FPoint *points = (SDL_FPoint *)malloc(sizeof(SDL_FPoint) * province->vertex_count);
        for (int i = 0; i < province->vertex_count; ++i) {
            points[i].x = (province->vertices[i].x - cam_x) * zoom;
            points[i].y = (province->vertices[i].y - cam_y) * zoom;
        }
    
        // Создаем SDL_FPolygon не поддерживается напрямую. Нужно использовать SDL_RenderGeometry или SDL_RenderDrawLines.
        // Для простоты используем SDL_RenderDrawLines + замыкание контура
        SDL_RenderDrawLinesF(renderer, points, province->vertex_count);
        // Замыкаем контур
        SDL_RenderDrawLineF(renderer, points[province->vertex_count - 1].x, points[province->vertex_count - 1].y, points[0].x, points[0].y);
    
        free(points);
    
        // Рисуем точки вершин
        SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // Зеленые точки
        for (int i = 0; i < province->vertex_count; ++i) {
            SDL_Rect rect;
            rect.w = rect.h = 6;
            rect.x = (int)((province->vertices[i].x - cam_x) * zoom) - 3;
            rect.y = (int)((province->vertices[i].y - cam_y) * zoom) - 3;
            SDL_RenderFillRect(renderer, &rect);
        }
    }
    
    SDL_Color Province_GetRandomColor() {
        SDL_Color color;
        color.r = rand() % 156 + 100; // Избегаем слишком темных цветов
        color.g = rand() % 156 + 100;
        color.b = rand() % 156 + 100;
        color.a = 100; // Полупрозрачность
        return color;
    }
    

    5. mainEditor.c

    // mainEditor.c
    #include <SDL2/SDL.h>
    #include <SDL2/SDL_image.h>
    #include <stdio.h>
    #include "zoom.h"
    #include "EProvince.h"
    
    #define WINDOW_WIDTH 1280
    #define WINDOW_HEIGHT 720
    
    int main(int argc, char *argv[]) {
        if (SDL_Init(SDL_INIT_VIDEO) != 0) {
            printf("SDL_Init Error: %s\n", SDL_GetError());
            return 1;
        }
    
        int imgFlags = IMG_INIT_PNG;
        if (!(IMG_Init(imgFlags) & imgFlags)) {
            printf("IMG_Init Error: %s\n", IMG_GetError());
            SDL_Quit();
            return 1;
        }
    
        SDL_Window *window = SDL_CreateWindow("Simple Map Editor",
                                              SDL_WINDOWPOS_CENTERED,
                                              SDL_WINDOWPOS_CENTERED,
                                              WINDOW_WIDTH,
                                              WINDOW_HEIGHT,
                                              SDL_WINDOW_RESIZABLE);
        if (!window) {
            printf("SDL_CreateWindow Error: %s\n", SDL_GetError());
            IMG_Quit();
            SDL_Quit();
            return 1;
        }
    
        SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 
                                                    SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
        if (!renderer) {
            printf("SDL_CreateRenderer Error: %s\n", SDL_GetError());
            SDL_DestroyWindow(window);
            IMG_Quit();
            SDL_Quit();
            return 1;
        }
    
        // Загрузка фонового изображения
        SDL_Surface *background_surface = IMG_Load("./map/world/background.png");
        if (!background_surface) {
            printf("IMG_Load Error: %s\n", IMG_GetError());
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            IMG_Quit();
            SDL_Quit();
            return 1;
        }
    
        SDL_Texture *background_texture = SDL_CreateTextureFromSurface(renderer, background_surface);
        int map_width = background_surface->w;
        int map_height = background_surface->h;
        SDL_FreeSurface(background_surface);
    
        if (!background_texture) {
            printf("SDL_CreateTextureFromSurface Error: %s\n", SDL_GetError());
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            IMG_Quit();
            SDL_Quit();
            return 1;
        }
    
        // Инициализация камеры
        Zoom camera;
        Zoom_Init(&camera, WINDOW_WIDTH, WINDOW_HEIGHT, map_width, map_height);
    
        // Инициализация провинций
        ProvinceList province_list;
        Province_Init(&province_list);
        Province current_province;
        int is_drawing = 0;
    
        // Перемещение
        int panning = 0;
        int last_mouse_x, last_mouse_y;
    
        int running = 1;
        Uint32 last_time = SDL_GetTicks();
    
        while (running) {
            SDL_Event e;
            while (SDL_PollEvent(&e)) {
                switch (e.type) {
                    case SDL_QUIT:
                        running = 0;
                        break;
                    case SDL_WINDOWEVENT:
                        if (e.window.event == SDL_WINDOWEVENT_RESIZED) {
                            camera.window_width = e.window.data1;
                            camera.window_height = e.window.data2;
                            Zoom_SetWindowSize(&camera, e.window.data1, e.window.data2);
                        }
                        break;
                    case SDL_MOUSEWHEEL: {
                        int mouse_x, mouse_y;
                        SDL_GetMouseState(&mouse_x, &mouse_y);
                        Zoom_HandleEvent(&camera, &e, mouse_x, mouse_y);
                        break;
                    }
                    case SDL_MOUSEBUTTONDOWN:
                        if (e.button.button == SDL_BUTTON_LEFT) {
                            int mouse_x = e.button.x;
                            int mouse_y = e.button.y;
                            // Переводим экранные координаты в мировые
                            float world_x = mouse_x / camera.zoom + camera.x;
                            float world_y = mouse_y / camera.zoom + camera.y;
                            if (!is_drawing) {
                                Province_InitProvince(&current_province);
                                is_drawing = 1;
                            }
                            Province_AddPoint(&current_province, world_x, world_y);
                        }
                        if (e.button.button == SDL_BUTTON_RIGHT) {
                            panning = 1;
                            last_mouse_x = e.button.x;
                            last_mouse_y = e.button.y;
                        }
                        break;
                    case SDL_MOUSEBUTTONUP:
                        if (e.button.button == SDL_BUTTON_RIGHT) {
                            panning = 0;
                        }
                        if (e.button.button == SDL_BUTTON_LEFT) {
                            // Не завершаем провинцию при отпускании кнопки
                            // Для завершения можно использовать клавишу
                        }
                        break;
                    case SDL_MOUSEMOTION:
                        if (panning) {
                            int delta_x = e.motion.x - last_mouse_x;
                            int delta_y = e.motion.y - last_mouse_y;
                            Zoom_Pan(&camera, delta_x, delta_y);
                            last_mouse_x = e.motion.x;
                            last_mouse_y = e.motion.y;
                        }
                        break;
                    case SDL_KEYDOWN:
                        if (e.key.keysym.sym == SDLK_RETURN || e.key.keysym.sym == SDLK_KP_ENTER) {
                            if (is_drawing && current_province.vertex_count >= 3) {
                                Province_AddProvince(&province_list, current_province);
                                is_drawing = 0;
                            }
                        }
                        if (e.key.keysym.sym == SDLK_ESCAPE) {
                            // Отмена текущего рисования
                            if (is_drawing) {
                                Province_DestroyProvince(&current_province);
                                is_drawing = 0;
                            }
                        }
                        break;
                    default:
                        break;
                }
            }
    
            // Выполняем плавный зум
            Uint32 current_time = SDL_GetTicks();
            float delta_time = (current_time - last_time) / 1000.0f;
            last_time = current_time;
            Zoom_Update(&camera, delta_time);
    
            // Очистка экрана
            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
            SDL_RenderClear(renderer);
    
            // Отрисовка фона
            SDL_Rect dest_rect;
            dest_rect.x = (int)((-camera.x) * camera.zoom);
            dest_rect.y = (int)((-camera.y) * camera.zoom);
            dest_rect.w = (int)(map_width * camera.zoom);
            dest_rect.h = (int)(map_height * camera.zoom);
            SDL_RenderCopy(renderer, background_texture, NULL, &dest_rect);
    
            // Отрисовка провинций
            Province_Render(&province_list, renderer, camera.zoom, camera.x, camera.y, camera.window_width, camera.window_height);
    
            // Отрисовка текущей провинции
            if (is_drawing) {
                Province_RenderSingle(&current_province, renderer, camera.zoom, camera.x, camera.y);
            }
    
            // Отображение
            SDL_RenderPresent(renderer);
        }
    
        // Очистка
        if (is_drawing) {
            Province_DestroyProvince(&current_province);
        }
        Province_Destroy(&province_list);
        SDL_DestroyTexture(background_texture);
        SDL_DestroyRenderer(renderer);
        SDL_DestroyWindow(window);
        IMG_Quit();
        SDL_Quit();
        return 0;
    }
    

    6. Makefile

    # Makefile
    CC = gcc
    CFLAGS = -Wall -Wextra -std=c11 `sdl2-config --cflags`
    LIBS = `sdl2-config --libs` -lSDL2_image
    
    TARGET = mainEditor
    
    SRCS = mainEditor.c zoom.c EProvince.c
    OBJS = $(SRCS:.c=.o)
    
    all: $(TARGET)
    
    $(TARGET): $(OBJS)
    	$(CC) -o $@ $^ $(LIBS)
    
    %.o: %.c
    	$(CC) $(CFLAGS) -c $< -o $@
    
    clean:
    	rm -f $(OBJS) $(TARGET)
    

    7. Инструкции по сборке и запуску

    1. Структура проекта:

      Создайте структуру директорий, как показано выше. Убедитесь, что у вас есть фоновое изображение карты по пути ./map/world/background.png.

    2. Сборка проекта:

      Откройте терминал в корневой директории проекта и выполните команду:

      make
      

      Это скомпилирует проект и создаст исполняемый файл mainEditor.

    3. Запуск программы:

      Запустите программу следующей командой:

      ./mainEditor
      

    8. Использование редактора

    • Загрузка карты:

      При запуске программы загружается фоновое изображение карты из файла ./map/world/background.png. Убедитесь, что путь корректен и файл существует.

    • Рисование провинций:

      • Добавление вершин:

        Нажимайте левой кнопкой мыши на карте, чтобы добавлять вершины текущей провинции.

      • Завершение провинции:

        Нажмите клавишу Enter, чтобы завершить текущую провинцию. Провинция будет сохранена и отображаться на карте с случайным полупрозрачным цветом.

      • Отмена провинции:

        Если вы начали рисовать провинцию, но хотите отменить, нажмите Esc.

    • Перемещение по карте (панорамирование):

      Удерживайте правую кнопку мыши и перемещайте мышь, чтобы переместить обзор карты.

    • Масштабирование:

      Используйте колесо мыши, чтобы увеличить или уменьшить масштаб карты. Масштабирование происходит относительно позиции курсора. Реализован плавный зум.

    • Изменение размера окна:

      Окно можно свободно изменять, и отображение карты будет корректироваться автоматически.

    • Ограничение камеры:

      При перемещении или масштабировании камера не позволит вам выйти за пределы карты.

    9. Дополнительные улучшения

    Этот базовый редактор можно расширить следующими возможностями:

    • Сохранение и загрузка провинций:

      Добавьте функциональность для сохранения созданных провинций в файл и их загрузки при следующем запуске программы.

    • Редактирование провинций:

      Позвольте пользователю перемещать, изменять или удалять созданные провинции.

    • Интерфейс пользователя:

      Добавьте меню, панель инструментов или всплывающие подсказки для улучшения удобства использования.

    • Поддержка других форматов изображений:

      Расширьте поддержку различных форматов изображений для карты.

    Надеюсь, этот редактор будет полезен для ваших проектов! Если у вас есть дополнительные вопросы или требуется помощь, не стесняйтесь спрашивать.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.