big refactor

src/engine/animation.h

@@ -0,0 +1,28 @@
+#ifndef ANIMATION_H
+#define ANIMATION_H
+
+typedef struct {    
+    int currentFrame;       
+    int maxFrame;           
+    int framesCounter;      
+    int framesSpeed;        
+    float animTimer;  
+} Animation;
+
+void UpdateAnimation(Animation *animation, float deltaTime) {
+    animation->animTimer += deltaTime;
+    float frameTime = 1.0f / animation->framesSpeed;
+
+    if (animation->animTimer < frameTime) {
+        return;
+    }
+
+    animation->animTimer -= frameTime;
+    animation->currentFrame++;
+
+    if (animation->currentFrame >= animation->maxFrame) {
+        animation->currentFrame = 0;
+    }
+}
+
+#endif // ANIMATION_H

src/engine/camera.h

@@ -0,0 +1,29 @@
+#ifndef CAMERA_H
+#define CAMERA_H
+#include "input.h" 
+
+Camera2D CreateCamera(int screenWidth, int screenHeight, Vector2 playerPosition, float initZoom){
+    return (Camera2D){
+        .offset = (Vector2){screenWidth / 2.0f, screenHeight / 2.0f},
+        .target = playerPosition,
+        .rotation = 0.0f,
+        .zoom = initZoom
+    };
+}
+
+void UpdateCameraTarget(Camera2D *camera, Vector2 *position, const float smoothness){
+    camera->target = Vector2Lerp(camera->target, *position, smoothness * GetFrameTime());
+}
+
+void UpdateCameraZoom(Camera2D *camera, const float *scaleFactor, const float *minZoom, const float *maxZoom){
+    float targetZoom = Clamp(camera->zoom * *scaleFactor, *minZoom, *maxZoom);
+    camera->zoom = Lerp(camera->zoom, targetZoom, 0.1f);
+}
+
+void UpdateCamera2D(Camera2D* camera, Vector2* position, Mouse* mouse){
+    UpdateCameraTarget(camera, position, 5.0f);
+    UpdateCameraZoom(camera, &mouse->scaleFactor, &mouse->minZoom, &mouse->maxZoom);
+}
+
+
+#endif // CAMERA_H

src/engine/gui.h

@@ -0,0 +1,29 @@
+#ifndef GUI_H
+#define GUI_H
+
+#define RAYGUI_IMPLEMENTATION
+#include "../include/raygui.h"
+
+typedef struct
+{
+    Rectangle rec;
+    const char *text;
+} Button;
+
+void initButton(Button *b, const char *text, int buttonWidth, int buttonHeight, int buttonPosX, int buttonPosY)
+{
+    b->rec = (Rectangle){buttonPosX - buttonWidth / 2, buttonPosY - buttonHeight / 2, buttonWidth, buttonHeight};
+    b->text = text;
+}
+
+int isButtonClicked(Button *b)
+{
+    return (CheckCollisionPointRec(GetMousePosition(), b->rec) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON));
+}
+
+void renderButton(Button *b)
+{
+    GuiButton(b->rec, b->text);
+}
+
+#endif // GUI_H

src/engine/input.h

