Put linked list for separate object

include/header.h

@@ -1,5 +1,6 @@
 #include <raylib.h>
 #include <stdio.h>
+#include <stdlib.h> 
 
 // Global Constants
 #define BEZIER_POINTS 5
@@ -93,6 +94,12 @@ struct target_obj
     double radius;
     struct kinematic_obj kinematic;
 };
+struct target_obj_node
+{
+    struct target_obj *obj;
+    struct target_obj_node *next;
+};
+
 // Object functions, kinematics.c
 struct kinematic_obj init_kinematic_obj(int width, int height);
 void move(struct kinematic_obj *obj, Vector2 acceleration);
@@ -100,6 +107,9 @@ void set_position(struct kinematic_obj *obj, int x, int y);
 bool place_meeting(struct kinematic_obj *obj, Vector2 dir);
 void scale_rect(struct kinematic_obj *obj);
 void adjust_hitbox(struct kinematic_obj *obj);
+void add_kinematic_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD);
+//struct kinematic_obj_node **get_list();
+void free_kinematic_list(struct kinematic_obj_node **HEAD);
 
 // Math functions, math.c
 double mag(Vector2 vec);
@@ -110,12 +120,6 @@ Vector2 center(Rectangle rect);
 
 // Linked list, linked_list.c
 void create_list(void);
-void add_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD);
-//struct kinematic_obj_node **get_list();
-void free_list(struct kinematic_obj_node **HEAD);
-void create_afterimage(struct player_obj *player, Color color);
-void remove_last_afterimage(struct player_obj *player);
-void free_afterimages(struct player_obj *player);
 
 // Squishy Square functions, squishy.c
 struct squishy_square init_squishy_square(struct kinematic_obj *parent, Color color);
@@ -127,9 +131,15 @@ void draw_afterimages(struct player_obj *player);
 //Player stuff, player.c
 struct player_obj init_player_obj();
 void player_input_check(struct player_obj *player);
+void create_afterimage(struct player_obj *player, Color color);
+void remove_last_afterimage(struct player_obj *player);
+void free_afterimages(struct player_obj *player);
 
 //Target stuff, target.c
 struct target_obj init_target();
+void free_target_list(struct target_obj_node **HEAD);
+void add_target_node(struct target_obj *obj, struct target_obj_node **HEAD);
+bool collide_target(struct kinematic_obj *obj, struct target_obj *target);
 
 //Debug stuff, debug.c
 void state_string(char *str, enum PLAYER_STATE state);

main.c

@@ -24,7 +24,7 @@
 
 #include "header.h"
 struct kinematic_obj_node *kinematic_HEAD = NULL;
-struct kinematic_obj_node *target_HEAD = NULL;
+struct target_obj_node *target_HEAD = NULL;
 int PLAYER_ACCEL = 1500;
 int JUMP_ACCEL = 15000;
 int JUMP_SPD = 350;
@@ -72,23 +72,22 @@ int main()
     struct squishy_square sqr = init_squishy_square(&player.kinematic, RED);
     player.image = &sqr;
 
-    add_node(&tile, &kinematic_HEAD);
+    add_kinematic_node(&tile, &kinematic_HEAD);
-    add_node(&tile2, &kinematic_HEAD);
+    add_kinematic_node(&tile2, &kinematic_HEAD);
-    add_node(&tile3, &kinematic_HEAD);
+    add_kinematic_node(&tile3, &kinematic_HEAD);
-    add_node(&tile4, &kinematic_HEAD);
+    add_kinematic_node(&tile4, &kinematic_HEAD);
-    add_node(&tile5, &kinematic_HEAD);
+    add_kinematic_node(&tile5, &kinematic_HEAD);
-    add_node(&tile6, &kinematic_HEAD);
+    add_kinematic_node(&tile6, &kinematic_HEAD);
-    add_node(&tile7, &kinematic_HEAD);
+    add_kinematic_node(&tile7, &kinematic_HEAD);
-    add_node(&player.kinematic, &kinematic_HEAD);
+    add_kinematic_node(&player.kinematic, &kinematic_HEAD);
 
 
     struct target_obj target = init_target(50, 300);
     set_position(&target.kinematic, 150, 380);
