#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <unistd.h>
#include <termios.h>
#include <limits.h>
#include <time.h>
#include <string.h>

#include "hash.h"
#include "base.h"
#include "entities.h"
#include "generation.h"

hashtbl visited;
room* current_room;

int player_chx;
int player_chy;

entry* pool;
int pool_size;
int total_weight;

int coins;
int fct_entry_size;

static char** to_free;
static int to_length;

fct_entry* hashtbl_entities;

void init_ent_generator(int n) {
    //!\\ size = 30 now
    hashtbl_entities = malloc(sizeof(fct_entry)*n);
    fct_entry_size = n;
    for(int k = 0; k < 10; k++) {
        hashtbl_entities[k].id = (-1);
    }

    hashtbl_entities[0].id = 0;
    hashtbl_entities[0].tex = 0;
    hashtbl_entities[0].name = "Coin";      // 0 = default
    hashtbl_entities[0].updatePos = &speen;
    hashtbl_entities[0].onHit = &money;
    hashtbl_entities[0].onDeath = NULL;

    hashtbl_entities[1].id = 1;
    hashtbl_entities[1].tex = 0;
    hashtbl_entities[1].name = "ExplosiveStill";
    hashtbl_entities[1].updatePos = &speen2;
    hashtbl_entities[1].onHit = &explodeOnHit;
    hashtbl_entities[1].onDeath = NULL;

    hashtbl_entities[2].id = 2;
    hashtbl_entities[2].tex = 0;
    hashtbl_entities[2].name = "ExplosiveSeek";
    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].tex = 0;
    hashtbl_entities[3].name = "ExplosiveShoot";
    hashtbl_entities[3].updatePos = &speen3;
    hashtbl_entities[3].onHit = &explodeOnHit;
    hashtbl_entities[3].onDeath = NULL;

    hashtbl_entities[4].id = 4;
    hashtbl_entities[4].tex = 0;
    hashtbl_entities[4].name = "SinePlatform";
    hashtbl_entities[4].updatePos = &moving_xyz;
    hashtbl_entities[4].onHit = &translatePlayer;
    hashtbl_entities[4].onDeath = NULL;

    hashtbl_entities[5].id = 5;
    hashtbl_entities[5].tex = 0;
    hashtbl_entities[5].name = "LinePlatform";
    hashtbl_entities[5].updatePos = &moving_xyz_line;
    hashtbl_entities[5].onHit = &translatePlayerLine;
    hashtbl_entities[5].onDeath = NULL;

    hashtbl_entities[6].id = 6;
    hashtbl_entities[6].tex = 1;
    hashtbl_entities[6].name = "TextBox";
    hashtbl_entities[6].updatePos = NULL;
    hashtbl_entities[6].onHit = &pop_text;
    hashtbl_entities[6].onDeath = NULL;

    hashtbl_entities[7].id = 7;
    hashtbl_entities[7].tex = 2;
    hashtbl_entities[7].name = "WarpBox";
    hashtbl_entities[7].updatePos = NULL;
    hashtbl_entities[7].onHit = &pop_and_tp;
    hashtbl_entities[7].onDeath = NULL;
}

fct_entry* get_entry(int k0) {
    for(int k = 0; k < fct_entry_size; k++) {
        if(hashtbl_entities[k].id == k0) {
            return &(hashtbl_entities[k]);
        }
    }
    return NULL;
}

