refactoring of display fcts + added editor menu

.vscode/settings.json

@@ -6,6 +6,7 @@
         "sdl_image.h": "c",
         "display.h": "c",
         "base.h": "c",
-        "assembly.h": "c"
+        "assembly.h": "c",
+        "limits": "c"
     }
 }

src/assembly.c

@@ -18,6 +18,7 @@
 #include "assembly.h"
 
 cell* start ;
+cell* current ;
 
 int* item_costs ;
 int* item_start ;
@@ -30,6 +31,9 @@ cell** playerCells ;
 
 player* players ;
 
+imgs digits ;
+imgs letters ;
+
 void init_empty_board() {
     start = malloc(sizeof(cell));
     start->id = 0 ;
@@ -47,6 +51,8 @@ void init_empty_board() {
     start->next_4 = NULL;
     start->meta = "start";
 
+    current = start ;
+
     cell_count = malloc(sizeof(int)*n_cell_type);
     cell_count[0] = 1;
     for(int i = 1; i < n_cell_type; i++) {
@@ -145,13 +151,261 @@ void init_shop(char* filename) {
     fclose(ptr);
 }
 
-void init_everything() {
+void import_digits(SDL_Renderer* renderer) {
+    imgs res;
+    res.arr = malloc(sizeof(SDL_Texture*)*10);
+    SDL_Texture* texture;
+    SDL_Surface* img;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-0.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[0] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-1.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[1] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-2.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[2] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-3.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[3] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-4.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[4] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-5.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[5] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-6.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[6] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-7.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[7] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-8.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[8] = texture;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/digits/digit-9.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[9] = texture;
+
+    res.len = 10 ;
+    digits = res;
+}
+
+void import_letters(SDL_Renderer* renderer) {
+    imgs res;
+    res.arr = malloc(sizeof(SDL_Texture*)*26);
+    SDL_Texture* texture;
+    SDL_Surface* img;
+
+    int cc = 0 ;
+
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-a.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-b.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-c.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-d.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-e.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-f.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-g.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-h.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-i.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-j.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-k.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-l.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-m.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-n.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-o.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-p.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-q.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-r.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-s.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-t.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-u.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-v.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-w.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-x.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-y.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+    cc += 1 ;
+    // -------------------------------------------------------- //
+    img = SDL_LoadBMP("./res/letters/letter-z.bmp");
+    texture = SDL_CreateTextureFromSurface(renderer, img);
+    SDL_FreeSurface(img);
+    res.arr[cc] = texture;
+
+    res.len = 26 ;
+    letters = res;
+}
+
+void free_digits(imgs dgts) {
+    for(int i = 0; i < dgts.len; i++) {
+        SDL_DestroyTexture(dgts.arr[i]);
+    }
+    free(dgts.arr);
+}
+
+void init_everything(SDL_Renderer* renderer) {
     printf("Initializing board...\n");
     init_empty_board();
     printf("Initializing players...\n");
     init_players();
     printf("Initializing items...\n");
     init_shop("src/config.txt");
+    printf("Initializing digits...\n");
+    import_digits(renderer);
+    import_letters(renderer);
     printf("Initialization complete!\n\n");
     //print_items();
 }
@@ -177,6 +431,9 @@ void destroy_everything() {
     free(item_is_special_type);
     free(cell_count);
 
+    free_digits(digits);
+    free_digits(letters);
+
     printf("Destruction complete!...\n\n");
 }
 

src/assembly.h

@@ -7,7 +7,13 @@ void init_players();
 
 void init_shop(char* filename);
 
-void init_everything();
+void import_digits(SDL_Renderer* renderer);
+
+void import_letters(SDL_Renderer* renderer);
+
+void free_digits(imgs dgts);
+
+void init_everything(SDL_Renderer* renderer);
 
 void destroy_everything();
 

src/base.c

@@ -14,8 +14,6 @@
 #include "consts.h"
 #include "base.h"
 
-imgs digits ;
-
 int ln_baseN(int n, int b) {
     int r = 0;
     while(n != 0) {
@@ -71,82 +69,6 @@ double distance_pt(int x1, int x2, int y1, int y2) {
     return sqrt(to_double(pw(x2 - x1, 2) + pw(y2 - y1, 2)));
 }
 
-void import_digits(SDL_Renderer* renderer) {
-    imgs res;
-    res.arr = malloc(sizeof(SDL_Texture*)*10);
-    SDL_Texture* texture;
-    SDL_Surface* img;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-0.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[0] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-1.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[1] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-2.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[2] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-3.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[3] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-4.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[4] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-5.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[5] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-6.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[6] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-7.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[7] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-8.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[8] = texture;
-
-    // -------------------------------------------------------- //
-    img = SDL_LoadBMP("./res/digits/digit-9.bmp");
-    texture = SDL_CreateTextureFromSurface(renderer, img);
-    SDL_FreeSurface(img);
-    res.arr[9] = texture;
-
-    digits = res;
-}
-
-void free_digits(imgs dgts) {
-    for(int i = 0; i < 10; i++) {
-        SDL_DestroyTexture(dgts.arr[i]);
-    }
-    free(dgts.arr);
-}
-
 bool is_star_allowed(int ctype) {
     return ((CELLTYPE)ctype == BLUE) ;
 }

src/base.h

@@ -19,10 +19,6 @@ int to_int(double n);
 
 double distance_pt(int x1, int x2, int y1, int y2);
 
-void import_digits(SDL_Renderer* renderer);
-
-void free_digits(imgs dgts);
-
 bool is_star_allowed(int ctype);
 
 bool is_hidden_block_allowed(int ctype);

src/consts.h

@@ -100,9 +100,14 @@ extern player* players ;
 extern imgs digits ;
 // len is always 10 for this
 
+extern imgs letters ;
+// len is always 26 for this
+
 static int __width__ = 1200 ;
 static int __height__ = 800 ;
 
 static int tile_size = 50 ;
 
+extern cell* current ;
+
 #endif

src/display.c

@@ -41,6 +41,7 @@ void placeRectToRenderer(SDL_Renderer* renderer, int X, int Y, int W, int H, int
 }
 
 void drawLineWithThicc(SDL_Renderer* renderer, int width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
+    // draws line with width (native SDL cannot do that)
     double theta = 0.0;
     double seglen = distance_pt(x1, x2, y1, y2);
     while(theta < 1.0) {
@@ -50,6 +51,8 @@ void drawLineWithThicc(SDL_Renderer* renderer, int width, int x1, int x2, int y1
 }
 
 void drawLineWithThiccGradient(SDL_Renderer* renderer, int start_width, int end_width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
+    // draws line with width ;
+    // width goes from start_width to end_with in a linear way
     double theta = 0.0;
     double seglen = distance_pt(x1, x2, y1, y2);
     while(theta < 1.0) {
@@ -77,6 +80,20 @@ void drawDigitToRenderer(SDL_Renderer* renderer, imgs data, int digit, int X, in
     SDL_RenderCopy(renderer, texture, NULL, &rect);
 }
 
+void drawCharToRenderer(SDL_Renderer* renderer, imgs data, char c, int X, int Y, int W, int H) {
+    if ((int)c >= 97 && (int)c <= 122) {
+        SDL_Rect rect;
+        rect.x = X;
+        rect.y = Y;
+        rect.w = W;
+        rect.h = H;
+            
+        SDL_Texture* texture = data.arr[(int)c - 97];
+        
+        SDL_RenderCopy(renderer, texture, NULL, &rect);
+    }
+}
+
 void drawNumberToRenderer(SDL_Renderer* renderer, imgs data, int n, int X, int Y, int W, int H, int Woffset) {
     if(n == 0) {
         drawDigitToRenderer(renderer, data, 0, X + W, Y, W, H);
@@ -91,6 +108,39 @@ void drawNumberToRenderer(SDL_Renderer* renderer, imgs data, int n, int X, int Y
     }
 }
 
+void drawStringToRenderer(SDL_Renderer* renderer, imgs data, char* s, int X, int Y, int W, int H) {
+    int k = 0 ;
+    while(s[k] != '\0') {
+        drawCharToRenderer(renderer, data, s[k], X + W*k, Y, W, H);
+        k += 1;
+    }
+}
+
+long cell_colors(cell* cl) {
+    switch (cl->type) {
+        case START:
+            return (long)(32) + (long)(256)*(long)(255) + (long)(256*256)*(long)(32);
+        case BLUE:
+            return (long)(32) + (long)(256)*(long)(32) + (long)(256*256)*(long)(255);
+        case RED:
+            return (long)(255) + (long)(256)*(long)(32) + (long)(256*256)*(long)(32);
+        case EVENT:
+            return (long)(32) + (long)(256)*(long)(128) + (long)(256*256)*(long)(32);
+        case VS:
+            return (long)(255) + (long)(256)*(long)(128) + (long)(256*256)*(long)(32);
+        case BOWSER:
+            return (long)(32) + (long)(256)*(long)(32) + (long)(256*256)*(long)(32);
+        case CHANCE_TIME:
+            return (long)(32) + (long)(256)*(long)(128) + (long)(256*256)*(long)(255);
+        case BOO:
+            return (long)(128) + (long)(256)*(long)(128) + (long)(256*256)*(long)(128);
+        case STAR:
+            return (long)(255) + (long)(256)*(long)(255) + (long)(256*256)*(long)(32);
+        case BANK:
+            return (long)(255) + (long)(256)*(long)(255) + (long)(256*256)*(long)(32);
+    }
+}
+
 void draw_cell(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax, cell* cl, int draw_id) {
     if(cl != NULL && cl->id != draw_id && cl->coord_x - tile_size > xmin && cl->coord_x - tile_size < xmax && cl->coord_y > ymin && cl->coord_y < ymax) {
         // draw lines
@@ -100,15 +150,19 @@ void draw_cell(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax, c
 
         if(cl->next_1 != NULL) {
             drawLineWithThiccGradient(renderer, tile_size, 3, nxmin, to_int((to_double(cl->next_1->coord_x) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)), nymin, to_int((to_double(cl->next_1->coord_y) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)), 255, 255, 0, SDL_ALPHA_OPAQUE);
+            drawDigitToRenderer(renderer, digits, 1, to_int((to_double((cl->coord_x + cl->next_1->coord_x)/2) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)) - 75/6, to_int((to_double((cl->coord_y + cl->next_1->coord_y)/2) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)) - 105/6, 75/3, 105/3);
         };
         if(cl->next_2 != NULL) {
             drawLineWithThiccGradient(renderer, tile_size, 3, nxmin, to_int((to_double(cl->next_2->coord_x) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)), nymin, to_int((to_double(cl->next_2->coord_y) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)), 255, 255, 0, SDL_ALPHA_OPAQUE);
+            drawDigitToRenderer(renderer, digits, 2, to_int((to_double((cl->coord_x + cl->next_2->coord_x)/2) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)) - 75/6, to_int((to_double((cl->coord_y + cl->next_2->coord_y)/2) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)) - 105/6, 75/3, 105/3);
         };
         if(cl->next_3 != NULL) {
             drawLineWithThiccGradient(renderer, tile_size, 3, nxmin, to_int((to_double(cl->next_3->coord_x) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)), nymin, to_int((to_double(cl->next_3->coord_y) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)), 255, 255, 0, SDL_ALPHA_OPAQUE);
+            drawDigitToRenderer(renderer, digits, 3, to_int((to_double((cl->coord_x + cl->next_3->coord_x)/2) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)) - 75/6, to_int((to_double((cl->coord_y + cl->next_3->coord_y)/2) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)) - 105/6, 75/3, 105/3);
         };
         if(cl->next_4 != NULL) {
             drawLineWithThiccGradient(renderer, tile_size, 3, nxmin, to_int((to_double(cl->next_4->coord_x) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)), nymin, to_int((to_double(cl->next_4->coord_y) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)), 255, 255, 0, SDL_ALPHA_OPAQUE);
+            drawDigitToRenderer(renderer, digits, 4, to_int((to_double((cl->coord_x + cl->next_4->coord_x)/2) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)) - 75/6, to_int((to_double((cl->coord_y + cl->next_4->coord_y)/2) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)) - 105/6, 75/3, 105/3);
         };
 
         // recursive calls
@@ -123,7 +177,13 @@ void draw_cell(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax, c
         draw_cell(renderer, xmin, xmax, ymin, ymax, cl->next_4, draw_id);
         
         // draw current cell
-        placeRectToRenderer(renderer, nxmin-tile_size/2, nymin-tile_size/2, tile_size, tile_size, 255, 255, 255, SDL_ALPHA_OPAQUE);
+
+        long packed_colors = cell_colors(cl);
+
+        if(cl == current) {
+            placeRectToRenderer(renderer, nxmin-tile_size/2-10, nymin-tile_size/2-10, tile_size+20, tile_size+20, 255, 255, 255, SDL_ALPHA_OPAQUE);
+        };
+        placeRectToRenderer(renderer, nxmin-tile_size/2, nymin-tile_size/2, tile_size, tile_size, (int)(packed_colors%256), (int)((packed_colors/256)%256), (int)((packed_colors/256/256)%256), SDL_ALPHA_OPAQUE);
     } else if(cl != NULL) {
         cl->id = draw_id;
     }
@@ -134,10 +194,6 @@ void draw_board(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax,
         fprintf(stderr, "ERROR : cannot draw NULL cell\n");
         exit(1);
     } else {
-        resetRenderer(renderer);
-
         draw_cell(renderer, xmin, xmax, ymin, ymax, one_cell, (one_cell->id +1)%727);
-
-        updateRenderer(renderer);
     }
 }

src/display.h

@@ -15,8 +15,14 @@ void drawLineWithThiccGradient(SDL_Renderer* renderer, int start_width, int end_
 
 void drawDigitToRenderer(SDL_Renderer* renderer, imgs data, int digit, int X, int Y, int W, int H);
 
+void drawCharToRenderer(SDL_Renderer* renderer, imgs data, char c, int X, int Y, int W, int H);
+
 void drawNumberToRenderer(SDL_Renderer* renderer, imgs data, int n, int X, int Y, int W, int H, int Woffset);
 
+void drawStringToRenderer(SDL_Renderer* renderer, imgs data, char* s, int X, int Y, int W, int H);
+
+long cell_colors(cell* cl);
+
 void draw_cell(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax, cell* cl, int draw_id);
 
 void draw_board(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax, cell* one_cell);

src/edit.c

@@ -13,6 +13,7 @@
 
 #include "consts.h"
 #include "base.h"
+#include "display.h"
 #include "edit.h"
 
 void link_cells(cell* parent, cell* child) {
@@ -94,6 +95,20 @@ void append_cell(int cell_type, int X, int Y, cell* parent) {
     cell_count[cell_type] += 1;
 }
 
+void append_cell_orthogonal(int cell_type, char dir, cell* parent) {
+    if(dir == 'N' || dir == 'n') {
+        append_cell(cell_type, parent->coord_x, parent->coord_y + tile_size * 2, parent);
+    } else if(dir == 'E' || dir == 'e') {
+        append_cell(cell_type, parent->coord_x + tile_size * 2, parent->coord_y, parent);
+    } else if(dir == 'W' || dir == 'w') {
+        append_cell(cell_type, parent->coord_x - tile_size * 2, parent->coord_y, parent);
+    } else if(dir == 'S' || dir == 's') {
+        append_cell(cell_type, parent->coord_x, parent->coord_y - tile_size * 2, parent);
+    } else {
+        fprintf(stderr, "ERROR : invalid direction (%d)", dir);
+    }
+}
+
 void destroy_cell(cell* cl) {
     unlink_cells(cl, cl->next_1);
     unlink_cells(cl, cl->next_2);
@@ -108,4 +123,178 @@ void destroy_cell(cell* cl) {
     cell_count[(int)cl->type] -= 1;
 
     free(cl);
+}
+
+bool isAdding = false ;
+int editBuffer = 0 ;
+int phase = 0 ;
+
+int editCellType = 0 ;
+int editDirection = 0 ;
+
+void playerEditActions(bool* finished) {
+    SDL_Event event;
+    while(SDL_PollEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+                break;
+            case SDL_KEYDOWN:
+                switch (event.key.keysym.sym) {
+                    case SDLK_1:
+                        if(!isAdding && current->next_1 != NULL) {
+                            current = current->next_1;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 1;
+                        };
+                        break;
+                    case SDLK_2:
+                        if(!isAdding && current->next_2 != NULL) {
+                            current = current->next_2;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 2;
+                        };
+                        break;
+                    case SDLK_3:
+                        if(!isAdding && current->next_3 != NULL) {
+                            current = current->next_3;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 3;
+                        };
+                        break;
+                    case SDLK_4:
+                        if(!isAdding && current->next_4 != NULL) {
+                            current = current->next_4;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 4;
+                        };
+                        break;
+                    case SDLK_0:
+                        if(!isAdding && current->prev_1 != NULL) {
+                            current = current->prev_1;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                        };
+                        break;
+                    case SDLK_9:
+                        if(!isAdding && current->prev_2 != NULL) {
+                            current = current->prev_2;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 9;
+                        };
+                        break;
+                    case SDLK_8:
+                        if(!isAdding && current->prev_3 != NULL) {
+                            current = current->prev_3;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 8;
+                        };
+                        break;
+                    case SDLK_7:
+                        if(!isAdding && current->prev_4 != NULL) {
+                            current = current->prev_4;
+                        } else if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 7;
+                        };
+                        break;
+                    case SDLK_6:
+                        if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 6;
+                        };
+                        break;
+                    case SDLK_5:
+                        if (isAdding) {
+                            editBuffer *= 10;
+                            editBuffer += 5;
+                        };
+                        break;
+                    case SDLK_MINUS:
+                        if (isAdding) {
+                            editBuffer = editBuffer / 10;
+                        };
+                        break;
+                    case SDLK_SPACE:
+                        if(isAdding) {
+                            if(phase == 0) {
+                                editCellType = editBuffer%n_cell_type;
+                            } else if(phase == 1) {
+                                editDirection = editBuffer%4;
+                                phase = -1;
+                                isAdding = false;
+                                char dir ;
+                                if(editDirection == 0) {
+                                    dir = 's';
+                                } else if(editDirection == 1) {
+                                    dir = 'e';
+                                } else if(editDirection == 2) {
+                                    dir = 'n';
+                                } else if(editDirection == 3) {
+                                    dir = 'w';
+                                };
+                                append_cell_orthogonal(editCellType, dir, current);
+                                printf("exit adding...\n");
+                            };
+                            phase += 1;
+                            editBuffer = 0;
+                        };
+                        break;
+                    case SDLK_p:
+                        isAdding = true ;
+                        phase = 0 ;
+                        printf("now adding...\n");
+                        break;
+                    case SDLK_TAB:
+                        *finished = true;
+                        break;
+                }
+        }
+    }
+}
+
+void draw_types(SDL_Renderer* renderer) {
+    drawStringToRenderer(renderer, letters, "start",  __width__ - 6 * 75/2,  50, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "blue",   __width__ - 5 * 75/2, 100, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "red",    __width__ - 4 * 75/2, 150, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "event",  __width__ - 6 * 75/2, 200, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "vs",     __width__ - 3 * 75/2, 250, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "bowser", __width__ - 7 * 75/2, 300, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "chance", __width__ - 7 * 75/2, 350, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "boo",    __width__ - 4 * 75/2, 400, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "star",   __width__ - 5 * 75/2, 450, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "bank",   __width__ - 5 * 75/2, 500, 75/2, 105/2);
+}
+
+void draw_directions(SDL_Renderer* renderer) {
+    drawStringToRenderer(renderer, letters, "north", __width__ - 6 * 75/2,  50, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "east",  __width__ - 5 * 75/2, 100, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "south", __width__ - 6 * 75/2, 150, 75/2, 105/2);
+    drawStringToRenderer(renderer, letters, "west",  __width__ - 5 * 75/2, 200, 75/2, 105/2);
+}
+
+void edit_main(SDL_Renderer* renderer) {
+    bool finished = false;
+    while(!finished) {
+        resetRenderer(renderer);
+        draw_board(renderer, current->coord_x - tile_size * 7, current->coord_x + tile_size * 7, current->coord_y - tile_size * 7, current->coord_y + tile_size * 7, current);
+        if(isAdding) {
+            if(phase == 0) {
+                drawStringToRenderer(renderer, letters, "choose type", 50, 50, 75/2, 105/2);
+                draw_types(renderer);
+            } else {
+                drawStringToRenderer(renderer, letters, "choose direction", 50, 50, 75/2, 105/2);
+                draw_directions(renderer);
+            };
+            drawNumberToRenderer(renderer, digits, editBuffer, 50, 150, 75/2, 105/2, 0);
+        };
+        updateRenderer(renderer);
+        playerEditActions(&finished);
+        usleep(20000);
+    }
 }

src/edit.h

@@ -9,4 +9,12 @@ void append_cell(int cell_type, int X, int Y, cell* parent);
 
 void destroy_cell(cell* cl);
 
+void playerEditActions(bool* finished);
+
+void draw_types(SDL_Renderer* renderer);
+
+void draw_directions(SDL_Renderer* renderer);
+
+void edit_main(SDL_Renderer* renderer);
+
 #endif

src/main.c

@@ -42,18 +42,9 @@ int main(int argc, char** argv) {
 
     /* -------------------------------------------------------- */
 
-    init_everything();
+    init_everything(rend);
 
-    draw_board(rend, -250, 250, -250, 250, start);
-    sleep(1);
-
-    append_cell(1, 75, 75, start);
-    draw_board(rend, -250, 250, -250, 250, start);
-    sleep(1);
-
-    append_cell(1, 75, 0, start->next_1);
-    draw_board(rend, -250, 250, -250, 250, start);
-    sleep(1);
+    edit_main(rend);
     
     destroy_everything();