mp2i-vms.fr
564 lines
14 KiB
C
564 lines
14 KiB
C
#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 "hash.h"
|
|
#include "base.h"
|
|
|
|
int ln_baseN(int n, int b) {
|
|
int r = 0;
|
|
while(n != 0) {
|
|
n = n / b;
|
|
r++;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
int pw(int x, int n) {
|
|
if (n<0)
|
|
return 0;
|
|
if (n==0)
|
|
return 1;
|
|
if (n%2==0)
|
|
return pw(x*x, n/2);
|
|
return x*pw(x*x, n/2);
|
|
}
|
|
|
|
double pwf(double x, int n) {
|
|
if (n<0)
|
|
return 0.0;
|
|
if (n==0)
|
|
return 1.0;
|
|
if (n%2==0)
|
|
return pwf(x*x, n/2);
|
|
return x*pwf(x*x, n/2);
|
|
}
|
|
|
|
int abs(int n) {
|
|
if(n > 0) {
|
|
return n;
|
|
} else {
|
|
return (-n);
|
|
}
|
|
}
|
|
|
|
int min(int a, int b) {
|
|
if(a > b) {
|
|
return b;
|
|
};
|
|
return a;
|
|
}
|
|
|
|
int max(int a, int b) {
|
|
if(a < b) {
|
|
return b;
|
|
};
|
|
return a;
|
|
}
|
|
|
|
float minf(float a, float b) {
|
|
if(a > b) {
|
|
return b;
|
|
};
|
|
return a;
|
|
}
|
|
|
|
float maxf(float a, float b) {
|
|
if(a < b) {
|
|
return b;
|
|
};
|
|
return a;
|
|
}
|
|
|
|
double mind(double a, double b) {
|
|
if(a > b) {
|
|
return b;
|
|
};
|
|
return a;
|
|
}
|
|
|
|
double maxd(double a, double b) {
|
|
if(a < b) {
|
|
return b;
|
|
};
|
|
return a;
|
|
}
|
|
|
|
double absf(double n) {
|
|
if(n > 0.0f) {
|
|
return n;
|
|
} else {
|
|
return (-n);
|
|
}
|
|
}
|
|
|
|
bool xor(bool a, bool b) {
|
|
return ((a && !b) || (!a && b));
|
|
}
|
|
|
|
// n >= 0
|
|
int reverse(int n) {
|
|
int res = 0;
|
|
int nexp = pw(10, ln_baseN(n, 10));
|
|
int cexp = nexp/10;
|
|
int left = n;
|
|
while(cexp > 0) {
|
|
res += (left%10)*cexp;
|
|
cexp /= 10;
|
|
left /= 10;
|
|
}
|
|
//printf("%d -> %d\n", n, res);
|
|
return res;
|
|
}
|
|
|
|
int convex_seg(int x1, int x2, double theta) {
|
|
return (int)(((1.0f - theta) * x1 + theta * x2));
|
|
}
|
|
|
|
double convex_pt(double a, double b, double theta) {
|
|
return (a+(b-a)*theta);
|
|
}
|
|
|
|
double convex_tri(double a, double tha, double b, double thb, double c, double thc) {
|
|
return (a*tha + b*thb + c*thc);
|
|
}
|
|
|
|
pt_2d convex_pt2d(pt_2d A, pt_2d B, double theta) {
|
|
pt_2d res;
|
|
res.x = A.x+(B.x-A.x)*theta;
|
|
res.y = A.y+(B.y-A.y)*theta;
|
|
res.z = A.z+(B.z-A.z)*theta;
|
|
return res;
|
|
}
|
|
|
|
pt_2d convex_pt2d_tri(pt_2d A, double tha, pt_2d B, double thb, pt_2d C, double thc) {
|
|
pt_2d res;
|
|
res.x = A.x*tha+B.x*thb+C.x*thc;
|
|
res.y = A.y*tha+B.y*thb+C.y*thc;
|
|
res.z = A.z*tha+B.z*thb+C.z*thc;
|
|
return res;
|
|
}
|
|
|
|
bool is_an_integer(char c) {
|
|
return ((int)c >= 48 && (int)c <= 57);
|
|
}
|
|
|
|
pt_2d vect_diff(pt_2d p1, pt_2d p2) {
|
|
pt_2d res;
|
|
res.x = p2.x - p1.x;
|
|
res.y = p2.y - p1.y;
|
|
res.z = p2.z - p1.z;
|
|
return res;
|
|
}
|
|
|
|
double dot2D(pt_2d p1, pt_2d p2) {
|
|
return p1.x * p2.x + p1.y * p2.y;
|
|
}
|
|
|
|
double dot3D(pt_2d p1, pt_2d p2) {
|
|
return p1.x * p2.x + p1.y * p2.y + p1.z * p2.z;
|
|
}
|
|
|
|
double to_double(int n) {
|
|
return (double)n;
|
|
}
|
|
|
|
int to_int(double n) {
|
|
return (int)n;
|
|
}
|
|
|
|
int line_count(char* filename) {
|
|
FILE* ptr = fopen(filename, "r");
|
|
char c = 'd';
|
|
|
|
int n = 0;
|
|
while(c != EOF) {
|
|
if(c == '\n') {
|
|
n += 1;
|
|
};
|
|
c = fgetc(ptr);
|
|
};
|
|
fclose(ptr);
|
|
return (n+1);
|
|
}
|
|
|
|
int str_to_int(char* s) {
|
|
int res = 0;
|
|
int i = 0;
|
|
while(s[i] != '\0' && is_an_integer(s[i])) {
|
|
res *= 10;
|
|
res += (int)s[i] - 48;
|
|
i++;
|
|
};
|
|
return res;
|
|
}
|
|
|
|
bool str_equal(char* s1, char* s2) {
|
|
if(s1[0] == '\0' || s2[0] == '\0') {
|
|
return (s1[0] == '\0' && s2[0] == '\0');
|
|
}
|
|
return (s1[0] == s2[0] && str_equal(&s1[1], &s2[1]));
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ //
|
|
|
|
cube_0* create_cube_0(double x, double y, double z, double w, double h, double d, double hz_a, double vt_a, int r, int g, int b) {
|
|
cube_0* cb = malloc(sizeof(cube_0));
|
|
cb->red = r;
|
|
cb->green = g;
|
|
cb->blue = b;
|
|
cb->x = x;
|
|
cb->y = y;
|
|
cb->z = z;
|
|
cb->w = w;
|
|
cb->h = h;
|
|
cb->d = d;
|
|
cb->hz_angle = hz_a;
|
|
cb->vt_angle = vt_a;
|
|
return cb;
|
|
}
|
|
|
|
void fill_cube_0(cube_0* cb, double x, double y, double z, double w, double h, double d, double hz_a, double vt_a, int r, int g, int b) {
|
|
cb->red = r;
|
|
cb->green = g;
|
|
cb->blue = b;
|
|
cb->x = x;
|
|
cb->y = y;
|
|
cb->z = z;
|
|
cb->w = w;
|
|
cb->h = h;
|
|
cb->d = d;
|
|
cb->hz_angle = hz_a;
|
|
cb->vt_angle = vt_a;
|
|
}
|
|
|
|
cube create_cube(double x, double y, double z, double w, double h, double d, double hz_a, double vt_a, int r, int g, int b) {
|
|
cube cb = malloc(sizeof(cube_0));
|
|
cb = create_cube_0(x, y, z, w, h, d, hz_a, vt_a, r, g, b);
|
|
return cb;
|
|
}
|
|
|
|
void free_cube(cube c) {
|
|
free(c);
|
|
}
|
|
|
|
teleporter* create_teleporter(
|
|
double x, double y, double z, double w, double h, double d, double hz_a, double vt_a, int r, int g, int b,
|
|
int chx_dest, int chy_dest, double x_dest, double y_dest, double z_dest
|
|
) {
|
|
teleporter* tp = malloc(sizeof(teleporter));
|
|
tp->dest_chx = chx_dest;
|
|
tp->dest_chy = chy_dest;
|
|
tp->dest_x = x_dest;
|
|
tp->dest_y = y_dest;
|
|
tp->dest_z = z_dest;
|
|
tp->hitbox = create_cube_0(x, y, z, w, h, d, hz_a, vt_a, r, g, b);
|
|
return tp;
|
|
}
|
|
|
|
void copy_cube(cube_0* src, cube_0* dest) {
|
|
dest->red = src->red;
|
|
dest->green = src->green;
|
|
dest->blue = src->blue;
|
|
dest->hz_angle = src->hz_angle;
|
|
dest->vt_angle = src->vt_angle;
|
|
dest->x = src->x;
|
|
dest->y = src->y;
|
|
dest->z = src->z;
|
|
dest->w = src->w;
|
|
dest->h = src->h;
|
|
dest->d = src->d;
|
|
}
|
|
|
|
void copy_entity(entity* src, entity* dest) {
|
|
dest->damage = src->damage;
|
|
dest->entity_type = src->entity_type;
|
|
*(dest->hitpoints) = *(src->hitpoints);
|
|
|
|
dest->metad1 = src->metad1;
|
|
dest->metad2 = src->metad2;
|
|
dest->metad3 = src->metad3;
|
|
dest->metad4 = src->metad4;
|
|
dest->metad5 = src->metad5;
|
|
dest->metad6 = src->metad6;
|
|
dest->metad7 = src->metad7;
|
|
dest->metad8 = src->metad8;
|
|
dest->metad9 = src->metad9;
|
|
dest->metai1 = src->metai1;
|
|
dest->metai2 = src->metai2;
|
|
dest->metai3 = src->metai3;
|
|
dest->metai4 = src->metai4;
|
|
dest->metai5 = src->metai5;
|
|
dest->metai6 = src->metai6;
|
|
dest->metach1 = src->metach1;
|
|
dest->metach2 = src->metach2;
|
|
|
|
dest->updatePos = src->updatePos;
|
|
dest->onHit = src->onHit;
|
|
dest->onDeath = src->onDeath;
|
|
|
|
dest->tex = src->tex;
|
|
dest->tex2 = src->tex2;
|
|
|
|
copy_cube(src->pos, dest->pos);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ //
|
|
|
|
double distance_pt_pt_3d(double x0, double y0, double z0, double x1, double y1, double z1) {
|
|
return sqrt((x1 - x0)*(x1 - x0)+(y1 - y0)*(y1 - y0)+(z1 - z0)*(z1 - z0));
|
|
}
|
|
|
|
double distance_pt_pt_2d_sq(double x0, double y0, double x1, double y1) {
|
|
return (x1 - x0)*(x1 - x0)+(y1 - y0)*(y1 - y0);
|
|
}
|
|
|
|
double distance_pt_pt_3d_sq(double x0, double y0, double z0, double x1, double y1, double z1) {
|
|
return (x1 - x0)*(x1 - x0)+(y1 - y0)*(y1 - y0)+(z1 - z0)*(z1 - z0);
|
|
}
|
|
|
|
double distance_pt_seg_3d(double x, double y, double z, double sx, double sy, double sz, double ex, double ey, double ez) {
|
|
double theta = -(
|
|
((ex - sx) * (sx - x) + (ey - sy) * (sy - y) + (ez - sz) * (sz - z)) /
|
|
((ex - sx) * (ex - sx) + (ey - sy) * (ey - sy) + (ez - sz) * (ez - sz))
|
|
);
|
|
if(theta >= 0.0 && theta <= 1.0) {
|
|
return (distance_pt_pt_3d(x, y, z, convex_pt(sx, ex, theta), convex_pt(sy, ey, theta), convex_pt(sz, ez, theta)));
|
|
} else if (theta < 0.0) {
|
|
return (distance_pt_pt_3d(x, y, z, sx, sy, sz));
|
|
} else {
|
|
return (distance_pt_pt_3d(x, y, z, ex, ey, ez));
|
|
}
|
|
}
|
|
|
|
double distance_pt_cube_axis(double coord, double begin, double end) {
|
|
if(coord < begin) {
|
|
return (begin);
|
|
} else if(coord > end) {
|
|
return (end);
|
|
} else {
|
|
return (coord);
|
|
}
|
|
}
|
|
|
|
double distance_pt_cube_aligned_3d(double x0, double y0, double z0, double cx, double cy, double cz, double cw, double ch, double cd) {
|
|
double clx = distance_pt_cube_axis(x0, cx, cx+cw);
|
|
double cly = distance_pt_cube_axis(y0, cy, cy+ch);
|
|
double clz = distance_pt_cube_axis(z0, cz, cz+cd);
|
|
return sqrt((x0-clx)*(x0-clx) + (y0-cly)*(y0-cly) + (z0-clz)*(z0-clz));
|
|
}
|
|
|
|
double distance_pt_cube_aligned_3d_infinite(double x0, double y0, double z0, double cx, double cy, double cz, double cw, double ch, double cd) {
|
|
double clx = distance_pt_cube_axis(x0, cx, cx+cw);
|
|
double cly = distance_pt_cube_axis(y0, cy, cy+ch);
|
|
double clz = distance_pt_cube_axis(z0, cz, cz+cd);
|
|
return maxd(maxd(absf(clx-x0), absf(cly-y0)), absf(clz-z0));
|
|
}
|
|
|
|
double distance_pt_cube_0_3d(double x0, double y0, double z0, cube_0* c) {
|
|
// places the origin at the center of the cube
|
|
double x = x0 - (c->x + c->w/2.0);
|
|
double y = y0 - (c->y + c->h/2.0);
|
|
double z = z0 - (c->z + c->d/2.0);
|
|
|
|
// rotate the point : y then x
|
|
double xry = x*cos(c->hz_angle) + z*sin(c->hz_angle);
|
|
double yry = y;
|
|
double zry = z*cos(c->hz_angle) - x*sin(c->hz_angle);
|
|
|
|
double xrx = xry;
|
|
double yrx = yry*cos(c->vt_angle) - zry*sin(c->vt_angle);
|
|
double zrx = zry*cos(c->vt_angle) + yry*sin(c->vt_angle);
|
|
|
|
// now the cube and pt are aligned, and (0, 0, 0) is at the cube's (bary)center
|
|
return distance_pt_cube_aligned_3d(xrx, yrx, zrx, -c->w/2.0, -c->h/2.0, -c->d/2.0, c->w, c->h, c->d);
|
|
}
|
|
|
|
double distance_pt_cube_0_3d_infinite(double x0, double y0, double z0, cube_0* c) {
|
|
// places the origin at the center of the cube
|
|
double x = x0 - (c->x + c->w/2.0);
|
|
double y = y0 - (c->y + c->h/2.0);
|
|
double z = z0 - (c->z + c->d/2.0);
|
|
|
|
// rotate the point : y then x
|
|
double xry = x*cos(c->hz_angle) + z*sin(c->hz_angle);
|
|
double yry = y;
|
|
double zry = z*cos(c->hz_angle) - x*sin(c->hz_angle);
|
|
|
|
double xrx = xry;
|
|
double yrx = yry*cos(c->vt_angle) - zry*sin(c->vt_angle);
|
|
double zrx = zry*cos(c->vt_angle) + yry*sin(c->vt_angle);
|
|
|
|
// now the cube and pt are aligned, and (0, 0, 0) is at the cube's (bary)center
|
|
return distance_pt_cube_aligned_3d_infinite(xrx, yrx, zrx, -c->w/2.0, -c->h/2.0, -c->d/2.0, c->w, c->h, c->d);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ //
|
|
|
|
void project_to_camera(double x0, double y0, double z0, double* rx, double* ry, double* rz) {
|
|
// align pt to (0, 0, 0)
|
|
double x = x0 - camx;
|
|
double y = y0 - camy;
|
|
double z = z0 - camz;
|
|
|
|
// rotate (y)
|
|
double xry = x*cos(rot_hz) - z*sin(rot_hz);
|
|
double yry = y;
|
|
double zry = z*cos(rot_hz) + x*sin(rot_hz);
|
|
|
|
// rotate (x)
|
|
if(rx != NULL) {*rx = xry;}
|
|
if(ry != NULL) {*ry = yry*cos(rot_vt) + zry*sin(rot_vt);}
|
|
if(rz != NULL) {*rz = zry*cos(rot_vt) - yry*sin(rot_vt);}
|
|
}
|
|
|
|
void project_to_cube(double x0, double y0, double z0, double* rx, double* ry, double* rz, cube_0* c) {
|
|
// align pt to (0, 0, 0)
|
|
double x = x0 - (c->x + c->w/2.0);
|
|
double y = y0 - (c->y + c->h/2.0);
|
|
double z = z0 - (c->z + c->d/2.0);
|
|
|
|
// rotate (y)
|
|
double xry = x*cos(c->hz_angle) - z*sin(c->hz_angle);
|
|
double yry = y;
|
|
double zry = z*cos(c->hz_angle) + x*sin(c->hz_angle);
|
|
|
|
// rotate (x)
|
|
if(rx != NULL) {*rx = c->x + c->w/2.0 + xry;}
|
|
if(ry != NULL) {*ry = c->y + c->h/2.0 + yry*cos(c->vt_angle) + zry*sin(c->vt_angle);}
|
|
if(rz != NULL) {*rz = c->z + c->d/2.0 + zry*cos(c->vt_angle) - yry*sin(c->vt_angle);}
|
|
}
|
|
|
|
pt_2d rotate_to_x_axis(double x, double y, double z, double y0, double z0, int angle) {
|
|
pt_2d res;
|
|
|
|
res.x = x;
|
|
res.y = y0+(y-y0)*cos(angle) + (z-z0)*sin(angle);
|
|
res.z = z0+(z-z0)*cos(angle) - (y-y0)*sin(angle);
|
|
|
|
//printf("> %lf %lf %lf <\n", res.x, res.y, res.z);
|
|
return res;
|
|
}
|
|
|
|
pt_2d rotate_to_y_axis(double x, double y, double z, double x0, double z0, int angle) {
|
|
pt_2d res;
|
|
|
|
res.x = x0+(x-x0)*cos(angle) - (z-z0)*sin(angle);
|
|
res.y = y;
|
|
res.z = z0+(z-z0)*cos(angle) + (x-x0)*sin(angle);
|
|
|
|
return res;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ //
|
|
|
|
void remove_entity(entity** arr, int* memlen, int* len, int index) {
|
|
if(*len > 0) {
|
|
entity* temp = arr[index];
|
|
arr[index] = arr[*len -1];
|
|
arr[*len -1] = temp;
|
|
*len -= 1;
|
|
}
|
|
}
|
|
|
|
entity* remove_entity_return(entity** arr, int* memlen, int* len, int index) {
|
|
if(*len > 0) {
|
|
entity* temp = arr[index];
|
|
arr[index] = arr[*len -1];
|
|
arr[*len -1] = temp;
|
|
*len -= 1;
|
|
return temp;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void add_entity(entity** arr, int* memlen, int* len, entity* ent) {
|
|
if(*memlen == *len) {
|
|
entity** newarr = malloc(sizeof(entity*)*2*(*memlen));
|
|
for(int k = 0; k < *len; k++) {
|
|
newarr[k] = arr[k];
|
|
}
|
|
for(int k = *len; k < 2*(*memlen); k++) {
|
|
newarr[k] = malloc(sizeof(entity));
|
|
newarr[k]->pos = malloc(sizeof(cube_0));
|
|
newarr[k]->hitpoints = malloc(sizeof(int));
|
|
}
|
|
free(*arr);
|
|
arr = newarr;
|
|
*memlen *= 2;
|
|
}
|
|
copy_entity(ent, arr[*len]);
|
|
*len += 1;
|
|
}
|
|
|
|
int is_neg0 = 1;
|
|
int read_int(FILE* ptr) {
|
|
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(sign == -1 && buffer == 0) {
|
|
is_neg0 = -1;
|
|
} else {
|
|
is_neg0 = 1;
|
|
}
|
|
return buffer*sign;
|
|
}
|
|
c = fgetc(ptr);
|
|
}
|
|
if(sign == -1 && buffer == 0) {
|
|
is_neg0 = -1;
|
|
} else {
|
|
is_neg0 = 1;
|
|
}
|
|
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);
|
|
int sn0 = is_neg0;
|
|
int frac = read_int(ptr);
|
|
//printf("%d.%d; ", ent, frac);
|
|
if(ent != 0.0) {
|
|
return sn0*(ent/abs(ent))*(absf((double)ent) + ((double)frac)/(pow(10.0, (double)ln_baseN(frac, 10))));
|
|
} else {
|
|
//printf("%d, %d\n", ent, frac);
|
|
return sn0*((double)frac)/(pow(10.0, (double)ln_baseN(frac, 10)));
|
|
}
|
|
} |