void copy_room(room* src, room* dest, int chx, int chy) {
    // considering dest has already been malloc'd
    dest->chunk_x = chx;
    dest->chunk_y = chy;
    dest->map = malloc(sizeof(cube_0*)*src->map_size);
    for(int k = 0; k < src->map_size; k++) {
        dest->map[k] = create_cube_0(
            src->map[k]->x, src->map[k]->y, src->map[k]->z, 
            src->map[k]->w, src->map[k]->h, src->map[k]->d,
            src->map[k]->hz_angle, src->map[k]->vt_angle, src->map[k]->red, src->map[k]->green, src->map[k]->blue 
        );
    }
    dest->map_size = src->map_size;
    dest->tps = malloc(sizeof(teleporter*)*src->tps_size);
    for(int k = 0; k < src->tps_size; k++) {
        dest->tps[k] = malloc(sizeof(teleporter));
        dest->tps[k]->hitbox = create_cube_0(
            src->tps[k]->hitbox->x, src->tps[k]->hitbox->y, src->tps[k]->hitbox->z, 
            src->tps[k]->hitbox->w, src->tps[k]->hitbox->h, src->tps[k]->hitbox->d,
            src->tps[k]->hitbox->hz_angle, src->tps[k]->hitbox->vt_angle, src->tps[k]->hitbox->red, src->tps[k]->hitbox->green, src->tps[k]->hitbox->blue 
        );
        dest->tps[k]->dest_chx = src->tps[k]->dest_chx + chx; 
        dest->tps[k]->dest_chy = src->tps[k]->dest_chy + chy; 
        dest->tps[k]->dest_x = src->tps[k]->dest_x;
        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_memlen);
    dest->ent_memlen = src->ent_memlen;
    dest->ent_len = src->ent_len;
    for(int k = 0; k < src->ent_len; k++) {
        dest->ents[k] = malloc(sizeof(entity));
        dest->ents[k]->damage = src->ents[k]->damage;
        dest->ents[k]->tex = src->ents[k]->tex;
        //printf("!! %d !!\n", dest->ents [k]->tex);
        dest->ents[k]->hitpoints = malloc(sizeof(int));
        dest->ents[k]->metai1 = src->ents[k]->metai1;
        dest->ents[k]->metai2 = src->ents[k]->metai2;
        dest->ents[k]->metai3 = src->ents[k]->metai3;
        dest->ents[k]->metai4 = src->ents[k]->metai4;
        dest->ents[k]->metai5 = src->ents[k]->metai5;
        dest->ents[k]->metai6 = src->ents[k]->metai6;
        dest->ents[k]->metad1 = src->ents[k]->metad1;
        dest->ents[k]->metad2 = src->ents[k]->metad2;
        dest->ents[k]->metad3 = src->ents[k]->metad3;
        dest->ents[k]->metad4 = src->ents[k]->metad4;
        dest->ents[k]->metad5 = src->ents[k]->metad5;
        dest->ents[k]->metad6 = src->ents[k]->metad6;
        dest->ents[k]->metad7 = src->ents[k]->metad7;
        dest->ents[k]->metad8 = src->ents[k]->metad8;
        dest->ents[k]->metad9 = src->ents[k]->metad9;
        dest->ents[k]->metach1 = src->ents[k]->metach1;
        dest->ents[k]->metach2 = src->ents[k]->metach2;
        //dest->ents[k]->metach1 = malloc(sizeof(char)*52);
        //dest->ents[k]->metach2 = malloc(sizeof(char)*52);
        //strcpy(dest->ents[k]->metach1, src->ents[k]->metach1);
        //strcpy(dest->ents[k]->metach2, src->ents[k]->metach2);
        *(dest->ents[k]->hitpoints) = *(src->ents[k]->hitpoints);
        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 = src->ents[k]->updatePos;
        dest->ents[k]->onHit = src->ents[k]->onHit;
        dest->ents[k]->onDeath = src->ents[k]->onDeath;
    }
    for(int k = src->ent_len; k < src->ent_memlen; k++) {
        dest->ents[k] = malloc(sizeof(entity));
        dest->ents[k]->hitpoints = malloc(sizeof(int));
        dest->ents[k]->pos = malloc(sizeof(cube_0));
    }
    dest->tps_size = src->tps_size;
}