@@ -0,0 +1,48 @@
+#ifndef INPUT_H
+#define INPUT_H
+
+typedef struct {
+    Vector2 worldPosition;
+    float zoomSpeed;
+    float minZoom;
+    float maxZoom;
+    float scaleFactor;
+    float wheelMove;
+    bool leftButton;
+    bool rightButton;
+} Mouse;
+
+Mouse CreateMouse(float zoomSpeed, float minZoom, float maxZoom){
+    return (Mouse){
+        .zoomSpeed = zoomSpeed,
+        .minZoom = minZoom,
+        .maxZoom = maxZoom
+    };
+}
+
+void UpdateMouse(Mouse *mouse, Camera2D *camera) {
+    mouse->worldPosition = GetScreenToWorld2D(GetMousePosition(), *camera);
+    mouse->leftButton = IsMouseButtonDown(MOUSE_LEFT_BUTTON);
+    mouse->rightButton = IsMouseButtonDown(MOUSE_RIGHT_BUTTON);
+    
+    // Calculate zoom scale factor
+    mouse->wheelMove = GetMouseWheelMove();
+    if (mouse->wheelMove != 0) {
+        float zoomFactor = 1.0f + (mouse->zoomSpeed * fabsf(mouse->wheelMove));
+        mouse->scaleFactor = (mouse->wheelMove < 0) ? (1.0f / zoomFactor) : zoomFactor;
+    } else {
+        mouse->scaleFactor = 1.0f;
+    }
+}
+
+Vector2 GetDirectionVector(void){
+    Vector2 vector = {.x = 0.0f, .y = 0.0f};
+    if (IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_D)){vector.x += 1.0f; }
+    if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_A)){ vector.x -= 1.0f; }
+    if (IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_S)){ vector.y += 1.0f; }
+    if (IsKeyDown(KEY_UP) || IsKeyDown(KEY_W)){ vector.y -= 1.0f; }
+    if (Vector2Length(vector) > 0.0f) {vector = Vector2Normalize(vector); }
+    return vector;
+}
+
+#endif //INPUT_H

src/engine/musicmanager.h

@@ -0,0 +1,23 @@
+#ifndef MUSICMANAGER_H
+#define MUSICMANAGER_H
+
+typedef struct {
+    Music music;
+    bool playing;
+} MyMusic;
+
+MyMusic CreateMusic(char* musicPath){
+    MyMusic music = {
+        .music = LoadMusicStream(musicPath),
+        .playing = 0
+    };
+    PlayMusicStream(music.music);
+    return music; 
+}
+
+void UpdateMusic(MyMusic* music){
+    UpdateMusicStream(music->music);
+}
+
+#endif // MUSICMANAGER_H
+

src/engine/object.h

