finished neko

.vscode/settings.json

@@ -7,6 +7,7 @@
         "array": "c",
         "string": "c",
         "string_view": "c",
-        "shape.h": "c"
+        "shape.h": "c",
+        "xfixes.h": "c"
     }
 }

build.sh

@@ -2,7 +2,8 @@
 
 echo Building with ...
 echo gcc src/main.c -o res/main $(pkg-config --cflags --libs sdl3 x11 xfixes sdl3-image)
-gcc src/main.c src/neko.c -I src/ -o res/main $(pkg-config --cflags --libs sdl3 x11 xfixes sdl3-image)
+gcc src/main.c src/neko.c -I src/ -o res/main $(pkg-config --cflags --libs sdl3 x11 xfixes sdl3-image) -lm
 
 echo Running...
-DISPLAY=:1 ./res/main
+#DISPLAY=:1 ./res/main
+./res/main

src/main.c

@@ -97,8 +97,9 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
 
     make_window_clickthrough();
     set_override_redirect();
+    SDL_SetDefaultTextureScaleMode(renderer, SDL_SCALEMODE_PIXELART);
 
-    neko_init(renderer);
+    neko_init(renderer, window);
 
     /* Open the image file */
     SDL_asprintf(&gif_path, "%ssample.gif", SDL_GetBasePath());

src/neko.c

@@ -1,16 +1,50 @@
 #include "neko.h"
 #include "common.h"
+#include <math.h>
 
-static SDL_Texture *texture = NULL;
 static int texture_width = 0;
 static int texture_height = 0;
 
 static float catx = 200;
 static float caty = 200;
+static float speed = 5.0;
 