void build_starting_chunk(int chx, int chy) {
    room* new = malloc(sizeof(room));
    new->chunk_x = chx;
    new->chunk_y = chy;
    new->map = malloc(sizeof(cube_0*)*9);
    new->map_size = 9;
    new->tps = malloc(sizeof(teleporter*)*4);
    new->tps_size = 4;

    new->map[0] = create_cube_0(0.0, 0.0, 0.0, 5.0, 1.0, 5.0, 0.0, 0.0, 255, 255, 255);
    new->map[1] = create_cube_0(0.0, 15.0, 0.0, 5.0, 1.0, 5.0, 0.0, 0.0, 255, 255, 255);
    new->map[2] = create_cube_0(0.0, 30.0, 0.0, 5.0, 1.0, 5.0, 0.0, 0.0, 255, 255, 255);
    new->map[3] = create_cube_0(0.0, 45.0, 0.0, 5.0, 1.0, 5.0, 0.0, 0.0, 255, 255, 255);
    new->map[4] = create_cube_0(0.0, 1.0, 0.0, 1.0, 5.0, 1.0, 0.0, 0.0, 255, 255, 128);
    new->map[5] = create_cube_0(4.0, 1.0, 0.0, 1.0, 5.0, 1.0, 0.0, 0.0, 255, 255, 128);
    new->map[6] = create_cube_0(0.0, 1.0, 4.0, 1.0, 5.0, 1.0, 0.0, 0.0, 255, 255, 128);
    new->map[7] = create_cube_0(4.0, 1.0, 4.0, 1.0, 5.0, 1.0, 0.0, 0.0, 255, 255, 128);
    new->map[8] = create_cube_0(10.0, 10.0, 10.0, 2.0, 2.0, 2.0, 0.0, 0.0, 255, 128, 255);

    new->tps[0] = create_teleporter(-1.0, 1.0, 2.0, 1.0, 2.0 + (double)(rand()%2), 1.0, 0.0, 0.0, 255, 0, 0  , chx-1, chy  , 2.5, 2.5, 2.5);
    new->tps[1] = create_teleporter(2.0, 1.0, -1.0, 1.0, 2.0 + (double)(rand()%2), 1.0, 0.0, 0.0, 255, 255, 0, chx  , chy-1, 2.5, 2.5, 2.5);
    new->tps[2] = create_teleporter(5.0, 1.0, 2.0, 1.0, 2.0 + (double)(rand()%2), 1.0, 0.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, 0.0, 0.0, 0, 0, 255   , chx  , chy+1, 2.5, 2.5, 2.5);

    new->ents = malloc(sizeof(entity*)*32);
    for(int k = 0; k < 32; k++) {
        new->ents[k] = malloc(sizeof(entity));
        new->ents[k]->hitpoints = malloc(sizeof(int));
        new->ents[k]->tex = 0;
        new->ents[k]->pos = malloc(sizeof(cube_0));
    };
    new->ent_len = 1;
    new->ent_memlen = 32;
    fill_cube_0(new->ents[0]->pos, -0.25, 8.25, -0.25, 0.5, 0.5, 0.5, 0.0, 0.0, 193, 128, 0);
    new->ents[0]->damage = 0;
    *(new->ents[0]->hitpoints) = 5;
    new->ents[0]->onDeath = NULL;
    new->ents[0]->onHit = *detectHit;
    new->ents[0]->updatePos = *speen2;

    hashtbl_add(visited, chx, chy, new);
}

void init_hashtbl() {
    printf("+1\n"); fflush(stdout);
    visited = hashtbl_generate(1789);
    printf("+1\n"); fflush(stdout);
    build_starting_chunk(player_chx, player_chy);
    printf("+1\n"); fflush(stdout);
    current_room = hashtbl_find_opt(visited, player_chx, player_chy);
    printf("+1\n"); fflush(stdout);
    total_weight = 0;
    printf("+1\n"); fflush(stdout);
}

