290 lines
8.0 KiB
C
290 lines
8.0 KiB
C
//
|
|
// Created by bruno on 4/24/25.
|
|
//
|
|
|
|
#include <dirent.h>
|
|
#include "util.h"
|
|
#include "../tiles/tile.h"
|
|
#include "font.h"
|
|
//#include "font.h"
|
|
|
|
|
|
//The window we'll be rendering to
|
|
SDL_Window *window = NULL;
|
|
volatile bool running = true;
|
|
|
|
WaveInfo waveInfo;
|
|
|
|
const char OrientStrings[ORIENT_DIRECTION_COUNT][10] = {
|
|
"LEFT_DOWN",
|
|
"LEFT",
|
|
"LEFT_UP",
|
|
"UP",
|
|
"RIGHT_UP",
|
|
"RIGHT",
|
|
"RIGHT_DOWN",
|
|
"DOWN",
|
|
};
|
|
|
|
int animationStep = 0;
|
|
|
|
bool debugMode = false;
|
|
bool itemViewing = false;
|
|
bool renderAtlas = false;
|
|
|
|
//The surface contained by the window
|
|
SDL_Renderer *mainRenderer = NULL;
|
|
|
|
SDL_Rect screenRect;
|
|
|
|
SDL_Texture *createFlippedTexture(SDL_Renderer *renderer, SDL_Texture *src, SDL_RendererFlip flip) {
|
|
int w, h;
|
|
SDL_QueryTexture(src, NULL, NULL, &w, &h);
|
|
|
|
SDL_Texture *renderTarget = SDL_GetRenderTarget(renderer);
|
|
|
|
SDL_Texture *target = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h);
|
|
SDL_SetRenderTarget(renderer, target);
|
|
SDL_RenderCopyEx(renderer, src, NULL, NULL, 0, NULL, flip);
|
|
SDL_SetRenderTarget(renderer, renderTarget);
|
|
|
|
return target;
|
|
}
|
|
|
|
SDL_Texture *createRotatedTexture(SDL_Renderer *renderer, SDL_Texture *src, double angle) {
|
|
int w, h;
|
|
SDL_QueryTexture(src, NULL, NULL, &w, &h);
|
|
SDL_Texture *renderTarget = SDL_GetRenderTarget(renderer);
|
|
|
|
SDL_Texture *target = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h);
|
|
SDL_SetRenderTarget(renderer, target);
|
|
SDL_RenderCopyEx(renderer, src, NULL, NULL, angle, NULL, SDL_FLIP_NONE);
|
|
SDL_SetRenderTarget(renderer, renderTarget);
|
|
|
|
return target;
|
|
}
|
|
|
|
SDL_Texture *ScaleTexture(SDL_Renderer *renderer, SDL_Texture *src, int newWidth, int newHeight) {
|
|
SDL_Texture *scaledTex = SDL_CreateTexture(renderer,
|
|
SDL_PIXELFORMAT_RGBA8888,
|
|
SDL_TEXTUREACCESS_TARGET,
|
|
newWidth,
|
|
newHeight);
|
|
|
|
if (!scaledTex) {
|
|
SDL_Log("Failed to create target texture: %s", SDL_GetError());
|
|
return nullptr;
|
|
}
|
|
|
|
// Save current render target
|
|
SDL_Texture *oldTarget = SDL_GetRenderTarget(renderer);
|
|
|
|
SDL_SetRenderTarget(renderer, scaledTex);
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
|
|
SDL_RenderClear(renderer);
|
|
|
|
SDL_Rect dst = {0, 0, newWidth, newHeight};
|
|
SDL_RenderCopy(renderer, src, NULL, &dst);
|
|
|
|
SDL_SetRenderTarget(renderer, oldTarget); // Restore
|
|
|
|
return scaledTex;
|
|
}
|
|
|
|
void DrawThickRect(SDL_Renderer *renderer, SDL_Rect rect, int thickness) {
|
|
for (int i = 0; i < thickness; i++) {
|
|
SDL_Rect r = {rect.x - i, rect.y - i, rect.w + i * 2, rect.h + i * 2};
|
|
SDL_RenderDrawRect(renderer, &r);
|
|
}
|
|
}
|
|
|
|
void renderBar(SDL_Renderer *renderer,
|
|
int x, int y, int width, int height,
|
|
int maxValue, int currentValue,
|
|
SDL_Color barColor, int margin) {
|
|
if (maxValue <= 0) return; // Avoid division by zero
|
|
|
|
// Clamp value
|
|
if (currentValue < 0) currentValue = 0;
|
|
if (currentValue == 0) {
|
|
return;
|
|
}
|
|
if (currentValue > maxValue) currentValue = maxValue;
|
|
|
|
// Calculate filled width based on currentValue
|
|
int filledWidth = (width * currentValue) / maxValue;
|
|
|
|
// Bar rectangle
|
|
SDL_Rect barRect = {x, y, filledWidth, height};
|
|
|
|
// Background rectangle with margin
|
|
SDL_Rect bgRect = {
|
|
x - margin,
|
|
y - margin,
|
|
width + margin * 2,
|
|
height + margin * 2
|
|
};
|
|
|
|
// Draw background (black)
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
|
SDL_RenderFillRect(renderer, &bgRect);
|
|
|
|
// Draw bar with provided color
|
|
SDL_SetRenderDrawColor(renderer, barColor.r, barColor.g, barColor.b, barColor.a);
|
|
SDL_RenderFillRect(renderer, &barRect);
|
|
|
|
char barString[20];
|
|
sprintf(barString, "%d/%d", currentValue, maxValue);
|
|
|
|
renderText(mainRenderer, fonts[1], barString, x + (width / 2 - (fonts[2].size * strlen(barString))), y - fonts[2].size - barRect.h);
|
|
}
|
|
|
|
int cmpstringp(const void *p1, const void *p2) {
|
|
return strcmp(*(const char **) p1, *(const char **) p2);
|
|
}
|
|
|
|
|
|
// Helper function to iterate over sorted entries in a directory
|
|
void iterateSortedDir(const char *path, DirEntryCallback callback, SDL_Renderer *renderer) {
|
|
DIR *dir = opendir(path);
|
|
if (!dir) {
|
|
perror("opendir");
|
|
return;
|
|
}
|
|
|
|
struct dirent *entry;
|
|
char **names = NULL;
|
|
size_t count = 0;
|
|
|
|
// Collect file names
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
if (entry->d_name[0] == '.') continue;
|
|
names = realloc(names, sizeof(char *) * (count + 1));
|
|
if (!names) {
|
|
perror("realloc");
|
|
closedir(dir);
|
|
return;
|
|
}
|
|
names[count++] = strdup(entry->d_name);
|
|
}
|
|
closedir(dir);
|
|
|
|
// Sort entries
|
|
qsort(names, count, sizeof(char *), cmpstringp);
|
|
|
|
// Call the user-provided function for each file
|
|
if (names != NULL) {
|
|
for (size_t i = 0; i < count; i++) {
|
|
if (names[i] != NULL) {
|
|
callback(names[i], renderer);
|
|
free(names[i]);
|
|
}
|
|
}
|
|
free(names);
|
|
}
|
|
}
|
|
|
|
bool checkCollision(SDL_Rect a, SDL_Rect b) {
|
|
//The sides of the rectangles
|
|
int leftA, leftB;
|
|
int rightA, rightB;
|
|
int topA, topB;
|
|
int bottomA, bottomB;
|
|
|
|
//Calculate the sides of tileRect A
|
|
leftA = a.x;
|
|
rightA = a.x + a.w;
|
|
topA = a.y;
|
|
bottomA = a.y + a.h;
|
|
|
|
//Calculate the sides of tileRect B
|
|
leftB = b.x;
|
|
rightB = b.x + b.w;
|
|
topB = b.y;
|
|
bottomB = b.y + b.h;
|
|
|
|
//If any of the sides from A are outside of B
|
|
if (bottomA <= topB) {
|
|
return false;
|
|
}
|
|
|
|
if (topA >= bottomB) {
|
|
return false;
|
|
}
|
|
|
|
if (rightA <= leftB) {
|
|
return false;
|
|
}
|
|
|
|
if (leftA >= rightB) {
|
|
return false;
|
|
}
|
|
|
|
//If none of the sides from A are outside B
|
|
return true;
|
|
}
|
|
|
|
bool canMoveTo(SDL_Rect newRect) {
|
|
// Round down to get all tiles the rect overlaps
|
|
int left = newRect.x / TILE_SIZE;
|
|
int right = (newRect.x + newRect.w - 1) / TILE_SIZE;
|
|
int top = newRect.y / TILE_SIZE;
|
|
int bottom = (newRect.y + newRect.h - 1) / TILE_SIZE;
|
|
|
|
for (int tx = left; tx <= right; ++tx) {
|
|
for (int ty = top; ty <= bottom; ++ty) {
|
|
MiniRect tile = { tx, ty };
|
|
if (!isWalkable(tile)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool canMoveWithRadius(SDL_Rect centerRect) {
|
|
// 16px radius — create a square bounding box around center
|
|
int radius = 16;
|
|
|
|
int left = (centerRect.x - radius) / TILE_SIZE;
|
|
int right = (centerRect.x + radius - 1) / TILE_SIZE;
|
|
int top = (centerRect.y - radius) / TILE_SIZE;
|
|
int bottom = (centerRect.y + radius - 1) / TILE_SIZE;
|
|
|
|
int x, y;
|
|
for (x = left; x <= right; x++) {
|
|
for (y = top; y <= bottom; y++) {
|
|
MiniRect tile;
|
|
tile.x = x;
|
|
tile.y = y;
|
|
|
|
if (!isWalkable(tile)) {
|
|
// Get pixel bounds of tile
|
|
int tileLeft = x * TILE_SIZE;
|
|
int tileRight = tileLeft + TILE_SIZE;
|
|
int tileTop = y * TILE_SIZE;
|
|
int tileBottom = tileTop + TILE_SIZE;
|
|
|
|
// Bounding box of the player
|
|
int playerLeft = centerRect.x - radius;
|
|
int playerRight = centerRect.x + radius;
|
|
int playerTop = centerRect.y - radius;
|
|
int playerBottom = centerRect.y + radius;
|
|
|
|
// AABB collision check
|
|
if (playerRight > tileLeft && playerLeft < tileRight &&
|
|
playerBottom > tileTop && playerTop < tileBottom) {
|
|
return 0; // Collision
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1; // No collisions
|
|
}
|
|
|
|
int compareStrings(const void *a, const void *b) {
|
|
const char *strA = *(const char **) a;
|
|
const char *strB = *(const char **) b;
|
|
return strcmp(strA, strB);
|
|
} |