@@ -0,0 +1,129 @@
+#ifndef OBJECT_H
+#define OBJECT_H
+#include "sprite.h" 
+#include "vector.h"
+
+
+typedef struct {
+    Sprite sprite;
+    Vector2 position;
+} Object;
+
+typedef struct {
+    Object *data;
+    const Object *prototype;
+    size_t count;
+} ObjectArray;
+
+ObjectArray CreateObjectArray(const Object *prototype, const size_t count) {
+    ObjectArray objects = {0};
+
+    if (count == 0) {
+        printf("Objects size must be greater than 0.\n");
+        return objects;
+    }
+
+    objects.count = count;
+    objects.data = (Object* )malloc(count * sizeof(Object));
+
+    if (!objects.data) {
+        printf("Memory allocation of objects failed.\n");
+        return objects;
+    }
+
+    objects.prototype = prototype;
+
+    for (int i = 0; i < count; i++) {
+        objects.data[i].position = prototype->position;
+        objects.data[i].sprite = prototype->sprite;
+    }
+    return objects;
+}
+
+Object* GetRandomObject(ObjectArray *objects){
+    if (objects->count == 0 || objects->data == NULL) {
+        return NULL;
+    }
+    return &objects->data[GetRandomValue(0, (int)objects->count-1)];
+}
+
+void AddObjectToArray(ObjectArray *objects, const Object *prototype, Vector2 position) {
+    Object *newData = (Object* )realloc(objects->data, (objects->count + 1) * sizeof(Object));
+    if (newData) {
+        objects->data = newData;
+        objects->data[objects->count] = *prototype;
+        objects->data[objects->count].position = position;
+        objects->data[objects->count].sprite.destRec.x = position.x;
+        objects->data[objects->count].sprite.destRec.y = position.y;
+        objects->count++;
+    } else {
+        printf("Memory allocation failed while adding an object.\n");
+    }
+}
+
+void SetPositionForObjectArray(ObjectArray *objects, const Vector2Array *positions) {
+    if (positions->count != objects->count) {
+        printf("Warning: Position array size (%zu) does not match ObjectArray size (%zu)\n", positions->count, objects->count);
+        return;
+    }
+
+    for (size_t i = 0; i < objects->count; i++) {
+        objects->data[i].position = positions->data[i];
+        objects->data[i].sprite.destRec.x = positions->data[i].x;
+        objects->data[i].sprite.destRec.y = positions->data[i].y;
+    }
+}
+
+void SetRandomPositionForObjectArray(ObjectArray *objects, const Rectangle bounds){
+    for (int i = 0; i < objects->count; i++) {
+        Vector2 position = GetRandomVector(bounds);
+        objects->data[i].position = position;
+        objects->data[i].sprite.destRec.x = position.x;
+        objects->data[i].sprite.destRec.y = position.y;
+    }
+}
+
+void SwapAndPopObjectsArrayOnRecCollision(ObjectArray *objects, const Rectangle rec){
+    for (int i = 0; i < objects->count; i++){
+
+        if (CheckCollisionRecs(rec, objects->data[i].sprite.destRec)){
+            if (objects->count == 1) {
+                objects->count = 0;
+                break;
+            }
+            objects->data[i] = objects->data[objects->count - 1];
+            objects->count--;
+            i--;
+        }
+    }
+    objects->data = (Object*)realloc(objects->data, objects->count * sizeof(Object));
+
+}
+
+void SwapAndPopObjectsArrayOnPointCollision(ObjectArray *objects, const Vector2 point){
+    for (int i = 0; i < objects->count; i++){
+
+        if (CheckCollisionPointRec(point, objects->data[i].sprite.destRec)){
+            if (objects->count == 1) {
+                objects->count = 0;
+                break;
+            }
+            objects->data[i] = objects->data[objects->count - 1];
+            objects->count--;
+            i--;
+        }
+    }
+    objects->data = (Object*)realloc(objects->data, objects->count * sizeof(Object));
+}
+
+Vector2 GetDirectionToObject(Object *object, Vector2 position){
+    return Vector2Normalize(Vector2Subtract(object->position, position));
+}
+
+void RenderObjectArray(const ObjectArray *objects){
+    for (int i = 0; i < objects->count; i++){
+        RenderSprite(&objects->data[i].sprite);
+    }
+}
+
+#endif // OBJECT_H

src/engine/physics.h

@@ -0,0 +1,33 @@
+#ifndef PHYSICS_H
+#define PHYSICS_H
+
+typedef struct {
+    Vector2 position;
+    Vector2 direction;
+    Vector2 velocity;
+    float speed;
+} Physics;
+
+void UpdatePhysicsDirection(Vector2 *direction, Vector2 vector){
+    *direction = vector;
+}
+
+void UpdatePhysicsVelocity(Vector2 *velocity, Vector2 *direction, float *speed){
+    *velocity = Vector2Scale(*direction, *speed * GetFrameTime());
+}
+
+void UpdatePhysicsPosition(Vector2 *position, Vector2 *velocity) {
+    *position = Vector2Add(*position, *velocity);
+}
+
+void UpdatePhysicsSpeed(float *speed, float *newSpeed){
+    *speed = *newSpeed;
+}
+
+void UpdatePhysics(Physics *physics, Vector2 target){
+    UpdatePhysicsDirection(&physics->direction, target);
+    UpdatePhysicsVelocity(&physics->velocity, &physics->direction, &physics->speed);
+    UpdatePhysicsPosition(&physics->position, &physics->velocity);
+}
+
+#endif // PHYSICS_H

src/engine/screen.h

@@ -0,0 +1,10 @@
+#ifndef SCREEN_H
+#define SCREEN_H
+
+typedef enum Screen {
+    LOGO = 0,
+    MENU,
+    GAMEPLAY
+} Screen;
+
+#endif // SCREEN_H

src/engine/settings.h

@@ -0,0 +1,10 @@
+#ifndef SETTINGS_H
+#define SETTINGS_H
+
+typedef struct {
+    int screenWidth;
+    int screenHeight;
+    const char* name;
+} Settings;
+
+#endif // SETTINGS_H

src/engine/shader.h