void get_number_blocks(int* ret_cubes, int* ret_tps, int* ret_ent, FILE* ptr) {
    *ret_cubes = 0;
    *ret_tps = 0;
    *ret_ent = 0;

    int in_blocks = 0;
    char c = fgetc(ptr);
    while(c != EOF && c != '$') {
        //printf("%c", c);
        if(c == 'B') {
            in_blocks = 0;
        } else if(c == 'T') {
            in_blocks = 1;
        } else if(c == 'E') {
            in_blocks = 2;
        } else if(c == '[') {
            if(in_blocks == 0) {
                *ret_cubes += 1;
            } else if(in_blocks == 1) {
                *ret_tps += 1;
            } else {
                *ret_ent += 1;
            }
        }
        c = fgetc(ptr);
    }

    fclose(ptr);
}

void align_to(FILE* ptr, char ch) {
    char c = fgetc(ptr);
    while(c != EOF && c != ch) {
        c = fgetc(ptr);
    }
}

int read_int(FILE* ptr, bool print) {
    bool is_reading = false;
    int buffer = 0;
    int sign = 1;
    char c = fgetc(ptr);
    while(c != EOF) {
        if(c == '-') {
            sign = -1;
        } else if((int)c >= 48 && (int)c <= 57) {
            is_reading = true;
            buffer = 10*buffer + (int)c - 48;
        } else if(is_reading) {
            /*if(print) {
                printf("%d; ", buffer*sign);
            }*/
            return buffer*sign;
        }
        c = fgetc(ptr);
    }
    return buffer*sign;
}

char* read_string(FILE* ptr) {
    char* res0 = malloc(sizeof(char)*52);
    char c = fgetc(ptr);
    int i = 0;
    while(c != EOF && c == ' ') { // ignore initial spaces
        c = fgetc(ptr);
    }
    while(c != EOF && c != ',') {
        res0[i] = c;
        i += 1;
        c = fgetc(ptr);
    }
    res0[i] = '\0';
    return res0;
}

double sign(double __x) {
    if(__x >= 0.0) {
        return 1.0;
    }
    return -1.0;
}

double read_float(FILE* ptr) {
    int ent = read_int(ptr, false);
    int frac = read_int(ptr, false);
    //printf("%d.%d; ", ent, frac);
    if(ent != 0.0) {
        return (ent/abs(ent))*(absf((double)ent) + ((double)frac)/(pow(10.0, (double)ln_baseN(frac, 10))));
    } else {
        //printf("%d, %d\n", ent, frac);
        return ((double)frac)/(pow(10.0, (double)ln_baseN(frac, 10)));
    }
}

