.vscode/settings.json

@@ -11,9 +11,6 @@
         "sdl.h": "c",
         "triangles.h": "c",
         "base.h": "c",
-        "move.h": "c",
-        "hash.h": "c",
-        "proj.h": "c",
-        "entities.h": "c"
+        "move.h": "c"
     }
 }

Makefile

@@ -7,7 +7,7 @@ all: bin/back
 test: bin/back
 	bin/back
 
-bin/back: obj/main.o obj/generation.o obj/display.o obj/proj.o obj/entities.o obj/bullets.o obj/menus.o obj/triangles.o obj/move.o obj/base.o obj/hash.o
+bin/back: obj/main.o obj/generation.o obj/display.o obj/entities.o obj/bullets.o obj/menus.o obj/triangles.o obj/move.o obj/base.o obj/hash.o
 	mkdir -p bin
 	$(CC) $(FLAGS) $^ $(LFLAGS) -o $@
 
@@ -23,7 +23,6 @@ obj/triangles.o: src/triangles.c
 obj/bullets.o: src/bullets.c
 obj/move.o: src/move.c
 obj/base.o: src/base.c
-obj/proj.o: src/proj.c
 obj/menus.o: src/menus.c
 obj/hash.o: src/hash.c
 

src/display.c

@@ -16,7 +16,6 @@
 #include "base.h"
 #include "triangles.h"
 #include "move.h"
-#include "proj.h"
 #include "entities.h"
 #include "generation.h"
 #include "display.h"
@@ -664,10 +663,8 @@ void addTriangleRotated(
     rotate_cube(x0, y0, z0, &px0, &py0, &pz0, cb);
     rotate_cube(x1, y1, z1, &px1, &py1, &pz1, cb);
     rotate_cube(x2, y2, z2, &px2, &py2, &pz2, cb);
-    if(triangles_i < MAX_SIZE -1) {
     addTriangle(px0, py0, pz0, px1, py1, pz1, px2, py2, pz2, red, green, blue);
 }
-}
 
 // -------------------------------------------------------------------------------------------------------------------------------- //
 