@@ -0,0 +1,40 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+typedef struct {
+    Shader shader;
+    int resolutionLoc;
+    int strengthLoc;
+    float strength;
+} VignetteShader;
+
+VignetteShader CreateShader(const char* shaderPath, float strength){
+    VignetteShader vignetteShader = {0};
+    vignetteShader.shader = LoadShader(NULL, shaderPath);
+
+    if (vignetteShader.shader.id == 0) {
+        TraceLog(LOG_ERROR, "Failed to load shader: %s", shaderPath);
+        return vignetteShader;
+    }
+
+    vignetteShader.strength = strength;
+    vignetteShader.resolutionLoc = GetShaderLocation(vignetteShader.shader, "resolution");
+    vignetteShader.strengthLoc = GetShaderLocation(vignetteShader.shader, "strength");
+    Vector2 resolution = { (float)GetScreenWidth(), (float)GetScreenHeight() };
+    SetShaderValue(vignetteShader.shader, vignetteShader.resolutionLoc, &resolution, SHADER_UNIFORM_VEC2);
+    return vignetteShader;
+}
+
+void UpdateShader(VignetteShader* vignetteShader){
+    if (vignetteShader->shader.id == 0) return;
+    SetShaderValue(vignetteShader->shader, vignetteShader->strengthLoc, &vignetteShader->strength, SHADER_UNIFORM_FLOAT);
+    Vector2 resolution = { (float)GetScreenWidth(), (float)GetScreenHeight() };
+    SetShaderValue(vignetteShader->shader, vignetteShader->resolutionLoc, &resolution, SHADER_UNIFORM_VEC2);
+}
+
+void UnloadVignetteShader(VignetteShader* vignetteShader){
+    if (vignetteShader->shader.id == 0) return;
+    UnloadShader(vignetteShader->shader);
+}
+
+#endif // SHADER_H

src/engine/sprite.h

@@ -0,0 +1,43 @@
+#ifndef SPRITE_H
+#define SPRITE_H
+
+typedef struct {
+    Texture2D texture;      
+    Rectangle sourceRec;    
+    Rectangle destRec;      
+    Vector2 frameSize;      
+    Vector2 origin;         
+    float rotation;         
+    Color color;
+} Sprite;
+
+void UpdateSpriteSourceRec(Sprite *sprite, const Vector2 *vector){
+    sprite->sourceRec.x = vector->x;
+    sprite->sourceRec.y = vector->y;
+}
+
+void UpdateSpriteDestRec(Sprite *sprite, const Vector2 *vector){
+    sprite->destRec.x = vector->x;
+    sprite->destRec.y = vector->y;
+}
+
+void UpdateSpriteRotation(Sprite *sprite, Vector2 *vector){
+    if(Vector2Length(*vector) <= 0.0f){
+        return;
+    }
+    float targetRotation = (float)atan2(vector->y, vector->x) * (180.0f / PI) + 90.0f;
+    sprite->rotation = Lerp(sprite->rotation, targetRotation, 0.1f); 
+}
+
+void RenderSprite(const Sprite *sprite){
+    DrawTexturePro(
+        sprite->texture, 
+        sprite->sourceRec, 
+        sprite->destRec, 
+        sprite->origin, 
+        sprite->rotation, 
+        sprite->color
+    );
+}
+
+#endif // SPRITE_H

src/engine/vector.h

@@ -0,0 +1,21 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+
+typedef struct {
+    Vector2 *data;
+    size_t count;
+} Vector2Array;
+
+bool IsVectorZero(Vector2 v) {
+    float epsilon = 0.01f;
+    return (fabs(v.x) < epsilon && fabs(v.y) < epsilon);
+}
+
+Vector2 GetRandomVector(const Rectangle bounds) {
+    return (Vector2){
+        bounds.x + (float)GetRandomValue(0, 10000) / 10000.0f * bounds.width,
+        bounds.y + (float)GetRandomValue(0, 10000) / 10000.0f * bounds.height
+    };
+}
+
+#endif // VECTOR_H