Entropie git · main

#include <SDL3/SDL.h>
#include <SDL3_ttf/SDL_ttf.h>

#include "color.h"
#include "object.h"
#include "render.h"
#include "character.h"
#include "map.h"

extern int MAP_WIDTH;
extern int MAP_HEIGHT;
extern const int TILE_SIZE;

extern int characters_size;
extern Character* characters;
extern Character* character;


void Render_rect(SDL_Renderer* renderer, float x, float y, float w, float h, unsigned char r, unsigned char g, unsigned char b, unsigned char a) {

    SDL_SetRenderDrawColor(renderer, r, g, b, a);
    SDL_FRect rect = {x, y, w, h};
    SDL_RenderFillRect(renderer, &rect);
}

// Function to render text to the window
void Render_text(SDL_Renderer* renderer, TTF_Font* font, const char* text, int x, int y, SDL_Color color) {
    SDL_Surface* surface = TTF_RenderText_Solid(font, text, sizeof(text), color);  // Create a surface with text
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);  // Convert surface to texture

    // Get the dimensions of the texture
    int textWidth = surface->w;
    int textHeight = surface->h;

    // Create a rectangle to display the text at the specified position
    SDL_FRect text_rect = {x, y, textWidth, textHeight};

    // Copy the texture to the renderer
    SDL_RenderTexture(renderer, texture, NULL, &text_rect);

    // Clean up
    SDL_DestroySurface(surface);
    SDL_DestroyTexture(texture);
}


// Function to print character details to the SDL window
void Render_characterInfo(SDL_Renderer *renderer, TTF_Font* font, const Character* character) {
    // Set text color (white)
    SDL_Color textColor = {255, 255, 255, 255};

    int text_height = 22;
    int margin_left = 16;
    int margin_top  = 16;

    // Render character name
    Render_text(renderer, font, character->name, margin_left, (text_height * 0) + margin_top, textColor);

    // Render character role
    Render_text(renderer, font, character->role, margin_left, (text_height * 1) + margin_top, textColor);

    // Render character preferences
    Render_text(renderer, font, character->preferences, margin_left, (text_height * 2) + margin_top, textColor);

    // Render character stats
    char stats[100];
    snprintf(stats, sizeof(stats), "Energy: %d, Friendliness: %d, Creativity: %d",
             character->energy, character->friendliness, character->creativity);
    Render_text(renderer, font, stats, margin_left, (text_height * 3) + margin_top, textColor);
}

void Render_character(SDL_Renderer* renderer, Camera camera, Character* character) {
    // Set the drawing color for the character (e.g., blue)

    Color c = character->color;
    SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a);

    // Define the rectangle
    SDL_FRect rect = {
        character->object->x - camera.center_x + (camera.view_w / 2), // Adjust for camera position
        character->object->y - camera.center_y + (camera.view_h / 2), // Adjust for camera position
        character->object->w,
        character->object->h
    };

    // Render the filled rectangle
    SDL_RenderFillRect(renderer, &rect);
}

void Render_object(SDL_Renderer* renderer, Camera camera, Object* object) {
    printf("## %f %f %p\n", object->x, object->y, object);
    if (object->parent_type == Object_Character) {
        Character* character = (Character*)object->parent;
        Color co = character->color;
        SDL_SetRenderDrawColor(renderer, co.r, co.g, co.b, co.a);
    } else if (object->parent_type == Object_Tile) {
        Tile* tile = (Tile*)object->parent;
        switch (tile->type) {
            case TILE_TREE:
                SDL_SetRenderDrawColor(renderer, 34, 139, 34, 255); // Forest Green for trees
                break;
            case TILE_GRASS:
                SDL_SetRenderDrawColor(renderer, 50, 205, 50, 255); // Lime Green for grass
                break;
            case TILE_DIRT:
                SDL_SetRenderDrawColor(renderer, 139, 69, 19, 255); // Saddle Brown for dirt
                break;
            case TILE_WATER:
                SDL_SetRenderDrawColor(renderer, 70, 130, 180, 255); // Steel Blue for water
                break;
            case TILE_WAY:
                SDL_SetRenderDrawColor(renderer, 255, 223, 186, 255); // Peach for pathways
                break;
            case TILE_ROAD:
                SDL_SetRenderDrawColor(renderer, 128, 128, 128, 255); // Gray for roads
                break;
            case TILE_TRACK:
                SDL_SetRenderDrawColor(renderer, 139, 69, 19, 255); // Saddle Brown for tracks
                break;
            case TILE_GRAVEL:
                SDL_SetRenderDrawColor(renderer, 169, 169, 169, 255); // Light Gray for gravel
                break;
            case TILE_WALL:
                SDL_SetRenderDrawColor(renderer, 105, 105, 105, 255); // Dim Gray for walls
                break;
            case TILE_EMPTY:
                SDL_SetRenderDrawColor(renderer, 240, 248, 255, 255); // Alice Blue for empty tiles
                break;
            case TILE_PLAYER_SPAWN:
                SDL_SetRenderDrawColor(renderer, 255, 223, 0, 255); // Golden Yellow for player spawn
                break;
            case TILE_CHARACTER_SPAWN:
                SDL_SetRenderDrawColor(renderer, 255, 105, 180, 255); // Hot Pink for character spawn
                break;
            case TILE_HOUSE:
                SDL_SetRenderDrawColor(renderer, 178, 34, 34, 255); // Firebrick for houses
                break;
            case TILE_COLLECTABLE:
                SDL_SetRenderDrawColor(renderer, 255, 215, 0, 255); // Gold for collectibles
                break;
            default:
                SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // Black for unknown types
                break;
        }
    } else {
        return;
    }

    SDL_FRect tileRect = { object->x - camera.offset_x, object->y - camera.offset_y, object->w, object->h };
    SDL_RenderFillRect(renderer, &tileRect);
}