@@ -804,13 +801,20 @@ void drawCurrentRoom(SDL_Renderer* renderer) {
     add_triangles_cb(current_room->map, current_room->map_size);
     add_triangles_tp(current_room->tps, current_room->tps_size);
     add_triangles_ent(current_room->ents, current_room->ent_len);
-    drawProj();
     topological_sort();
     //remove_hidden(renderer);
     //topological_sort();
     for(int k = 0; k < triangles_i; k++) {
         renderTriangleFull(renderer, triangles_order[k]);
     }
+    /*for(int k = 0; k < triangles_i; k++) {
+        drawNumberToRenderer(renderer, digits, 
+            (int)(3.3*(proj_pt_distance_to_camera(triangles_og_coords[k][0])+proj_pt_distance_to_camera(triangles_og_coords[k][1])+proj_pt_distance_to_camera(triangles_og_coords[k][2]))),
+            (int)(0.33*(triangles_to_render[k][0].x+triangles_to_render[k][1].x+triangles_to_render[k][2].x)),
+            (int)(0.33*(triangles_to_render[k][0].y+triangles_to_render[k][1].y+triangles_to_render[k][2].y)),
+            75/4, 105/4, 0
+        );
+    }*/
     for(int k = 0; k < 0*triangles_i; k++) {
         for(int l = 0; l < 3; l++) {
             drawNumberToRenderer(renderer, digits, 

src/display.h

@@ -29,13 +29,6 @@ double square_z_distance_to_camera(
     double x2, double y2, double z2
 );
 
-void addTriangle(
-    double x0, double y0, double z0,
-    double x1, double y1, double z1,
-    double x2, double y2, double z2,
-    int red, int green, int blue
-);
-
 void axialRotation_X0(double* y, double* z, double theta);
 void axialRotation_X(double* y, double* z, double theta, double cst_y, double cst_z);
 void axialRotation_Y0(double* x, double* z, double theta);

src/entities.c

@@ -14,8 +14,6 @@
 #include "hash.h"
 #include "structure.h"
 #include "base.h"
-#include "display.h"
-#include "proj.h"
 #include "entities.h"
 
 // ------------------------------------------------------------------------------------------------------------------------------------------------ //
@@ -60,28 +58,11 @@ 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) {
-    ret->hz_angle += ((double)dtime)*15.0;
+    ret->vt_angle += ((double)dtime)*15.0;
 }
 
 void speen2(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret) {
-    ret->hz_angle += ((double)dtime)*22.5;
-    if((int)(10.0*ret->hz_angle) != (int)(10.0*(ret->hz_angle - ((double)dtime)*22.5))) {
-        double dx = (x+w/2 - camx);
-        double dy = (y+h/2 - camy);
-        double dz = (z+d/2 - camz);
-        double total = sqrt(dx*dx + dy*dy + dz*dz) ;
-        dx = 170.0*dx/total;
-        dy = 170.0*dy/total;
-        dz = 170.0*dz/total;
-        appendProj(x+w/2, y+h/2, z+d/2, -dx, -dy, -dz, 0.0, 0.0, 0.0, 192, 32, 192, 10, 2.0);
-    }
-}
-
-void speen3(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)*22.5;
-    if((int)(ret->vt_angle) != (int)(ret->vt_angle - ((double)dtime)*22.5)) {
-        appendProj(x+w/2, y+h/2, z+d/2, 10.0 + rand()%15, 10.0 + rand()%15, 0.0, 0.0, 0.0, 0.0, 32, 32, 255, 1, 5.0);
-    }
+    ret->hz_angle += ((double)dtime)*15.0;
 }
 
 void detectHit(float dtime, int* hp, int* dmg, cube_0* ret) {
@@ -103,23 +84,20 @@ void go_to_player(double x, double y, double z, double w, double h, double d, do
     double dy = (y+h/2 - camy);
     double dz = (z+d/2 - camz);
     double total = sqrt(dx*dx + dy*dy + dz*dz) ;
-    dx = 110.0*dx/total;
-    dy = 110.0*dy/total;
-    dz = 110.0*dz/total;
-    ret->x -= dtime*dx ;
+    dx = 7.0*dx/total;
+    dy = 7.0*dy/total;
+    dz = 7.0*dz/total;
+    ret->x -=12.0*dtime*dx ;
     if(is_colliding_with_map(*ret) || is_colliding_with_tp(*ret)) {
-        ret->x += dtime*dx ;
+        ret->x +=12.0*dtime*dx ;
     }
-    ret->y -= dtime*dy ;
+    ret->y -=12.0*dtime*dy ;
     if(is_colliding_with_map(*ret) || is_colliding_with_tp(*ret)) {
-        ret->y += dtime*dy ;
+        ret->y +=12.0*dtime*dy ;
     }
-    ret->z -= dtime*dz ;
+    ret->z -=12.0*dtime*dz ;
     if(is_colliding_with_map(*ret) || is_colliding_with_tp(*ret)) {
-        ret->z += dtime*dz ;
-    }
-    if((int)(ret->x+ret->y+ret->z) != (int)(ret->x+ret->y+ret->z-dx-dy-dz)) {
-        
+        ret->z +=12.0*dtime*dz ;
     }
 }
 

src/entities.h

@@ -9,7 +9,6 @@ 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);
 void speen2(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret);
-void speen3(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret);
 
 void go_to_player(double x, double y, double z, double w, double h, double d, double hz_angle, double vt_angle, float dtime, cube_0* ret);
 

src/generation.c

@@ -41,7 +41,7 @@ void init_ent_generator(int n) {
 
     hashtbl_entities[0].id = 0;
     hashtbl_entities[0].name = "Coin";      // 0 = default
-    hashtbl_entities[0].updatePos = &speen ;
+    hashtbl_entities[0].updatePos = &speen2 ;
     hashtbl_entities[0].onHit = &detectHit ;
     hashtbl_entities[0].onDeath = NULL ;
 
@@ -56,12 +56,6 @@ void init_ent_generator(int n) {
     hashtbl_entities[2].updatePos = &go_to_player ;
     hashtbl_entities[2].onHit = &explodeOnHit ;
     hashtbl_entities[2].onDeath = NULL ;
-
-    hashtbl_entities[3].id = 3;
-    hashtbl_entities[3].name = "ExplosiveShoot";
-    hashtbl_entities[3].updatePos = &speen3 ;
-    hashtbl_entities[3].onHit = &explodeOnHit ;
-    hashtbl_entities[3].onDeath = NULL ;
 }
 
 fct_entry* get_entry(int k0) {

src/main.c

@@ -16,7 +16,6 @@
 #include "base.h"
 #include "move.h"
 #include "triangles.h"
-#include "proj.h"
 #include "entities.h"
 #include "display.h"
 #include "generation.h"
@@ -64,7 +63,6 @@ int main(int argc, char** argv) {
     init_draworder();
     init_ent_generator(10);
     trInit();
-    init_proj();
     parse_rooms(5);
     import_digits(rend) ;
     import_letters(rend) ;
@@ -83,56 +81,49 @@ int main(int argc, char** argv) {
         entend = clock();
         //printf("00\n");
         //printf("%s\n", SDL_GetError());
-        //fflush(stdout);
+        fflush(stdout);
         playerActions(((float)entend - (float)entstart)/CLOCKS_PER_SEC) ;
         //printf("01\n");
-        //fflush(stdout);
+        fflush(stdout);
         generate_nearby_chunks(1);
         //printf("02\n");
-        //fflush(stdout);
+        fflush(stdout);
 
         entend = clock();
         update_entities(((float)entend - (float)entstart)/CLOCKS_PER_SEC);
-        updateAllProj(((float)entend - (float)entstart)/CLOCKS_PER_SEC);
         //printf("03\n");
-        //fflush(stdout);
+        fflush(stdout);
         entstart = clock();
 
-        //printf("-->%d\n", triangles_i);
         drawCurrentRoom(rend);
-        //printf("-->%d\n", triangles_i);
-        //printf("-->%d\n", triangles_i);
         //printf("04\n");
         //printf("%s\n", SDL_GetError());
-        //fflush(stdout);
+        fflush(stdout);
         drawData(rend) ;
         //printf("05\n");
-        //fflush(stdout);
+        fflush(stdout);
         drawHPbar(rend);
         //printf("06\n");
-        //fflush(stdout);
+        fflush(stdout);
         finish = clock();
         fade_dmg = max(fade_dmg-5, 0);
         delta = ((float)finish - (float)origin)/CLOCKS_PER_SEC;
         //printf("07\n");
-        //fflush(stdout);
+        fflush(stdout);
         drawNumberToRenderer(rend, digits, (int)(1.0f/delta), 720, 60, 75/2, 105/2, 0);
         drawNumberToRenderer(rend, digits, (int)(10*sim_time), 720, 110, 75/2, 105/2, 0);
         drawNumberToRenderer(rend, digits, coins, 1500/2-55, 1000 - 70, 75/3, 105/3, 0);
         //printf("08\n");
-        //fflush(stdout);
+        fflush(stdout);
         //printf("%s\n", SDL_GetError());
         updateRenderer(rend) ;
         sim_time += delta + intervalf ;
         //printf("09\n");
-        //fflush(stdout);
-        if(player_hp <= 0) {
-            stop_evetything = true ;
-        }
+        fflush(stdout);
         usleep(interval) ;
     }
     //printf("GPNE\n");
-    //fflush(stdout);
+    fflush(stdout);
     free_digits(digits) ;
 
     for(int k = 0; k < MAX_SIZE; k++) {
@@ -147,9 +138,8 @@ int main(int argc, char** argv) {
     free(blues);
     free(triangles_order);
     free(visited_tri);
-    free_proj();
     //printf("10\n");
-    //fflush(stdout);
+    fflush(stdout);
     hashtbl_free(visited);
     free_pool();
 
@@ -157,17 +147,17 @@ int main(int argc, char** argv) {
 
     SDL_DestroyRenderer(rend);
     //printf("10\n");
-    //fflush(stdout);
+    fflush(stdout);
     SDL_DestroyWindow(win);
     //printf("11\n");
-    //fflush(stdout);
+    fflush(stdout);
     SDL_Quit();
     //printf("12\n");
-    //fflush(stdout);
+    fflush(stdout);
 
     /* -------------------------------------------------------- */
 
     //printf("Done\n") ;
-    //fflush(stdout);
+    fflush(stdout);
     return 0;
 }

src/move.c

@@ -15,7 +15,6 @@
 #include "structure.h"
 #include "base.h"
 #include "entities.h"
-#include "proj.h"
 #include "move.h"
 
 // ---------------------------------------------------------------------------------------------------- //
@@ -85,7 +84,6 @@ bool is_colliding(float dtime) {
             player_chy = current_room->tps[k].dest_chy ;
             current_room = hashtbl_find_opt(visited, player_chx, player_chy);
             set_player_coords(old_chx, old_chy);
-            resetProj();
             return true ;
         }
     }
@@ -184,10 +182,13 @@ void playerActions(float dtime) {
 
     if(state[SDL_SCANCODE_SPACE] == 1) {
         stop_evetything = true ;
+    } else {
+        pass = true ;
     }
 
     if(state[SDL_SCANCODE_T] == 1) {
-        stop_evetything = true ;
+        fprintf(stderr, "Killed.\n") ;
+        exit(1) ;
     }
 
     if(state[SDL_SCANCODE_A] == 1) {

src/proj.c

@@ -1,180 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <math.h>
-#include <stdbool.h>
-#include <ncurses.h>
-#include <unistd.h>
-#include <termios.h>
-#include <limits.h>
-#include <time.h>
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_image.h>
-
-#include "structure.h"
-#include "hash.h"
-#include "base.h"
-#include "move.h"
-#include "entities.h"
-#include "proj.h"
-
-projectile** bullets ;
-int bullets_id ;
-
-double psize = 1.5;
-
-pt_2d build_pt(double x, double y, double z) {
-    pt_2d res;
-    res.x = x ;
-    res.y = y ;
-    res.z = z ;
-    return res;
-}
-
-void init_proj() {
-    bullets = malloc(sizeof(projectile*)*MAX_SIZE);
-    for(int k = 0; k < MAX_SIZE; k++) {
-        bullets[k] = malloc(sizeof(projectile));
-        bullets[k]->pos = build_pt(0.0, 0.0, 0.0);
-        bullets[k]->vel = build_pt(0.0, 0.0, 0.0);
-        bullets[k]->acc = build_pt(0.0, 0.0, 0.0);
-        bullets[k]->size = 1.0;
-        bullets[k]->ttl = 1.0;
-        bullets[k]->red = 0;
-        bullets[k]->green = 0;
-        bullets[k]->blue = 0;
-        bullets[k]->damage = 0;
-    }
-    bullets_id = 0;
-}
-
-bool is_proj_colliding_with_map(double x, double y, double z, double size) {
-    for(int k = 0; k < current_room->map_size; k++) {
-        if(distance_pt_cube_0_3d(x+size/2, y+size/2, z+size/2, current_room->map[k]) <= size/2) {
-            return true ;
-        }
-    }
-    return false ;
-}
-
-bool is_proj_colliding_with_tp(double x, double y, double z, double size) {
-    for(int k = 0; k < current_room->tps_size; k++) {
-        for(int d = 0; d < 8; d++) {
-            if(distance_pt_cube_0_3d(x+size/2, y+size/2, z+size/2, current_room->tps[k].hitbox) <= size/2) {
-                return true ;
-            }
-        }
-    }
-    return false ;
-}
-
-bool is_proj_colliding_w_player(double x, double y, double z, double size) {
-    return (distance_pt_pt_3d(x, y, z, camx, camy, camz) <= size);
-}
-
-double ppx, ppy, ppz;
-double projx, projy;
-void addProjectileToDraw(projectile* proj) {
-    if(triangles_i < MAX_SIZE-1) {
-        project_to_camera(proj->pos.x, proj->pos.y, proj->pos.z, &ppx, &ppy, &ppz);
-        if(ppz >= draw_constant) {
-            projx = 1500.0 * (1.0 + (ppx / (1.5 * ppz * tan_fov))) / 2.0;
-            projy = 1000.0 * (1.0 + (ppy / (ppz * tan_fov))) / 2.0;
-            double rpsize = (40.0*psize/maxd(0.07, ppz));
-            //printf("%lf\n", rpsize);
-            triangles_to_render[triangles_i][0] = build_pt(projx-rpsize/2, projy-rpsize/2, 0.0);
-            triangles_to_render[triangles_i][1] = build_pt(projx-rpsize/2, projy+rpsize/2, 0.0);
-            triangles_to_render[triangles_i][2] = build_pt(projx+rpsize/2, projy+rpsize/2, 0.0);
-            triangles_og_coords[triangles_i][0] = build_pt(ppx, ppy, ppz);
-            triangles_og_coords[triangles_i][1] = build_pt(ppx, ppy, ppz);
-            triangles_og_coords[triangles_i][2] = build_pt(ppx, ppy, ppz);
-            reds[triangles_i] = proj->red;
-            greens[triangles_i] = proj->green;
-            blues[triangles_i] = proj->blue;
-            triangles_i += 1;
-
-            triangles_to_render[triangles_i][0] = build_pt(projx-rpsize/2, projy-rpsize/2, 0.0);
-            triangles_to_render[triangles_i][1] = build_pt(projx+rpsize/2, projy-rpsize/2, 0.0);
-            triangles_to_render[triangles_i][2] = build_pt(projx+rpsize/2, projy+rpsize/2, 0.0);
-            triangles_og_coords[triangles_i][0] = build_pt(ppx, ppy, ppz);
-            triangles_og_coords[triangles_i][1] = build_pt(ppx, ppy, ppz);
-            triangles_og_coords[triangles_i][2] = build_pt(ppx, ppy, ppz);
-            reds[triangles_i] = proj->red;
-            greens[triangles_i] = proj->green;
-            blues[triangles_i] = proj->blue;
-            triangles_i += 1;
-        }
-    }
-}
-
-void drawProj() {
-    for(int k = 0; k < bullets_id; k++) {
-        addProjectileToDraw(bullets[k]);
-    }
-}
-
-void appendProj(double x, double y, double z, double vx, double vy, double vz, double ax, double ay, double az, int r, int g, int b, int dmg, double ttl) {
-    if(bullets_id < MAX_SIZE) {
-        bullets[bullets_id]->red = r ;
-        bullets[bullets_id]->green = g ;
-        bullets[bullets_id]->blue = b ;
-        bullets[bullets_id]->size = 1.0 ;
-        bullets[bullets_id]->damage = dmg ;
-        bullets[bullets_id]->ttl = ttl ;
-        bullets[bullets_id]->pos = build_pt(x, y, z) ;
-        bullets[bullets_id]->vel = build_pt(vx, vy, vz) ;
-        bullets[bullets_id]->acc = build_pt(ax, ay, az) ;
-        bullets_id += 1;
-    }
-}
-
-void removeProj(int k) {
-    bullets[k]->red = bullets[bullets_id]->red;
-    bullets[k]->green = bullets[bullets_id]->green;
-    bullets[k]->blue = bullets[bullets_id]->blue;
-    bullets[k]->size = bullets[bullets_id]->size;
-    bullets[k]->pos = bullets[bullets_id]->pos;
-    bullets[k]->vel = bullets[bullets_id]->vel;
-    bullets[k]->acc = bullets[bullets_id]->acc;
-    bullets[k]->ttl = bullets[bullets_id]->ttl;
-    bullets[k]->damage = bullets[bullets_id]->damage;
-    bullets_id -= 1;
-}
-
-void updateAllProj(float dtime) {
-    for(int k = 0; k < bullets_id; k++) {
-        bullets[k]->vel.x += ((double)dtime)*(bullets[k]->acc.x);
-        bullets[k]->vel.y += ((double)dtime)*(bullets[k]->acc.y);
-        bullets[k]->vel.z += ((double)dtime)*(bullets[k]->acc.z);
-        bullets[k]->pos.x += ((double)dtime)*(bullets[k]->vel.x);
-        bullets[k]->pos.y += ((double)dtime)*(bullets[k]->vel.y);
-        bullets[k]->pos.z += ((double)dtime)*(bullets[k]->vel.z);
-        bullets[k]->ttl -= 20.0*(double)dtime;
-        //if(k==0) printf("[%d] %lf\n", k, bullets[k]->ttl);
-        if(is_proj_colliding_w_player(bullets[k]->pos.x - bullets[k]->size/2.0, bullets[k]->pos.y - bullets[k]->size/2.0, bullets[k]->pos.z - bullets[k]->size/2.0, bullets[k]->size)) {
-            if(bullets[k]->damage != 0) {
-                player_hp -= bullets[k]->damage ;
-                fade_dmg = 255 ;
-            }
-            removeProj(k);
-            k -= 1;
-        } else if(bullets[k]->ttl <= 0.0 || (
-            is_proj_colliding_with_map(bullets[k]->pos.x - bullets[k]->size/2.0, bullets[k]->pos.y - bullets[k]->size/2.0, bullets[k]->pos.z - bullets[k]->size/2.0, bullets[k]->size) ||
-            is_proj_colliding_with_tp(bullets[k]->pos.x - bullets[k]->size/2.0, bullets[k]->pos.y - bullets[k]->size/2.0, bullets[k]->pos.z - bullets[k]->size/2.0, bullets[k]->size)
-        )) {
-            removeProj(k);
-            k -= 1;
-        }
-    }
-}
-
-void resetProj() {
-    bullets_id = 0;
-}
-
-void free_proj() {
-    for(int k = 0; k < MAX_SIZE; k++) {
-        free(bullets[k]);
-    }
-    free(bullets);
-}

src/proj.h

@@ -1,26 +0,0 @@
-#ifndef PROJ_H
-#define PROJ_H
-
-typedef struct projectile {
-    pt_2d pos ;
-    pt_2d vel ;
-    pt_2d acc ;
-    double size;
-    double ttl;
-    int red;
-    int green;
-    int blue;
-    int damage;
-} projectile ;
-
-void init_proj();
-void free_proj();
-
-void drawProj();
-void appendProj(double x, double y, double z, double vx, double vy, double vz, double ax, double ay, double az, int r, int g, int b, int dmg, double ttl);
-void removeProj(int k);
-void updateAllProj(float dtime);
-
-void resetProj();
-
-#endif

src/triangles.c

@@ -318,6 +318,17 @@ bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og
         return false;
     }
     get_barycentric(p, tri, &u, &v, &w);
+    /*if(renderer != NULL && (u >= 0.0) && (v >= 0.0) && (w >= 0.0) && (u+v+w <= 1.0)) {
+        if(mid.z >= 0.4) {
+            SDL_Rect r;
+            r.x = (int)(1500.0 * (1.0 + (mid.x / (1.5 * mid.z * tan_fov))) / 2.0) -2;
+            r.y = (int)(1000.0 * (1.0 + (mid.y / (mid.z * tan_fov))) / 2.0) -2;
+            r.w = 4 ;
+            r.h = 4 ;
+            SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+            SDL_RenderFillRect(renderer, &r);
+        }
+    }*/
     if(((u >= 0.0) && (v >= 0.0) && (w >= 0.0) && (u+v+w <= 1.0)) && nonzero(u, v, w, 0.0001)) {
         pt_2d mid = convex_pt2d_tri(og[0], u, og[1], v, og[2], w);
         dist = proj_pt_distance_to_camera(mid) - proj_pt_distance_to_camera(ogp);
@@ -330,19 +341,6 @@ bool is_hidden(SDL_Renderer* renderer, pt_2d p, pt_2d ogp, pt_2d* tri, pt_2d* og
 }
 
 bool is_in_front(pt_2d* tri1, pt_2d* og1, pt_2d* tri2, pt_2d* og2) {
-    for(int k1 = 0; k1 < 3; k1++) {
-        for(int k2 = 0; k2 < 3; k2++) {
-            if(seg_seg_inter(tri1[k1], tri1[(k1+1)%3], tri2[k2], tri2[(k2+1)%3], &th1, &th2)) {
-                pt_2d mid1 = convex_pt2d(tri1[k1], tri1[(k1+1)%3], th1);
-                pt_2d mid2 = convex_pt2d(tri2[k2], tri2[(k2+1)%3], th2);
-                dist = proj_pt_distance_to_camera(mid1) - proj_pt_distance_to_camera(mid2);
-                if(absf(dist) >= 0.0001) {
-                    //return (proj_pt_distance_to_camera(mid1) <= proj_pt_distance_to_camera(mid2));
-                    return (dist <= 0.0);
-                }
-            }
-        }
-    }
     for(int k = 0; k < 3; k++) {
         pt_2d p = tri1[k];
         if(pt_equal(p, tri2[0], 0.0001) || pt_equal(p, tri2[1], 0.0001) || pt_equal(p, tri2[2], 0.0001)) {
@@ -373,5 +371,18 @@ bool is_in_front(pt_2d* tri1, pt_2d* og1, pt_2d* tri2, pt_2d* og2) {
             }
         }
     }
+    for(int k1 = 0; k1 < 3; k1++) {
+        for(int k2 = 0; k2 < 3; k2++) {
+            if(seg_seg_inter(tri1[k1], tri1[(k1+1)%3], tri2[k2], tri2[(k2+1)%3], &th1, &th2)) {
+                pt_2d mid1 = convex_pt2d(tri1[k1], tri1[(k1+1)%3], th1);
+                pt_2d mid2 = convex_pt2d(tri2[k2], tri2[(k2+1)%3], th2);
+                dist = proj_pt_distance_to_camera(mid1) - proj_pt_distance_to_camera(mid2);
+                if(absf(dist) >= 0.0001) {
+                    //return (proj_pt_distance_to_camera(mid1) <= proj_pt_distance_to_camera(mid2));
+                    return (dist <= 0.0);
+                }
+            }
+        }
+    }
     return false;
 }

templates/room_2

@@ -14,12 +14,12 @@ Teleporters :
 [-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, 192, 0, 1, 0, 3]
+[3.0, 3.0, 3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 193, 192, 0, 1, 0, 0]
 [-3.0, 3.0, 3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 193, 192, 0, 1, 0, 0]
 [3.0, 3.0, -3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 193, 192, 0, 1, 0, 0]
-[-3.0, 3.0, -3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 255, 192, 0, 1, 0, 3]
+[-3.0, 3.0, -3.0, 0.5, 0.5, 0.5, 0.0, 0.0, 193, 192, 0, 1, 0, 0]
 
 Weight :
-50
+20
 
 $

templates/room_4

@@ -13,6 +13,6 @@ Entities :
 [0.0, 40.0, 0.0, 0.5, 0.5, 0.5, 0.0, 0.0, 255, 64, 0, 5, 100, 2]
 
 Weight :
-500
+100
 
 $