void parse_one_room(int id, char* filename) {
    //printf("    parsing %s...", filename);
    FILE* ptr = fopen(filename, "r");

    pool[id].area = malloc(sizeof(room));
    int ncubes;
    int ntps;
    int nent;

    FILE* ptr2 = fopen(filename, "r");
    get_number_blocks(&ncubes, &ntps, &nent, ptr2);
    printf("(%d, %d, %d)\n", ncubes, ntps, nent);

    int nmemlen = maxd(nent, 64);

    pool[id].area->map = malloc(sizeof(cube_0*)*ncubes);
    pool[id].area->map_size = ncubes;
    pool[id].area->tps = malloc(sizeof(teleporter*)*ntps);
    for(int k = 0; k < ntps; k++) {
        pool[id].area->tps[k] = malloc(sizeof(teleporter));
    }
    pool[id].area->tps_size = ntps;
    pool[id].area->ents = malloc(sizeof(entity*)*nmemlen);
    for(int k = 0; k < nmemlen; k++) {
        pool[id].area->ents[k] = malloc(sizeof(entity));
        pool[id].area->ents[k]->hitpoints = malloc(sizeof(int));
        pool[id].area->ents[k]->pos = malloc(sizeof(cube_0));
        pool[id].area->ents[k]->tex = 0;
    }
    pool[id].area->ent_len = nent;
    pool[id].area->ent_memlen = nmemlen;

    printf("0/3...\n");
    fflush(stdout);

    for(int k = 0; k < ncubes; 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);
        pool[id].area->map[k] = create_cube_0(cx, cy, cz, cw, ch, cd, chz, cvt, red, green, blue);
        //printf("\n");
    }

    printf("1/3...\n");
    fflush(stdout);

    for(int k = 0; k < ntps; 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);
        pool[id].area->tps[k]->hitbox = create_cube_0(cx, cy, cz, cw, ch, cd, chz, cvt, red, green, blue);
        pool[id].area->tps[k]->dest_chx = read_int(ptr, true);
        pool[id].area->tps[k]->dest_chy = read_int(ptr, true);
        //printf("\n");
    }

    printf("2/3...\n");
    fflush(stdout);

    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);
        int fid = read_int(ptr, true);
        fct_entry* entry = get_entry(fid);
        if(entry == NULL) {
            entry = get_entry(0);
        }
        //printf(">>><>>>>><> %d\n", entry->tex);
        fill_cube_0(pool[id].area->ents[k]->pos, cx, cy, cz, cw, ch, cd, chz, cvt, red, green, blue);
        pool[id].area->ents[k]->damage = dmg;
        pool[id].area->ents[k]->tex = entry->tex;
        *(pool[id].area->ents[k]->hitpoints) = hp;
        pool[id].area->ents[k]->updatePos = entry->updatePos;
        pool[id].area->ents[k]->onHit = entry->onHit ;
        pool[id].area->ents[k]->onDeath = entry->onDeath ;
        pool[id].area->ents[k]->metai1 = entry->metai1;
        pool[id].area->ents[k]->metai2 = entry->metai2;
        pool[id].area->ents[k]->metai3 = entry->metai3;
        pool[id].area->ents[k]->metai4 = entry->metai4;
        pool[id].area->ents[k]->metai5 = entry->metai5;
        pool[id].area->ents[k]->metai6 = entry->metai6;
        pool[id].area->ents[k]->metad1 = entry->metad1;
        pool[id].area->ents[k]->metad2 = entry->metad2;
        pool[id].area->ents[k]->metad3 = entry->metad3;
        pool[id].area->ents[k]->metad4 = entry->metad4;
        pool[id].area->ents[k]->metad5 = entry->metad5;
        pool[id].area->ents[k]->metad6 = entry->metad6;
        pool[id].area->ents[k]->metad7 = entry->metad7;
        pool[id].area->ents[k]->metad8 = entry->metad8;
        pool[id].area->ents[k]->metad9 = entry->metad9;
        if(entry->id == 4) {
            // sine platform
            double ccw = read_float(ptr);
            double cch = read_float(ptr);
            double ccd = read_float(ptr);
            int mult = read_int(ptr, true);
            int divd = read_int(ptr, true);
            int phase = read_int(ptr, true);
            pool[id].area->ents[k]->metad1 = cx;
            pool[id].area->ents[k]->metad2 = cy;
            pool[id].area->ents[k]->metad3 = cz;
            pool[id].area->ents[k]->metad4 = ccw;
            pool[id].area->ents[k]->metad5 = cch;
            pool[id].area->ents[k]->metad6 = ccd;
            pool[id].area->ents[k]->metai1 = mult;
            pool[id].area->ents[k]->metai2 = divd;
            pool[id].area->ents[k]->metai3 = phase;
        } else if(entry->id == 5) {
            // linear platform
            double amp_x = read_float(ptr);
            double amp_y = read_float(ptr);
            double amp_z = read_float(ptr);
            double speed_x = read_float(ptr);
            double speed_y = read_float(ptr);
            double speed_z = read_float(ptr);
            pool[id].area->ents[k]->metad1 = cx;
            pool[id].area->ents[k]->metad2 = cy;
            pool[id].area->ents[k]->metad3 = cz;
            pool[id].area->ents[k]->metad4 = speed_x;
            pool[id].area->ents[k]->metad5 = speed_y;
            pool[id].area->ents[k]->metad6 = speed_z;
            pool[id].area->ents[k]->metad7 = amp_x;
            pool[id].area->ents[k]->metad8 = amp_y;
            pool[id].area->ents[k]->metad9 = amp_z;
            pool[id].area->ents[k]->metai1 = 1;
            pool[id].area->ents[k]->metai2 = 1;
            pool[id].area->ents[k]->metai3 = 1;
        } else if(entry->id == 6) {
            // text box
            char* msg = read_string(ptr);
            to_free[to_length] = msg;
            to_length += 1;
            pool[id].area->ents[k]->metach1 = msg;
            int ired = read_int(ptr, true);
            int igreen = read_int(ptr, true);
            int iblue = read_int(ptr, true);
            pool[id].area->ents[k]->metai1 = build_text_box(msg, ired, igreen, iblue);
            pool[id].area->ents[k]->metai3 = (-727); // random value to recognize
        } else if(entry->id == 7) {
            // warp text box
            char* dest = read_string(ptr);
            to_free[to_length] = dest;
            to_length += 1;
            int count = read_int(ptr, true);
            char* msg = read_string(ptr);
            to_free[to_length] = msg;
            to_length += 1;
            pool[id].area->ents[k]->metach1 = dest;
            pool[id].area->ents[k]->metach2 = msg;
            int ired = read_int(ptr, true);
            int igreen = read_int(ptr, true);
            int iblue = read_int(ptr, true);
            pool[id].area->ents[k]->metai1 = build_text_box(msg, ired, igreen, iblue);
            pool[id].area->ents[k]->metai2 = count;
            pool[id].area->ents[k]->metai3 = (-72727); // random value to recognize
        } else {
            pool[id].area->ents[k]->metai3 = 0;
        }
    }

    printf("3/3...\n");
    fflush(stdout);

    pool[id].weight = read_int(ptr, true);
    total_weight += pool[id].weight;

    printf("(w = %d) OK\n", pool[id].weight);
    fflush(stdout);
    printf("\n\n");

    fclose(ptr);
}