-    add_node(&target.kinematic, &target_HEAD);
+    add_target_node(&target, &target_HEAD);
     
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    struct kinematic_obj_node *current;
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -107,17 +106,19 @@ int main()
             ClearBackground(RAYWHITE);
             draw_afterimages(&player);
             draw_squishy(&sqr);
-
+            struct kinematic_obj_node *current;
+            struct target_obj_node *target_current;
             BeginMode2D(camera);
                 current = kinematic_HEAD;
                 while(current){
                     DrawRectangleLinesEx(current->obj->rect, 1, BLACK);
                     current = current->next;
                 }
-                current = target_HEAD;
+                target_current = target_HEAD;
-                while(current){
+                while(target_current){
-                    DrawCircle(current->obj->pos.x, current->obj->pos.y, current->obj->ori_width, BLACK);
+                    DrawCircle(target_current->obj->kinematic.pos.x, target_current->obj->kinematic.pos.y, 
-                    current = current->next;
+                    target_current->obj->kinematic.ori_width, BLACK);
+                    target_current = target_current->next;
                 }
                 DrawFPS(0,0);
                 state_string(current_state, player.state);
@@ -135,8 +136,8 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    free_list(&kinematic_HEAD);
+    free_kinematic_list(&kinematic_HEAD);
-    free_list(&target_HEAD);
+    free_target_list(&target_HEAD);
     free_afterimages(&player);
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

obj/kinematics.c

@@ -109,3 +109,34 @@ void adjust_hitbox(struct kinematic_obj *obj){
     approach(&obj->dim_reduction[2], obj->set_dim_reduction[2], 0.2);
     approach(&obj->dim_reduction[3], obj->set_dim_reduction[3], 0.2);
 }
+
+// Placeholder collision checking structure. Use linked list for now
+// Need to implement some sort of tree structure for efficient collision checking
+
+void add_kinematic_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD){
+    struct kinematic_obj_node *node = malloc(sizeof(struct kinematic_obj_node));
+    if (node){
+        node->obj = obj;
+        node->next = NULL;
+    }
+    if (*HEAD != NULL)
+        node->next = *HEAD;
+    
+    *HEAD = node;
+}
+
+/**struct kinematic_obj_node **get_list(){
+    return &kinematic_HEAD;
+}*/
+
+void free_kinematic_list(struct kinematic_obj_node **HEAD){
+    struct kinematic_obj_node *current = *HEAD;
+    struct kinematic_obj_node *next;
+    while(current){
+        next = current->next;
+        current->next = NULL;
+        free(current);
+        current = next;
+    }
+    *HEAD = NULL;
+}

obj/player.c

@@ -321,4 +321,62 @@ void player_input_check(struct player_obj *player){
         player->image->color.b = 255;
     else
         player->image->color.b = 0;
-}
+}
+
+void create_afterimage(struct player_obj *player, Color color){
+    struct afterImage *img = malloc(sizeof(struct afterImage));
+    if (img){
+       for (int i=0;i<=BEZIER_POINTS;++i){
+            img->top_vertices[i] = player->image->top_vertices[i];
+            img->bottom_vertices[i] = player->image->bottom_vertices[i];
+            img->left_vertices[i] = player->image->left_vertices[i];
+            img->right_vertices[i] = player->image->right_vertices[i];
+        }
+        img->pos = (Vector2){player->image->center.x, player->image->center.y};
+        img->velocity = (Vector2){player->kinematic.velocity.x, player->kinematic.velocity.y};
+        img->opacity = 1.0;
+        img->color = color;
+        img->prev = NULL;
+        if (player->after_img_head == NULL){
+            img->next = NULL;
+            player->after_img_head = img;
+            player->after_img_tail = img;
+        }else{
+            img->next = player->after_img_head;
+            player->after_img_head->prev = img;
+            player->after_img_head = img;
+        } 
+    }
+}
+
+void remove_last_afterimage(struct player_obj *player){
+    struct afterImage *last;
+    if (player->after_img_tail != NULL){
+        if (player->after_img_tail->opacity <= 0){
+            last = player->after_img_tail;
+            player->after_img_tail = player->after_img_tail->prev;
+            last->prev = NULL;
+            free(last);
+        }
+        // This happens if the last tail is the head
+        if (player->after_img_tail == NULL){
+            player->after_img_head = NULL;
+        }else{
+            player->after_img_tail->next = NULL;
+        }
+    }
+}
+
+void free_afterimages(struct player_obj *player){
+    struct afterImage *current = player->after_img_head;
+    struct afterImage *next;
+    while(current != NULL){
+        next = current->next;
+        current->next = NULL;
+        current->prev = NULL;
+        free(current);
+        current = next;
+    }
+    player->after_img_head = NULL;
+    player->after_img_tail = NULL;
+}