-int neko_init(SDL_Renderer *renderer){
+#define TIME_BEFORE_SPLEEP 3000
-    SDL_Surface *surface = NULL;
+#define TIME_BEFORE_RUNNING 1000
-    char *neko_bmp_path = NULL;
+#define TIME_ANIM_INTERVAL 300
+
+enum CatState {
+    ST_SLEEPING,
+    ST_RUNNING,
+    ST_WAKING_UP,
+    ST_STAND_BY,
+} cat_state = ST_RUNNING;
+
+enum CatFrames {
+    STAND_BY=0,
+    WAKING_UP=1,
+    UP=2,
+    DOWN=4,
+    LEFT=6,
+    RIGHT=8,
+    UP_LEFT=10,
+    UP_RIGHT=12,
+    DOWN_RIGHT=14,
+    DOWN_LEFT=16,
+    SLEEPING=18,
+};
+
+static int state_timer;
+static int anim_timer = 0;
+static int current_frame = 0; 
+
+static float diffx, diffy;
+
+static IMG_Animation *anim;
+static SDL_Texture **anim_textures;
+
+int neko_init(SDL_Renderer *renderer, SDL_Window *window){
+    char *neko_gif_path = NULL;
     
     /* Textures are pixel data that we upload to the video hardware for fast drawing. Lots of 2D
        engines refer to these as "sprites." We'll do a static texture (upload once, draw many
@@ -18,47 +52,143 @@ int neko_init(SDL_Renderer *renderer){
 
     /* SDL_Surface is pixel data the CPU can access. SDL_Texture is pixel data the GPU can access.
        Load a .bmp into a surface, move it to a texture from there. */
-    SDL_asprintf(&neko_bmp_path, "%ssample.bmp", SDL_GetBasePath());  /* allocate a string of the full file path */
+    SDL_asprintf(&neko_gif_path, "%sreal_oneko.gif", SDL_GetBasePath());
-    surface = SDL_LoadBMP(neko_bmp_path);
+    anim = IMG_LoadAnimation(neko_gif_path);
-    if (!surface) {
+    if (!anim) {
-        SDL_Log("Couldn't load bitmap: %s", SDL_GetError());
+        SDL_Log("Couldn't load %s: %s\n", neko_gif_path, SDL_GetError());
         return SDL_APP_FAILURE;
     }
+    SDL_free(neko_gif_path);  /* done with this, the file is loaded. */
 
-    SDL_free(neko_bmp_path);  /* done with this, the file is loaded. */
+    texture_width = anim->w;
+    texture_height = anim->h;
 
-    texture_width = surface->w;
+    anim_textures = (SDL_Texture **)SDL_calloc(anim->count, sizeof(*anim_textures));
-    texture_height = surface->h;
+    if (!anim_textures) {
-
+        SDL_Log("Couldn't allocate textures\n");
-    texture = SDL_CreateTextureFromSurface(renderer, surface);
+        IMG_FreeAnimation(anim);
-    if (!texture) {
-        SDL_Log("Couldn't create static texture: %s", SDL_GetError());
         return SDL_APP_FAILURE;
     }
+    for (int i = 0; i < anim->count; ++i) {
+        anim_textures[i] = SDL_CreateTextureFromSurface(renderer, anim->frames[i]);
+    }
 
-    SDL_DestroySurface(surface);  /* done with this, the texture has a copy of the pixels now. */
+    SDL_AddTimer(50, move_cat, window);
-
 }
 
 void neko_render(SDL_Renderer *renderer, SDL_Window *window){
-    float mousex, mousey;
-    int windowx, windowy;
-    float diffx, diffy;
     SDL_FRect dst_rect;
 
-    SDL_GetGlobalMouseState(&mousex, &mousey);
+    dst_rect.x = catx;
-    SDL_GetWindowPosition(window, &windowx, &windowy);
+    dst_rect.y = caty;
-    diffx = catx-(mousex-(float)windowx);
+    dst_rect.h = WINDOW_HEIGHT/15;
-    diffy = caty-(mousey-(float)windowy);
+    dst_rect.w = WINDOW_HEIGHT/15;
-    SDL_Log("(%f, %f)", diffx, diffy);
 
-    dst_rect.x = catx+(diffx/diffy);
+    int texture_index = 0;
-    dst_rect.y = caty+(diffy/diffx);
+    switch (cat_state)
-    dst_rect.h = WINDOW_HEIGHT/10;
+    {
-    dst_rect.w = WINDOW_HEIGHT/10;
+    case ST_SLEEPING:
-    SDL_RenderTexture(renderer, texture, NULL, &dst_rect);
+        texture_index = SLEEPING+current_frame;
+        break;
+    case ST_WAKING_UP:
+        texture_index = WAKING_UP;
+        break;
+    case ST_STAND_BY:
+        texture_index = STAND_BY;
+        break;
+    case ST_RUNNING:
+        // We do this to know if our cat is moving in diagonals
+        double angle = fabs(atan((double) (diffy/diffx)));
+        if(angle<SDL_PI_D/3 && angle>SDL_PI_D/6){ // Diagonals
+            if(diffy<0){
+                if(diffx<0){
+                    texture_index = DOWN_RIGHT+current_frame;
+                }else{
+                    texture_index = DOWN_LEFT+current_frame;
+                }
+            }else{
+                if(diffx<0){
+                    texture_index = UP_RIGHT+current_frame;
+                }else{
+                    texture_index = UP_LEFT+current_frame;
+                }
+            }
+        }else{ // pas diagonals
+            if(fabs(diffy) > fabs(diffx)){
+                if(diffy<0){
+                    texture_index = DOWN+current_frame;
+                }else{
+                    texture_index = UP+current_frame;
+                }
+            }else{
+                if(diffx<0){
+                    texture_index = RIGHT+current_frame;
+                }else{
+                    texture_index = LEFT+current_frame;
+                }
+            }
+        }
+        break;
+    
+    default:
+        break;
+    }
+
+    SDL_RenderTexture(renderer, anim_textures[texture_index], NULL, &dst_rect);
+
+    if(SDL_GetTicks()-anim_timer > TIME_ANIM_INTERVAL){
+        current_frame = (current_frame+1) % 2;
+        anim_timer=SDL_GetTicks();
+    }
 }
 
 void neko_quit(){
-    SDL_DestroyTexture(texture);
+    SDL_DestroyTexture(anim_textures[current_frame]);
+}
+
+Uint32 move_cat(void *window, SDL_TimerID timerID, Uint32 interval){
+    float mousex, mousey;
+    float hypo;
+    int windowx, windowy;
+
+    SDL_GetGlobalMouseState(&mousex, &mousey);
+    SDL_GetWindowPosition(window, &windowx, &windowy);
+
+    diffx = catx-(mousex-(float)windowx);
+    diffy = caty-(mousey-(float)windowy);
+    hypo = sqrt(diffx*diffx + diffy*diffy); 
+    switch (cat_state)
+    {
+    case ST_RUNNING:
+        if (hypo>50){
+            catx -= (diffx*speed/hypo);
+            caty -= (diffy*speed/hypo);
+        }else{
+            cat_state = ST_STAND_BY;
+            state_timer = SDL_GetTicks();
+        }
+        break;
+    case ST_STAND_BY:
+        if (hypo>50){
+            cat_state = ST_RUNNING;
+        }else if (SDL_GetTicks()-TIME_BEFORE_SPLEEP > state_timer){
+            cat_state = ST_SLEEPING;
+        }
+        break;
+    case ST_SLEEPING:
+        if (hypo>50){
+            cat_state = ST_WAKING_UP;
+            state_timer = SDL_GetTicks();
+        }
+        break;
+    case ST_WAKING_UP:
+        if (SDL_GetTicks()-TIME_BEFORE_RUNNING > state_timer){
+            cat_state = ST_RUNNING;
+        }
+        break;
+    
+    default:
+        break;
+    }
+    return(interval);
 }

src/neko.h

@@ -7,8 +7,9 @@
 
 #include <stdio.h>
 
-int neko_init(SDL_Renderer *renderer);
+int neko_init(SDL_Renderer *renderer, SDL_Window *window);
 void neko_render(SDL_Renderer *renderer, SDL_Window *window);
 void neko_quit();
+Uint32 move_cat(void *window, SDL_TimerID timerID, Uint32 interval);
 
 #endif