Merged with Sorting

DepthSorting/bucket.c

@@ -4,37 +4,65 @@
 #include "../sprite.h"
 #include "../IsometricMap/tile.h"
 
-
-Bucket * BucketInit(Sprite *sprite, Tile *tile){
+Bucket * BucketInit(void *data, int type){
     Bucket *bucket = malloc(sizeof(Bucket));
-    if(sprite != 0){
-        bucket->type = 0;
-        bucket->sprite = sprite;
+
+    if(type == SPRITE){
+        bucket->sprite = (Sprite *) data;
         bucket->tile = 0;
-        bucket->depth = sprite->x + sprite->y + sprite->z;
+        bucket->depth = bucket->sprite->x + bucket->sprite->y + bucket->sprite->z;
     }
-    else if(tile != 0){
-        bucket->type = 1;
+    else if(type == TILE){
         bucket->sprite = 0;
-        bucket->tile = tile;
-        // TODO: Aktuell wird die Depth an der oberen Ecke berechnet, müsste es die untere sein? Oder eher die Mitte? Das scheint mir problematisch zu sein :o
-        bucket->depth = tile->x * 32 + tile->y * 32 + tile->z;
+        bucket->tile = (Tile *) data;
+        bucket->depth = bucket->tile->x * 32 + bucket->tile->y * 32 + bucket->tile->z;
+    }
+    else{
+        printf("WARNING: BucketInit called with unknown type! Undefined behavior expected\n");
     }
 
-    bucket->next = 0;
-    bucket->prev = 0;
+    bucket->type = type;
+
+    bucket->left = 0;
+    bucket->right = 0;
 
     return bucket;
 
 }
 
 void BucketInsert(Bucket *head, Bucket *new){
+    Bucket *current = head;
+
+    while(current != 0){
+        if(current->depth > new->depth){
+            // Rechter Teilbaum
+            if(current->right != 0){
+                current = current->right;
+            }
+            else{
+                current->right = new;
+                break;
+            }
+        }
+        else{
+            // Linker Teilbaum
+            if(current->left != 0){
+                current = current->left;
+            }
+            else{
+                current->left = new;
+                break;
+            }
+        }
+    }
+}
+
+void BucketRemove(Bucket *head, Bucket *new){
+    if(new->left == 0){
 
+    }
 }
 
-void BucketRemove(Bucket *new){
-    new->next->prev = new->prev;
-    new->prev->next = new->next;
+void BucketChanged(Bucket *head, Bucket *changed){
 
-    free(new);
-}
+}

DepthSorting/bucket.h

@@ -2,24 +2,28 @@
 #define BUCKET_H_
 #include "raylib.h"
 
+#define SPRITE 0
+#define TILE 1
+
 typedef struct Sprite Sprite;
 typedef struct Tile Tile;
-typedef struct Bucket Bucket;
 
 typedef struct Bucket{
-    int type; // 0: Sprite, 1: Tile
+    int type;
     Sprite *sprite;
     Tile *tile;
     float depth;
 
-    Bucket *next;
-    Bucket *prev;
+    struct Bucket *left;
+    struct Bucket *right;
 } Bucket;
 
-Bucket * BucketInit(Sprite *sprite, Tile *tile);
+Bucket * BucketInit(void *data, int type);
+
+void BucketInsert(struct Bucket *head, struct Bucket *new);
 
-void BucketInsert(Bucket *head, Bucket *new);
+void BucketRemove(struct Bucket *head, struct Bucket *new);
 
-void BucketRemove(Bucket *new);
+void BucketChanged(struct Bucket *head, struct Bucket *changed);
 
 #endif

Input/inputHandler.c

@@ -131,7 +131,8 @@ void mouseInput(Game *game){
             else if(inputHandler->cursorWorldPos.x > maxWidth){ printf("OutOfBoundsDestination Spawn\n");}
             else if(inputHandler->cursorWorldPos.y > maxHeight){ printf("OutOfBoundsDestination Spawn\n");}
             else {
-                ListInsertBack(sprites, SpriteCreate(game->textures, 1, inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y));
+                ListInsert(sprites, SpriteCreate(game->textures, 1, inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y));
+                ListPrintForward(sprites);
                 //ListInsertSorted(sprites, SpriteCreate(game->textures, 1, inputHandler->cursorWorldPos.x, inputHandler->cursorWorldPos.y));
             }
         } else{

IsometricMap/isometricMap.c

@@ -51,7 +51,7 @@ IsometricMap * IsometricMapInit(int layer){
             tmp->offsetX = offset->x;
             tmp->offsetY = offset->y;
             free(offset);
-            tmp->sortable = BucketInit(0, tmp);
+            tmp->sortable = BucketInit(tmp, TILE);
             tiles[i][j] = tmp;
         }
     }

List/list.c

@@ -19,50 +19,119 @@ void ListPrintForward(List *list){
     
     printf("\n[\n");
     while(current != 0){
-        //printf("(%f | %f),\n", current->data.x, current->data.y);
+        printf("%f,\n", current->data->depth);
         current = current->next;
     }
     printf("]\n");
 }
 
-void ListInsertFront(List *list, Sprite *data){
-    Node *new = ListCreateNode(data);
+void ListInsertBefore(List *list, Node *new, Node *current){
+    new->next = current;
+    new->prev = current->prev;
+    current->prev = new;
 
-    if(list->head == 0){
+    if(current == list->head){
         list->head = new;
-        list->tail = new;
     }
-    else if(list->head == list->tail){
-        list->head = new;
-        list->head->next = list->tail;
-        list->tail->prev = list->head;
+    else{
+        new->prev->next = new;
+    }
+}
+
+void ListInsertAfter(List *list, Node *new, Node *current){
+    new->prev = current;
+    new->next = current->next;
+    current->next = new;
+
+    if(current == list->tail){
+        list->tail = new;
     }
     else{
-        list->head->prev = new;
-        new->next = list->head;
-        list->head = new;
+        new->next->prev = new;
     }
 }
 
-void ListInsertBack(List *list, Sprite *data){
+void ListInsert(List *list, Sprite *data){
     Node *new = ListCreateNode(data);
 
     if(list->head == 0){
-        list->head = new;
-        list->tail = new;
-    }
-    else if(list->head == list->tail){
-        list->tail = new;
-        list->head->next = list->tail;
-        list->tail->prev = list->head;
+       list->head = new;
+       list->tail = new;
     }
     else{
-        list->tail->next = new;
-        new->prev = list->tail;
-        list->tail = new;
+        Node *current = list->head;
+
+        while(current != 0){
+            if(new->data->depth < current->data->depth){
+                ListInsertBefore(list, new, current);
+                return;
+            }
+            current = current->next;
+        }
+
+        ListInsertAfter(list, new, list->tail);
     }
 }
 
+void ListSpriteChanged(List *list, Node *changed){
+    if(changed != list->tail && changed->data->depth > changed->next->data->depth){
+        //Nach rechts 
+
+        Node *current = changed->next;
+        ListRemove(list, changed);
+
+        while(current != 0){
+            if(changed->data->depth < current->data->depth){
+                ListInsertBefore(list, changed, current);
+                return;
+            }
+            current = current->next;
+        }
+
+        ListInsertAfter(list, changed, list->tail);
+    }
+    else if(changed != list->head && changed->data->depth < changed->prev->data->depth){
+        //Nach links
+
+        Node *current = changed->prev;
+        ListRemove(list, changed);
+
+        while(current != 0){
+            if(changed->data->depth > current->data->depth){
+                ListInsertAfter(list, changed, current);
+                return;
+            }
+            current = current->prev;
+        }
+
+        ListInsertBefore(list, changed, list->head);
+    }
+}
+
+void ListRemove(List *list, Node *remove){
+    if(remove == 0){
+        printf("WARNING: TRIED TO REMOVE NULLPOINTER\n");
+    }
+    else if(list->head == remove && list->tail == remove){
+        list->head = 0;
+        list->tail = 0;
+    }
+    else if(list->head == remove){
+        remove->next->prev = 0;
+        list->head = remove->next;
+    }
+    else if(list->tail == remove){
+        remove->prev->next = 0;
+        list->tail = remove->prev;
+    }
+    else{
+        remove->prev->next = remove->next;
+        remove->next->prev = remove->prev;
+    }
+
+    remove->next = 0;
+    remove->prev = 0;
+}
 
 List * ListInit(){
     List *newList = malloc(sizeof(List));
@@ -106,13 +175,15 @@ void ListDrawAllSprites(List *list, IsometricMap **map, Camera2D *camera){
 
 // iterates over all Sprites in the list and does their acting (moving etc)
 void ListActAllSprites(Game *game){
-
+    ListPrintForward(game->sprites);
     // Sprites move towards their destination
     float movementSpeed = 150.0f * GetFrameTime(); 
     Node *current = game->sprites->head;
 
     int counter = 0;
     while (current != 0){
+        current->data->depth = current->data->x + current->data->y + current->data->z;
+        ListSpriteChanged(game->sprites, current);
         counter ++;
         if(current->data->hasDestination == 1){
             Vector2 movement = {

List/list.h

@@ -25,8 +25,12 @@ Node * ListCreateNode(Sprite *data);
 
 //Print the list in order
 void ListPrintForward(List *list);
-void ListInsertFront(List *list, Sprite *data);
-void ListInsertBack(List *list, Sprite *data);
+
+void ListInsertBefore(List *list, Node *new, Node *current);
+void ListInsertAfter(List *list, Node *new, Node *current);
+void ListInsert(List *list, Sprite *data);
+void ListRemove(List *list, Node *remove);
+void ListSpriteChanged(List *list, Node *changed);
 List * ListInit();
 void ListDrawAllSprites(List *list, IsometricMap **map, Camera2D *camera);
 void ListActAllSprites(Game *game);

Makefile

@@ -34,7 +34,7 @@ animationHandler.o: Textures/animationHandler.c
 
 bucket.o: DepthSorting/bucket.c
 	$(CC) -c DepthSorting/bucket.c $(FLAGS)
-
+	
 button.o: Ui/button.c
 	$(CC) -c Ui/button.c $(FLAGS)
 

main.c

@@ -120,5 +120,4 @@ int main(){
 
     return 0;
 
-}
-
+}

sprite.c

@@ -64,12 +64,14 @@ Sprite * SpriteCreate(TextureAtlas *atlas, int textureID, int x, int y){
     newSprite->texture = newSprite->animationHandler->currentFrame->texture;
     newSprite->x = x - newSprite->texture->width / 2;
     newSprite->y = y - newSprite->texture->height / 2;
+    newSprite->z = 0;
     newSprite->destX = x;
     newSprite->destY = y;
     newSprite->hasDestination = 0;
     newSprite->selected = 0;
+    newSprite->depth = newSprite->x + newSprite->y;
 
-    newSprite->sortable = BucketInit(newSprite, 0);
+    newSprite->sortable = BucketInit(newSprite, SPRITE);
 
     return newSprite;
 }

sprite.h

@@ -16,6 +16,7 @@ typedef struct Sprite {
     float destY;
     int hasDestination;
     int selected;
+    float depth;
     Bucket *sortable;
 } Sprite;