obj/target.c

@@ -44,4 +44,28 @@ bool collide_target(struct kinematic_obj *obj, struct target_obj *target){
     if (!(max_proj < target_proj - target->radius) && !(min_proj > target_proj + target->radius))
         return true;
     return false;
+}
+
+void add_target_node(struct target_obj *obj, struct target_obj_node **HEAD){
+    struct target_obj_node *node = malloc(sizeof(struct target_obj_node));
+    if (node){
+        node->obj = obj;
+        node->next = NULL;
+    }
+    if (*HEAD != NULL)
+        node->next = *HEAD;
+    
+    *HEAD = node;
+}
+
+void free_target_list(struct target_obj_node **HEAD){
+    struct target_obj_node *current = *HEAD;
+    struct target_obj_node *next;
+    while(current){
+        next = current->next;
+        current->next = NULL;
+        free(current);
+        current = next;
+    }
+    *HEAD = NULL;
 }

utilities/linked_list.c

@@ -1,91 +0,0 @@
-#include "header.h"
-#include <stdlib.h> 
-
-// Placeholder collision checking structure. Use linked list for now
-// Need to implement some sort of tree structure for efficient collision checking
-
-void add_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD){
-    struct kinematic_obj_node *node = malloc(sizeof(struct kinematic_obj_node));
-    if (node){
-        node->obj = obj;
-        node->next = NULL;
-    }
-    if (*HEAD != NULL)
-        node->next = *HEAD;
-    
-    *HEAD = node;
-}
-
-/**struct kinematic_obj_node **get_list(){
-    return &kinematic_HEAD;
-}*/
-
-void free_list(struct kinematic_obj_node **HEAD){
-    struct kinematic_obj_node *current = *HEAD;
-    struct kinematic_obj_node *next;
-    while(current){
-        next = current->next;
-        current->next = NULL;
-        free(current);
-        current = next;
-    }
-    *HEAD = NULL;
-}
-
-void create_afterimage(struct player_obj *player, Color color){
-    struct afterImage *img = malloc(sizeof(struct afterImage));
-    if (img){
-       for (int i=0;i<=BEZIER_POINTS;++i){
-            img->top_vertices[i] = player->image->top_vertices[i];
-            img->bottom_vertices[i] = player->image->bottom_vertices[i];
-            img->left_vertices[i] = player->image->left_vertices[i];
-            img->right_vertices[i] = player->image->right_vertices[i];
-        }
-        img->pos = (Vector2){player->image->center.x, player->image->center.y};
-        img->velocity = (Vector2){player->kinematic.velocity.x, player->kinematic.velocity.y};
-        img->opacity = 1.0;
-        img->color = color;
-        img->prev = NULL;
-        if (player->after_img_head == NULL){
-            img->next = NULL;
-            player->after_img_head = img;
-            player->after_img_tail = img;
-        }else{
-            img->next = player->after_img_head;
-            player->after_img_head->prev = img;
-            player->after_img_head = img;
-        } 
-    }
-}
-
-void remove_last_afterimage(struct player_obj *player){
-    struct afterImage *last;
-    if (player->after_img_tail != NULL){
-        if (player->after_img_tail->opacity <= 0){
-            last = player->after_img_tail;
-            player->after_img_tail = player->after_img_tail->prev;
-            last->prev = NULL;
-            free(last);
-        }
-        // This happens if the last tail is the head
-        if (player->after_img_tail == NULL){
-            player->after_img_head = NULL;
-        }else{
-            player->after_img_tail->next = NULL;
-        }
-    }
-}
-
-void free_afterimages(struct player_obj *player){
-    struct afterImage *current = player->after_img_head;
-    struct afterImage *next;
-    while(current != NULL){
-        next = current->next;
-        current->next = NULL;
-        current->prev = NULL;
-        free(current);
-        current = next;
-    }
-    player->after_img_head = NULL;
-    player->after_img_tail = NULL;
-}