char* get_name_and_i(char* folder, int nrooms, int* reti) {
    int len = 0;
    while(folder[len] != '\0') {
        len+=1;
    }
    int lnn = 1+ln_baseN(nrooms, 10);
    int str_size = len+lnn+5;
    char* res = malloc(sizeof(char)*str_size);
    for(int k = 0; k < len; k++) {
        res[k] = folder[k];
    }
    res[len  ] = 'r';
    res[len+1] = 'o';
    res[len+2] = 'o';
    res[len+3] = 'm';
    res[len+4] = '_';
    res[len+5] = '0';
    for(int k = len+6; k < str_size; k++) {
        res[k] = '\0';
    }

    *reti = len+5;
    return res;
}

void parse_rooms(int n_rooms, char* folder) {
    int id = 0;
    char* name = get_name_and_i(folder, n_rooms, &id);

    pool = malloc(sizeof(entry)*n_rooms);
    pool_size = n_rooms;

    printf("<%s> with %d rooms\n", folder, n_rooms);
    printf("Parsing...\n");

    for(int k = 0; k < n_rooms; k++) {
        printf("parsing %d...", k);
        if(k < 10) {
            name[id] =   (char)(k%10 + 48);
        } else if(k < 100) {
            name[id] =   (char)((k/10)%10 + 48);
            name[id+1] = (char)(k%10 + 48);
        } else if(k < 1000) {
            name[id] =   (char)((k/100)%10 + 48);
            name[id+1] = (char)((k/10)%10 + 48);
            name[id+2] = (char)(k%10 + 48);
        }
        parse_one_room(k, name);
        printf("done.\n");
    }

    printf("\nDone.\n");
    free(name);
    printf("Total sum : %d\n", total_weight);
}

