added spinning entities + fixed segFault on sort entities

src/display.c

@@ -339,8 +339,8 @@ int surfaceDrawOrder(double x0, double y0, double z0, cube_0 cb) {
     double zry = z*cos(cb.hz_angle) - x*sin(cb.hz_angle) ;
     // rotate (x)
     double xrx = xry ;
-    double yrx = yry*cos(cb.vt_angle) - zry*sin(cb.vt_angle) ;
+    double yrx = yry*cos(cb.vt_angle) + zry*sin(cb.vt_angle) ;
-    double zrx = zry*cos(cb.vt_angle) + yry*sin(cb.vt_angle) ;
+    double zrx = zry*cos(cb.vt_angle) - yry*sin(cb.vt_angle) ;
     // cube is centered and aligned
     int id = 0 ;
     if(xrx > cb.w/2.0) {
@@ -599,6 +599,12 @@ void swap_tp(teleporter* arr, int i, int j) {
     arr[j] = temp;
 }
 
+void swap_ent(entity* arr, int i, int j) {
+    entity temp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = temp;
+}
+
 void insertionSort_cb(cube_0* arr, int len) {
     for(int k = 0; k < len; k++) {
         int j = k-1 ;
@@ -627,12 +633,30 @@ void insertionSort_tp(teleporter* arr, int len) {
     }
 }
 
+void insertionSort_ent(entity* arr, int len) {
+    for(int k = 0; k < len; k++) {
+        int j = k-1 ;
+        while(j >= 0) {
+            if(distance_pt_cube_0_3d_weighted(camx, camy, camz, 1.0, 8.5, 1.0, *(arr[j].pos)) < distance_pt_cube_0_3d_weighted(camx, camy, camz, 1.0, 8.5, 1.0, *(arr[j+1].pos))) {
+                swap_ent(arr, j, j+1);
+                j -= 1;
+            } else {
+                j = -1;
+            }
+        }
+    }
+}
+
 void drawCurrentRoom(SDL_Renderer* renderer) {
     insertionSort_cb(current_room->map, current_room->map_size);
     insertionSort_tp(current_room->tps, current_room->tps_size);
+    insertionSort_ent(current_room->ents, current_room->ent_len);
     for(int k = 0; k < current_room->map_size; k++) {
         drawFullCube(renderer, current_room->map[k]);
     }
+    for(int k = 0; k < current_room->ent_len; k++) {
+        drawFullCube(renderer, *(current_room->ents[k].pos));
+    }
     for(int k = 0; k < current_room->tps_size; k++) {
         drawFullCube(renderer, current_room->tps[k].hitbox);
     }

src/entities.c

@@ -42,6 +42,21 @@ bool is_colliding_with_tp(cube_0 cb) {
 
 // ------------------------------------------------------------------------------------------------------------------------------------------------ //
 
-void update_entity(entity* ent) {
+void update_entity(entity* ent, float dtime) {
-    (*ent->updatePos)(ent->pos->x, ent->pos->y, ent->pos->z, ent->pos->w, ent->pos->h, ent->pos->d, ent->pos->hz_angle, ent->pos->vt_angle, ent->pos);
+    (*ent->updatePos)(ent->pos->x, ent->pos->y, ent->pos->z, ent->pos->w, ent->pos->h, ent->pos->d, ent->pos->hz_angle, ent->pos->vt_angle, dtime, ent->pos);
+}
+
+void update_entities(float dtime) {
+    for(int k = 0; k < current_room->ent_len; k++) {
+        if(current_room->ents[k].updatePos != NULL) {
+            //printf("e\n");
+            update_entity(&(current_room->ents[k]), dtime);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------------------------------------------------------ //
+
+void speen(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret) {
+    ret->vt_angle += ((double)dtime)*3.0;
 }

src/entities.h

@@ -1,5 +1,12 @@
 #ifndef ENTITIES_H
 #define ENTITIES_H
 
+bool is_colliding_with_map(cube_0 cb);
+bool is_colliding_with_tp(cube_0 cb);
+
+void update_entity(entity* ent, float dtime);
+void update_entities(float dtime);
+
+void speen(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret);
 
 #endif

src/generation.c

@@ -14,6 +14,7 @@
 #include "hash.h"
 #include "structure.h"
 #include "base.h"
+#include "entities.h"
 #include "generation.h"
 
 hashtbl visited ;
@@ -52,6 +53,19 @@ void copy_room(room* src, room* dest, int chx, int chy) {
         dest->tps[k].dest_y = src->tps[k].dest_y ;
         dest->tps[k].dest_z = src->tps[k].dest_z ;
     }
+    dest->ents = malloc(sizeof(entity)*src->ent_len);
+    dest->ent_len = src->ent_len ;
+    for(int k = 0; k < src->ent_len; k++) {
+        dest->ents[k].damage = src->ents[k].damage ;
+        dest->ents[k].hitpoints = src->ents[k].hitpoints ;
+        dest->ents[k].pos = malloc(sizeof(cube_0));
+        *(dest->ents[k].pos) = create_cube_0(
+            (*(src->ents[k].pos)).x, (*(src->ents[k].pos)).y, (*(src->ents[k].pos)).z,
+            (*(src->ents[k].pos)).w, (*(src->ents[k].pos)).h, (*(src->ents[k].pos)).d,
+            (*(src->ents[k].pos)).hz_angle, (*(src->ents[k].pos)).vt_angle, (*(src->ents[k].pos)).red, (*(src->ents[k].pos)).green, (*(src->ents[k].pos)).blue 
+        );
+        dest->ents[k].updatePos = *speen ;
+    }
     dest->tps_size = src->tps_size;
 }
 
@@ -78,6 +92,9 @@ void build_starting_chunk(int chx, int chy) {
     new->tps[2] = create_teleporter(5.0, 1.0, 2.0, 1.0, 2.0 + (double)(rand()%2), 1.0, 3.14159/4.0, 0.0, 0, 255, 0   , chx+1, chy  , 2.5, 2.5, 2.5);
     new->tps[3] = create_teleporter(2.0, 1.0, 5.0, 1.0, 2.0 + (double)(rand()%2), 1.0, 3.14159/4.0, 0.0, 0, 0, 255   , chx  , chy+1, 2.5, 2.5, 2.5);
 
+    new->ents = malloc(sizeof(entity)*0);
+    new->ent_len = 0 ;
+
     hashtbl_add(visited, chx, chy, new);
 }
 
@@ -90,23 +107,28 @@ void init_hashtbl() {
     total_weight = 0 ;
 }
 
-void get_number_blocks(int* ret_cubes, int* ret_tps, FILE* ptr) {
+void get_number_blocks(int* ret_cubes, int* ret_tps, int* ret_ent, FILE* ptr) {
     *ret_cubes = 0 ;
     *ret_tps = 0 ;
+    *ret_ent = 0 ;
 
-    bool in_blocks = true ;
+    int in_blocks = 0 ;
     char c = fgetc(ptr) ;
     while(c != EOF && c != '$') {
         //printf("%c", c);
         if(c == 'B') {
-            in_blocks = true ;
+            in_blocks = 0 ;
         } else if(c == 'T') {
-            in_blocks = false ;
+            in_blocks = 1 ;
+        } else if(c == 'E') {
+            in_blocks = 2 ;
         } else if(c == '[') {
-            if(in_blocks) {
+            if(in_blocks == 0) {
                 *ret_cubes += 1 ;
-            } else {
+            } else if(in_blocks == 1) {
                 *ret_tps += 1 ;
+            } else {
+                *ret_ent += 1;
             }
         }
         c = fgetc(ptr);
@@ -170,15 +192,18 @@ void parse_one_room(int id, char* filename) {
     pool[id].area = malloc(sizeof(room));
     int ncubes ;
     int ntps ;
+    int nent ;
 
     FILE* ptr2 = fopen(filename, "r") ;
-    get_number_blocks(&ncubes, &ntps, ptr2);
+    get_number_blocks(&ncubes, &ntps, &nent, ptr2);
-    //printf("(%d, %d)\n", ncubes, ntps);
+    printf("(%d, %d, %d)\n", ncubes, ntps, nent);
 
     pool[id].area->map = malloc(sizeof(cube_0)*ncubes);
     pool[id].area->map_size = ncubes;
     pool[id].area->tps = malloc(sizeof(teleporter)*ntps);
     pool[id].area->tps_size = ntps;
+    pool[id].area->ents = malloc(sizeof(entity)*nent);
+    pool[id].area->ent_len = nent ;
 
     for(int k = 0; k < ncubes; k++) {
         align_to(ptr, '[');
@@ -216,6 +241,30 @@ void parse_one_room(int id, char* filename) {
         //printf("\n");
     }
 
+    for(int k = 0; k < nent; k++) {
+        align_to(ptr, '[');
+        double cx = read_float(ptr);
+        double cy = read_float(ptr);
+        double cz = read_float(ptr);
+        double cw = read_float(ptr);
+        double ch = read_float(ptr);
+        double cd = read_float(ptr);
+        double chz = read_float(ptr);
+        double cvt = read_float(ptr);
+        int red = read_int(ptr, true);
+        int green = read_int(ptr, true);
+        int blue = read_int(ptr, true);
+        int hp = read_int(ptr, true);
+        int dmg = read_int(ptr, true);
+        pool[id].area->ents[k].pos = malloc(sizeof(cube_0));
+        *(pool[id].area->ents[k].pos) = create_cube_0(cx, cy, cz, cw, ch, cd, chz, cvt, red, green, blue);
+        pool[id].area->ents[k].damage = dmg ;
+        pool[id].area->ents[k].hitpoints = malloc(sizeof(int));
+        *(pool[id].area->ents[k].hitpoints) = hp ;
+        pool[id].area->ents[k].updatePos = *speen ;
+        //printf("\n");
+    }
+
     // debug
     for(int k = 0; k < ncubes; k++) {
         printf("(%lf, %lf, %lf), (%lf, %lf, %lf), (%lf, %lf), (%d, %d, %d)\n", 

src/generation.h

@@ -11,7 +11,7 @@ void build_starting_chunk(int chx, int chy) ;
 
 void init_hashtbl() ;
 
-void get_number_blocks(int* ret_cubes, int* ret_tps, FILE* ptr) ;
+void get_number_blocks(int* ret_cubes, int* ret_tps, int* ret_ent, FILE* ptr) ;
 void align_to(FILE* ptr, char ch) ;
 int read_int(FILE* ptr, bool print) ;
 double read_float(FILE* ptr) ;

src/main.c

@@ -60,6 +60,9 @@ int main(int argc, char** argv) {
     sim_time = 0.0 ;
     clock_t origin = clock();
     clock_t finish = clock();
+
+    clock_t entstart = clock();
+    clock_t entend = clock();
     float delta;
     while(true) {
         resetRenderer(rend) ;
@@ -68,6 +71,11 @@ int main(int argc, char** argv) {
         SDL_SetRenderDrawColor(rend, 255, 255, 255, SDL_ALPHA_OPAQUE) ;
         playerActions() ;
         generate_nearby_chunks(1);
+
+        entend = clock();
+        update_entities(((float)entend - (float)entstart)/CLOCKS_PER_SEC);
+        entstart = clock();
+
         drawCurrentRoom(rend);
         drawData(rend) ;
         finish = clock();

src/move.c

@@ -20,7 +20,7 @@
 double sensitivity = 0.22 ;
 double fov = 90.0 ;
 double speed = 1.0 ;
-double min_dist = 0.5 ;
+double min_dist = 0.7 ;
 // ---------------------------------------------------------------------------------------------------- //
 
 double camx ;

src/structure.h

@@ -31,9 +31,9 @@ typedef struct teleporter {
 
 typedef struct entity {
     cube_0* pos ;
-    void (*updatePos)(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, cube_0* ret) ;    // act as velocity function
+    void (*updatePos)(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret) ;    // act as velocity function
     int damage ;
-    int hitpoints ;
+    int* hitpoints ;
 } entity ;
 
 struct room {
@@ -44,6 +44,8 @@ struct room {
     int map_size ;
     teleporter* tps ;
     int tps_size ;
+    entity* ents ;
+    int ent_len ;
 } ;
 typedef struct room room ;
 

templates/room_2

@@ -13,7 +13,13 @@ Teleporters :
 [9.0, 1.0, -5.0, 1.0, 2.0, 10.0, 0.0, 0.0, 0, 255, 0; 0, 1]
 [-5.0, 1.0, 9.0, 10.0, 2.0, 1.0, 0.0, 0.0, 0, 0, 255; 1, 0]
 
+Entities :
+[3.0, 3.0, 3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 255, 255, 0, 900, 20]
+[-3.0, 3.0, 3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 255, 255, 0, 900, 20]
+[3.0, 3.0, -3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 255, 255, 0, 900, 20]
+[-3.0, 3.0, -3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 255, 255, 0, 900, 20]
+
 Weight :
-30
+20
 
 $