void Render_map(SDL_Renderer* renderer, Camera camera, Object* object) {
    Object* next = camera.render_object;
        printf("*_* %p %f %f\n", next, next->x, next->y);
    while (next->next && Object_is_visible(next, &camera)) {
        Render_object(renderer, camera, next);
        next = next->next;
    }
}
void Render_map_OLD(SDL_Renderer* renderer, Camera camera, Object* object) {
    // printf("MIN %d\n", camera.min_y);
    // Render only the tiles within the visible window area
    for (int y = camera.min_y; y <= camera.max_y; y++) {
        for (int x = camera.min_x; x <= camera.max_x; x++) {
            // Calculate the position of each tile relative to the camera
            float tile_x = (x * TILE_SIZE) - camera.offset_x;
            float tile_y = (y * TILE_SIZE) - camera.offset_y;
            switch (map[y][x]) {
                case TILE_TREE:
                    SDL_SetRenderDrawColor(renderer, 34, 139, 34, 255); // Forest Green for trees
                    break;
                case TILE_GRASS:
                    SDL_SetRenderDrawColor(renderer, 50, 205, 50, 255); // Lime Green for grass
                    break;
                case TILE_DIRT:
                    SDL_SetRenderDrawColor(renderer, 139, 69, 19, 255); // Saddle Brown for dirt
                    break;
                case TILE_WATER:
                    SDL_SetRenderDrawColor(renderer, 70, 130, 180, 255); // Steel Blue for water
                    break;
                case TILE_WAY:
                    SDL_SetRenderDrawColor(renderer, 255, 223, 186, 255); // Peach for pathways
                    break;
                case TILE_ROAD:
                    SDL_SetRenderDrawColor(renderer, 128, 128, 128, 255); // Gray for roads
                    break;
                case TILE_TRACK:
                    SDL_SetRenderDrawColor(renderer, 139, 69, 19, 255); // Saddle Brown for tracks
                    break;
                case TILE_GRAVEL:
                    SDL_SetRenderDrawColor(renderer, 169, 169, 169, 255); // Light Gray for gravel
                    break;
                case TILE_WALL:
                    SDL_SetRenderDrawColor(renderer, 105, 105, 105, 255); // Dim Gray for walls
                    break;
                case TILE_EMPTY:
                    SDL_SetRenderDrawColor(renderer, 240, 248, 255, 255); // Alice Blue for empty tiles
                    break;
                case TILE_PLAYER_SPAWN:
                    SDL_SetRenderDrawColor(renderer, 255, 223, 0, 255); // Golden Yellow for player spawn
                    break;
                case TILE_CHARACTER_SPAWN:
                    SDL_SetRenderDrawColor(renderer, 255, 105, 180, 255); // Hot Pink for character spawn
                    break;
                case TILE_HOUSE:
                    SDL_SetRenderDrawColor(renderer, 178, 34, 34, 255); // Firebrick for houses
                    break;
                case TILE_COLLECTABLE:
                    SDL_SetRenderDrawColor(renderer, 255, 215, 0, 255); // Gold for collectibles
                    break;
                default:
                    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // Black for unknown types
                    break;
            }

            // Render the tile at the adjusted position
            SDL_FRect tileRect = { tile_x, tile_y, TILE_SIZE, TILE_SIZE };
            SDL_RenderFillRect(renderer, &tileRect);

            // Render Objects
            for (int i = 0; i < map_objects_count[y][x]; i++) {
                float w = 10, h = 10;
                float pos_x = tile_x, pos_y = tile_y;
                int char_id = map_objects[y][x][i] - CHARACTER_0;
                if (char_id >= 0 && char_id < CHARACTER_MAX-CHARACTER_0) {
                    w = characters[char_id].object->w;
                    h = characters[char_id].object->h;
                    pos_x = characters[char_id].object->x - camera.center_x + (camera.view_w / 2);
                    pos_y = characters[char_id].object->y - camera.center_y + (camera.view_h / 2);
                    if (char_id == 0) {
                        printf("REND_CAR %d %f %f\n", char_id, pos_x, tile_x);
                        printf("MIN %d %d %d %d\n", camera.min_y, camera.min_x, camera.max_y, camera.max_x);
                    }
                    Color co = characters[char_id].color;
                    SDL_SetRenderDrawColor(renderer, co.r, co.g, co.b, co.a);
                } else {
                    SDL_SetRenderDrawColor(renderer, 123,32,142,212);
                }
                switch (map_objects[y][x][i]) {
                    case CHARACTER_0:
                        break;
                    default:
                        break;
                }
                SDL_FRect objectRect = { pos_x, pos_y, w, h};
                SDL_RenderFillRect(renderer, &objectRect );
            }

        }
    }
}