// has to be a multiple of both room_width and room_depth
int divider = 4;

// unused
void generate_terrain(room* r) {
    int rsize = 4*(room_width/divider)*(room_width/divider)*(room_depth/divider)*(room_depth/divider); // floor size (with 1x1 cubes)

    cube_0** newMap = malloc(sizeof(cube_0*)*(rsize+r->map_size));
    for(int k = 0; k < rsize+r->map_size; k++) {
        newMap[k] = malloc(sizeof(cube_0));
    }

    for(int k = 0; k < r->map_size; k++) {
        copy_cube(r->map[k], newMap[k]);
        free(r->map[k]);
    }
    free(r->map);

    // use whatever noise funtcion here
    int i = r->map_size;
    for(int l = -room_width; l < room_width; l+=divider) {
        for(int d = -room_depth; d < room_depth; d+=divider) {
            fill_cube_0(newMap[i], (double)l, -20.0, (double)d, (double)divider, 1.0, (double)divider, 0.0, 0.0,32, 128, 32);
            i+=1;
        }
    }

    r->map = newMap;
    r->map_size += rsize;
}

void generate_nearby_chunks(int render_dist) {
    for(int w = -render_dist; w <= render_dist; w++) {
        for(int h = -render_dist; h <= render_dist; h++) {
            if(!hashtbl_mem(visited, player_chx + w, player_chy + h)) {
                printf("generating (%d, %d)... ", player_chx + w, player_chy + h);
                //build_starting_chunk(player_chx + w, player_chy + h);
                int pick = rand()%total_weight;
                printf("R = %d ", pick);
                int sum = 0;
                for(int k = 0; k < pool_size; k++) {
                    sum += pool[k].weight;
                    if(pick < sum) {
                        printf("chose %d\n", k);
                        room* new = malloc(sizeof(room));
                        copy_room(pool[k].area, new, player_chx + w, player_chy + h);
                        //generate_terrain(new);
                        hashtbl_add(visited, player_chx + w, player_chy + h, new);
                        k = pool_size+1;
                    }
                }
                printf("Done\n");
            }
        }
    }
}

void free_pool() {
    for(int k0 = 0; k0 < pool_size; k0++) {
        printf("%d/%d\n", 1+k0, pool_size); fflush(stdout);
        for(int k = 0; k < pool[k0].area->map_size; k++) {
            printf("%d-%d\n", k, pool[k0].area->map_size);
            free(pool[k0].area->map[k]);
        }
        printf("...\n"); fflush(stdout);
        for(int k = 0; k < pool[k0].area->tps_size; k++) {
            free(pool[k0].area->tps[k]->hitbox);
            free(pool[k0].area->tps[k]);
        }
        printf("...\n"); fflush(stdout);
        for(int k = 0; k < pool[k0].area->ent_memlen; k++) {
            if(pool[k0].area->ents[k]->metai3 == -727) { // 6 and 7 //
                //free(pool[k0].area->ents[k]->metach1);
            }
            if(pool[k0].area->ents[k]->metai3 == -72727) { // 7 //
                //free(pool[k0].area->ents[k]->metach1);
                //free(pool[k0].area->ents[k]->metach2);
            }
            free(pool[k0].area->ents[k]->hitpoints);
            free(pool[k0].area->ents[k]->pos);
            free(pool[k0].area->ents[k]);
        }
        printf("...\n"); fflush(stdout);
        free(pool[k0].area->ents);
        free(pool[k0].area->tps);
        free(pool[k0].area->map);
        free(pool[k0].area);
    }
    free(pool);
}

void init_to_free() {
    to_free = malloc(sizeof(char*)*100); // ------------------------------------------------------------------------------------------------- 100 max //
    to_length = 0;
}

void free_to_free() {
    for(int k = 0; k < to_length; k++) {
        free(to_free[k]);
    }
    free(to_free);

}

void free_ent_generator() {
    free(hashtbl_entities);
}