mp2i-vms.fr
677 lines
23 KiB
C
677 lines
23 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 <glad/glad.h>
|
|
#include <GLFW/glfw3.h>
|
|
#include <cglm/cglm.h>
|
|
|
|
#include "hash.h"
|
|
#include "base.h"
|
|
#include "entities.h"
|
|
#include "proj.h"
|
|
#include "move.h"
|
|
#include "display.h"
|
|
#include "music.h"
|
|
|
|
// ---------------------------------------------------------------------------------------------------- //
|
|
double sensitivity = 0.06;
|
|
double fov = 90.0;
|
|
double creative_speed = 0.5;
|
|
double speed = 5.0;
|
|
double vtmult = 2.7;
|
|
double min_dist = 0.4;
|
|
double friction = 0.3;
|
|
double gravity_factor = 26.0;
|
|
// ---------------------------------------------------------------------------------------------------- //
|
|
|
|
const double blockRestitution = 0.2;
|
|
|
|
entity* entToVelCheck = NULL;
|
|
bool doUpdateEntVel = false;
|
|
|
|
entity* movingPlatformUpdate = NULL;
|
|
bool doUpdateMoving = false;
|
|
|
|
bool is_clipping = false;
|
|
int clip_dps = 500;
|
|
|
|
int njumps;
|
|
double fx;
|
|
double fy;
|
|
double fz;
|
|
bool updateForces = false;
|
|
|
|
int player_hp;
|
|
|
|
bool stop_evetything;
|
|
|
|
double camx;
|
|
double camy;
|
|
double camz;
|
|
|
|
double camvx;
|
|
double camvy;
|
|
double camvz;
|
|
double rot_hz;
|
|
double rot_vt;
|
|
|
|
double tan_fov;
|
|
|
|
int draw_type;
|
|
int fade_dmg;
|
|
|
|
bool has_changed;
|
|
int collisionVal = 0;
|
|
|
|
double room_width;
|
|
double room_depth;
|
|
|
|
double sq2;
|
|
|
|
float dmgCD;
|
|
int lastDmg;
|
|
|
|
bool buttonSwitch[16];
|
|
float buttonTimes[16];
|
|
float buttonMaxT[16];
|
|
|
|
bool mathSignal;
|
|
int mathSigCD;
|
|
|
|
void init_csts() {
|
|
camx = 2.0;
|
|
camy = 5.0;
|
|
camz = 2.0;
|
|
player_chx = 0;
|
|
player_chy = 0;
|
|
camvx = 0.0;
|
|
camvy = 0.0;
|
|
camvz = 0.0;
|
|
rot_hz = 0.0;
|
|
rot_vt = 0.0;
|
|
|
|
room_width = 16.0;
|
|
room_depth = 16.0;
|
|
|
|
coins = 0;
|
|
player_hp = 1000;
|
|
njumps = 1;
|
|
|
|
draw_type = 0;
|
|
fade_dmg = 0;
|
|
|
|
mathSignal = false;
|
|
mathSigCD = 4;
|
|
|
|
for(int k = 0; k < 16; k++) {
|
|
buttonTimes[k] = 0.0f;
|
|
buttonSwitch[k] = false;
|
|
buttonMaxT[k] = 0.0f;
|
|
}
|
|
|
|
dmgCD = 0.0f;
|
|
lastDmg = player_hp;
|
|
|
|
stop_evetything = false;
|
|
tan_fov = tan((fov * 3.14159 / 180.0) / 2.0);
|
|
sq2 = sqrt(2);
|
|
}
|
|
|
|
void update_buttons(float dtime) {
|
|
for(int k = 0; k < 16; k++) {
|
|
if(buttonSwitch[k]) {
|
|
if(buttonTimes[k] <= dtime && buttonMaxT[k] > 0.0) {
|
|
buttonTimes[k] = 0.0f;
|
|
buttonSwitch[k] = false;
|
|
} else {
|
|
buttonTimes[k] -= dtime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void set_player_coords(int old_chx, int old_chy) {
|
|
for(int k = 0; k < current_room->tps_size; k++) {
|
|
if(current_room->tps[k]->dest_chx == old_chx && current_room->tps[k]->dest_chy == old_chy) {
|
|
if(true) {
|
|
camx = current_room->tps[k]->hitbox->x + current_room->tps[k]->hitbox->w/2.0;
|
|
camy = current_room->tps[k]->hitbox->y + current_room->tps[k]->hitbox->h +1.5;
|
|
camz = current_room->tps[k]->hitbox->z + current_room->tps[k]->hitbox->d/2.0;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
// no TP has been found, placing to the middle of the room
|
|
camx = 0.0;
|
|
camy = 10.0;
|
|
camz = 0.0;
|
|
}
|
|
|
|
pt_2d surface[3];
|
|
pt_2d directors[2];
|
|
pt_2d normal;
|
|
double p1, p2, p3;
|
|
void getSF(cube_0* cb, int sf) {
|
|
if(sf == 0 || sf == 1) {
|
|
project_to_cube(cb->x + (sf==0)*(cb->w), cb->y , cb->z , &p1, &p2, &p3, cb);
|
|
surface[0] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
|
|
project_to_cube(cb->x + (sf==0)*(cb->w), cb->y + cb->h, cb->z , &p1, &p2, &p3, cb);
|
|
surface[1] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
|
|
project_to_cube(cb->x + (sf==0)*(cb->w), cb->y , cb->z + cb->d, &p1, &p2, &p3, cb);
|
|
surface[2] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
} else if(sf == 2 || sf == 3) {
|
|
project_to_cube(cb->x , cb->y + (sf==2)*(cb->h), cb->z , &p1, &p2, &p3, cb);
|
|
surface[0] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
|
|
project_to_cube(cb->x + cb->w, cb->y + (sf==2)*(cb->h), cb->z , &p1, &p2, &p3, cb);
|
|
surface[1] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
|
|
project_to_cube(cb->x , cb->y + (sf==2)*(cb->h), cb->z + cb->d, &p1, &p2, &p3, cb);
|
|
surface[2] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
} else {
|
|
project_to_cube(cb->x , cb->y , cb->z + (sf==4)*(cb->d), &p1, &p2, &p3, cb);
|
|
surface[0] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
|
|
project_to_cube(cb->x + cb->w, cb->y , cb->z + (sf==4)*(cb->d), &p1, &p2, &p3, cb);
|
|
surface[1] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
|
|
project_to_cube(cb->x , cb->y + cb->h, cb->z + (sf==4)*(cb->d), &p1, &p2, &p3, cb);
|
|
surface[2] = (pt_2d){.x = p1, .y = p2, .z = p3};
|
|
}
|
|
}
|
|
|
|
void getDirectors() {
|
|
directors[0] = (pt_2d){.x = surface[1].x - surface[0].x, .y = surface[1].y - surface[0].y, .z = surface[1].z - surface[0].z};
|
|
directors[1] = (pt_2d){.x = surface[2].x - surface[0].x, .y = surface[2].y - surface[0].y, .z = surface[2].z - surface[0].z};
|
|
}
|
|
|
|
void getNormal() {
|
|
normal.x = directors[0].y*directors[1].z - directors[1].y*directors[0].z;
|
|
normal.y = directors[0].z*directors[1].x - directors[1].z*directors[0].x;
|
|
normal.z = directors[0].x*directors[1].y - directors[1].x*directors[0].y;
|
|
double norm = sqrt(normal.x*normal.x + normal.y*normal.y + normal.z*normal.z);
|
|
normal.x /= norm;
|
|
normal.y /= norm;
|
|
normal.z /= norm;
|
|
}
|
|
|
|
pt_2d cross_product(pt_2d p1, pt_2d p2) {
|
|
return (pt_2d){
|
|
.x = p1.y*p2.z - p1.z*p2.y,
|
|
.y = p1.z*p2.x - p1.x*p2.z,
|
|
.z = p1.x*p2.y - p1.y*p2.x
|
|
};
|
|
}
|
|
|
|
void normalize(pt_2d* p) {
|
|
double norm = sqrt(p->x*p->x + p->y*p->y + p->z*p->z);
|
|
p->x /= norm;
|
|
p->y /= norm;
|
|
p->z /= norm;
|
|
}
|
|
|
|
void debugMove(cube_0* cb) {
|
|
for(int d = 0; d < 6; d++) {
|
|
cb->x -= min_dist;
|
|
cb->y -= min_dist;
|
|
cb->z -= min_dist;
|
|
cb->w += 2*min_dist;
|
|
cb->h += 2*min_dist;
|
|
cb->d += 2*min_dist;
|
|
getSF(cb, d);
|
|
cb->x += min_dist;
|
|
cb->y += min_dist;
|
|
cb->z += min_dist;
|
|
cb->w -= 2*min_dist;
|
|
cb->h -= 2*min_dist;
|
|
cb->d -= 2*min_dist;
|
|
for(int k = 0; k < 3; k++) {
|
|
cube_0* cb2 = create_cube_0(surface[k].x-0.1, surface[k].y-0.1, surface[k].z-0.1, 0.2, 0.2, 0.2, 0.0, 0.0, 255, 255, 255);
|
|
|
|
gl_renderCube(cb2, 0.0, 0.0, 0.0);
|
|
|
|
free(cb2);
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateF_movableCrate(cube_0* cb, double dtime, entity* ent) {
|
|
for(int d = 0; d < 6; d++) {
|
|
cb->x -= min_dist;
|
|
cb->y -= min_dist;
|
|
cb->z -= min_dist;
|
|
cb->w += 2*min_dist;
|
|
cb->h += 2*min_dist;
|
|
cb->d += 2*min_dist;
|
|
getSF(cb, d);
|
|
cb->x += min_dist;
|
|
cb->y += min_dist;
|
|
cb->z += min_dist;
|
|
cb->w -= 2*min_dist;
|
|
cb->h -= 2*min_dist;
|
|
cb->d -= 2*min_dist;
|
|
getDirectors();
|
|
getNormal();
|
|
if(d==2 || d==5 || d==1) {
|
|
normal.x *= -1.0;
|
|
normal.y *= -1.0;
|
|
normal.z *= -1.0;
|
|
}
|
|
//printf("%lf %lf\n", dot3D(normal, directors[0]), dot3D(normal, directors[1]));
|
|
pt_2d vt = (pt_2d){.x = camx-camvx*dtime - surface[0].x, .y = camy-camvy*dtime - surface[0].y, .z = camz-camvz*dtime - surface[0].z};
|
|
pt_2d vtdt = (pt_2d){.x = camx - surface[0].x, .y = camy - surface[0].y, .z = camz - surface[0].z};
|
|
normalize(&vtdt);
|
|
normalize(&vt);
|
|
if(
|
|
(dot3D(vt, normal) <= 0.0 && dot3D(vtdt, normal) >= 0.0) ||
|
|
(dot3D(vt, normal) >= 0.0 && dot3D(vtdt, normal) <= 0.0)
|
|
) {
|
|
//printf("%d\n", d);
|
|
switch (d) {
|
|
case 0:
|
|
ent->metad1 += camvx; break;
|
|
case 1:
|
|
ent->metad1 += camvx; break;
|
|
case 3:
|
|
break;
|
|
case 2:
|
|
ent->metad2 += camvy; break;
|
|
case 4:
|
|
ent->metad3 += camvz; break;
|
|
case 5:
|
|
ent->metad3 += camvz; break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
pt_2d normal_axis = {.x = 0.0, .y = 1.0, .z = 0.0};
|
|
pt_2d normal_axis2 = {.x = 1.0, .y = 0.0, .z = 0.0};
|
|
// rotation axis
|
|
|
|
void updateF(cube_0* cb, double dtime, entity* ent) {
|
|
for(int d = 0; d < 6; d++) {
|
|
cb->x -= min_dist;
|
|
cb->y -= min_dist;
|
|
cb->z -= min_dist;
|
|
cb->w += 2*min_dist;
|
|
cb->h += 2*min_dist;
|
|
cb->d += 2*min_dist;
|
|
getSF(cb, d);
|
|
cb->x += min_dist;
|
|
cb->y += min_dist;
|
|
cb->z += min_dist;
|
|
cb->w -= 2*min_dist;
|
|
cb->h -= 2*min_dist;
|
|
cb->d -= 2*min_dist;
|
|
getDirectors();
|
|
getNormal();
|
|
if(d==2 || d==5 || d==1) {
|
|
normal.x *= -1.0;
|
|
normal.y *= -1.0;
|
|
normal.z *= -1.0;
|
|
}
|
|
//printf("%lf %lf\n", dot3D(normal, directors[0]), dot3D(normal, directors[1]));
|
|
pt_2d vt = (pt_2d){.x = camx-camvx*dtime - surface[0].x, .y = camy-camvy*dtime - surface[0].y, .z = camz-camvz*dtime - surface[0].z};
|
|
pt_2d vtdt = (pt_2d){.x = camx - surface[0].x, .y = camy - surface[0].y, .z = camz - surface[0].z};
|
|
normalize(&vtdt);
|
|
normalize(&vt);
|
|
if(
|
|
(dot3D(vt, normal) <= 0.0 && dot3D(vtdt, normal) >= 0.0) ||
|
|
(dot3D(vt, normal) >= 0.0 && dot3D(vtdt, normal) <= 0.0)
|
|
) {
|
|
//printf("%d\n", d);
|
|
double normv = sqrt(camvx*camvx + camvy*camvy + camvz*camvz);
|
|
|
|
double alpha = acos(dot3D(normal, (pt_2d){.x = camvx, .y = camvy, .z = camvz})/normv);
|
|
double beta = 3.1415926535 - 2*alpha;
|
|
double nu = normv*sqrt(1-cos(beta));
|
|
|
|
pt_2d u = (pt_2d){.x = normal.x*nu, .y = normal.y*nu, .z = normal.z*nu};
|
|
|
|
normalize(&u);
|
|
|
|
if(ent != NULL && ent->entity_type == 2) {
|
|
double radspeed = distance_pt_pt_3d(camx, camy, camz, ent->metad4+ent->pos->w/2.0, camy, ent->metad6+ent->pos->d/2.0
|
|
)*(ent->metad1);
|
|
double radspeed2 = distance_pt_pt_3d(camx, camy, camz, camx, ent->metad5+ent->pos->h/2.0, ent->metad6+ent->pos->d/2.0
|
|
)*(ent->metad2);
|
|
|
|
pt_2d camD;
|
|
camD.x = camx - ent->pos->w/2.0 - ent->metad4;
|
|
camD.y = 0.0;
|
|
camD.z = camz - ent->pos->d/2.0 - ent->metad6;
|
|
if(camD.x*camD.x + camD.y*camD.y + camD.z*camD.z >= 0.001) { // avoid division by 0.0
|
|
normalize(&camD);
|
|
}
|
|
pt_2d utheta = cross_product(camD, normal_axis);
|
|
|
|
pt_2d camD2;
|
|
camD2.x = 0.0;
|
|
camD2.y = camy - ent->pos->h/2.0 - ent->metad5;
|
|
camD2.z = camz - ent->pos->d/2.0 - ent->metad6;
|
|
if(camD2.x*camD2.x + camD2.y*camD2.y + camD2.z*camD2.z >= 0.001) { // avoid division by 0.0
|
|
normalize(&camD2);
|
|
}
|
|
pt_2d utheta2 = cross_product(camD2, normal_axis2);
|
|
|
|
//printf("(HZ) %lf %lf %lf\n", utheta.x*radspeed , utheta.y*radspeed , utheta.z*radspeed );
|
|
//printf("(VT) %lf %lf %lf\n\n", utheta2.x*radspeed2, utheta2.y*radspeed2, utheta2.z*radspeed2);
|
|
|
|
camvx = u.x*normv*(blockRestitution) + utheta.x*radspeed + utheta2.x*radspeed2;
|
|
camvy = u.y*normv*(blockRestitution) + utheta.y*radspeed + utheta2.y*radspeed2;
|
|
camvz = u.z*normv*(blockRestitution) + utheta.z*radspeed + utheta2.z*radspeed2;
|
|
} else {
|
|
camvx = u.x*normv*(blockRestitution);
|
|
camvy = u.y*normv*(blockRestitution);
|
|
camvz = u.z*normv*(blockRestitution);
|
|
}
|
|
|
|
is_clipping = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateF_specific(cube_0* cb, double dtime, entity* ent) {
|
|
double dilat = distance_pt_cube_0_3d_infinite(camx, camy, camz, cb);
|
|
for(int d = 0; d < 6; d++) {
|
|
|
|
// force a collision
|
|
cb->x -= dilat;
|
|
cb->y -= dilat;
|
|
cb->z -= dilat;
|
|
getSF(cb, d);
|
|
cb->x += dilat;
|
|
cb->y += dilat;
|
|
cb->z += dilat;
|
|
getDirectors();
|
|
getNormal();
|
|
if(d==2 || d==5 || d==1) {
|
|
normal.x *= -1.0;
|
|
normal.y *= -1.0;
|
|
normal.z *= -1.0;
|
|
}
|
|
//printf("%lf %lf\n", dot3D(normal, directors[0]), dot3D(normal, directors[1]));
|
|
pt_2d vt = (pt_2d){.x = camx-camvx*dtime - surface[0].x, .y = camy-camvy*dtime - surface[0].y, .z = camz-camvz*dtime - surface[0].z};
|
|
pt_2d vtdt = (pt_2d){.x = camx - surface[0].x, .y = camy - surface[0].y, .z = camz - surface[0].z};
|
|
normalize(&vtdt);
|
|
normalize(&vt);
|
|
|
|
if(
|
|
(dot3D(vt, normal) <= 0.0 && dot3D(vtdt, normal) >= 0.0) ||
|
|
(dot3D(vt, normal) >= 0.0 && dot3D(vtdt, normal) <= 0.0)
|
|
) {
|
|
double normv = sqrt(camvx*camvx + camvy*camvy + camvz*camvz);
|
|
|
|
double alpha = acos(dot3D(normal, (pt_2d){.x = camvx, .y = camvy, .z = camvz})/normv);
|
|
double beta = 3.1415926535 - 2*alpha;
|
|
double nu = normv*sqrt(1-cos(beta));
|
|
|
|
pt_2d u = (pt_2d){.x = normal.x*nu, .y = normal.y*nu, .z = normal.z*nu};
|
|
|
|
normalize(&u);
|
|
|
|
camvx = u.x*normv*(blockRestitution);
|
|
camvy = u.y*normv*(blockRestitution);
|
|
camvz = u.z*normv*(blockRestitution);
|
|
|
|
is_clipping = false;
|
|
}
|
|
}
|
|
|
|
|
|
if(ent != NULL && ent->entity_type == 2) {
|
|
double radspeed = distance_pt_pt_3d(camx, camy, camz, ent->metad4+ent->pos->w/2.0, camy, ent->metad6+ent->pos->d/2.0
|
|
)*(ent->metad1);
|
|
double radspeed2 = distance_pt_pt_3d(camx, camy, camz, camx, ent->metad5+ent->pos->h/2.0, ent->metad6+ent->pos->d/2.0
|
|
)*(ent->metad2);
|
|
|
|
pt_2d camD;
|
|
camD.x = camx - ent->pos->w/2.0 - ent->metad4;
|
|
camD.y = 0.0;
|
|
camD.z = camz - ent->pos->d/2.0 - ent->metad6;
|
|
if(camD.x*camD.x + camD.y*camD.y + camD.z*camD.z >= 0.001) { // avoid division by 0.0
|
|
normalize(&camD);
|
|
}
|
|
pt_2d utheta = cross_product(camD, normal_axis);
|
|
|
|
pt_2d camD2;
|
|
camD2.x = 0.0;
|
|
camD2.y = camy - ent->pos->h/2.0 - ent->metad5;
|
|
camD2.z = camz - ent->pos->d/2.0 - ent->metad6;
|
|
if(camD2.x*camD2.x + camD2.y*camD2.y + camD2.z*camD2.z >= 0.001) { // avoid division by 0.0
|
|
normalize(&camD2);
|
|
}
|
|
pt_2d utheta2 = cross_product(camD2, normal_axis2);
|
|
|
|
//printf("(HZ) %lf %lf %lf\n", utheta.x*radspeed , utheta.y*radspeed , utheta.z*radspeed );
|
|
//printf("(VT) %lf %lf %lf\n\n", utheta2.x*radspeed2, utheta2.y*radspeed2, utheta2.z*radspeed2);
|
|
|
|
camvx = utheta.x*radspeed + utheta2.x*radspeed2;
|
|
camvy = utheta.y*radspeed + utheta2.y*radspeed2;
|
|
camvz = utheta.z*radspeed + utheta2.z*radspeed2;
|
|
}
|
|
//printf("\n");
|
|
}
|
|
|
|
bool update_physics = true;
|
|
bool is_colliding(float dtime) {
|
|
bool globalCollision = false;
|
|
if(doUpdateEntVel) {
|
|
updateF_movableCrate(entToVelCheck->pos, (double)dtime, entToVelCheck);
|
|
doUpdateEntVel = false;
|
|
}
|
|
if(doUpdateMoving) {
|
|
updateF_specific(movingPlatformUpdate->pos, (double)dtime, movingPlatformUpdate);
|
|
doUpdateMoving = false;
|
|
}
|
|
for(int w = -1; w <= 1; w++) {
|
|
for(int h = -1; h <= 1; h++) {
|
|
room* vstd = hashtbl_find_opt(visited, player_chx+w, player_chy+h);
|
|
if(vstd != NULL) {
|
|
for(int k = 0; k < vstd->map_size; k++) {
|
|
double dist = distance_pt_cube_0_3d_infinite(camx-2*room_width*w, camy, camz-2*room_depth*h, vstd->map[k]);
|
|
//if(vstd->map[k]->vt_angle != 0.0) {
|
|
// printf("(%lf)\n", dist);
|
|
//}
|
|
if(dist <= min_dist) {
|
|
if(update_physics && updateForces) {
|
|
updateF(vstd->map[k], (double)dtime, NULL);
|
|
}
|
|
globalCollision = true;
|
|
}
|
|
}
|
|
|
|
for(int k = 0; k < vstd->tps_size; k++) {
|
|
double dist = distance_pt_cube_0_3d_infinite(camx-2*room_width*w, camy, camz-2*room_depth*h, vstd->tps[k]->hitbox);
|
|
if(dist <= min_dist) {
|
|
if(update_physics && updateForces) {
|
|
updateF(vstd->tps[k]->hitbox, (double)dtime, NULL);
|
|
}
|
|
int old_chx = player_chx;
|
|
int old_chy = player_chy;
|
|
player_chx = vstd->tps[k]->dest_chx;
|
|
player_chy = vstd->tps[k]->dest_chy;
|
|
vstd = hashtbl_find_opt(visited, player_chx, player_chy);
|
|
set_player_coords(old_chx, old_chy);
|
|
resetProj();
|
|
globalCollision = true;
|
|
}
|
|
}
|
|
|
|
for(int k = 0; k < vstd->ent_len; k++) {
|
|
//printf("%d -> %d\n", k, vstd->ents[k]->entity_type);
|
|
if(
|
|
(vstd->ents[k]->entity_type != 12 || xor(buttonSwitch[vstd->ents[k]->metai1], vstd->ents[k]->metai2)) && // disabled button block
|
|
(vstd->ents[k]->entity_type != 9 || vstd->ents[k]->metai1) && // off-beat block
|
|
(vstd->ents[k]->entity_type != 13 || (vstd->ents[k]->metad1 == 0.0 || vstd->ents[k]->metai1 == 0)) // hollow math block
|
|
) {
|
|
double dist = distance_pt_cube_0_3d_infinite(camx-2*room_width*w, camy, camz-2*room_depth*h, vstd->ents[k]->pos);
|
|
//printf("%lf vs %lf\n", dist, min_dist);
|
|
if(dist <= min_dist) {
|
|
bool exists = true;
|
|
if(vstd->ents[k]->onHit != NULL) {
|
|
(*vstd->ents[k]->onHit)(dtime, vstd->ents[k]->hitpoints, &vstd->ents[k]->damage, vstd->ents[k], &(*(vstd->ents[k]->pos)));
|
|
if(*(vstd->ents[k]->hitpoints) <= 0) {
|
|
if(vstd->ents[k]->onDeath != NULL) {
|
|
(*vstd->ents[k]->onDeath)(dtime);
|
|
}
|
|
if(vstd->ents[k]->entity_type == 0) {
|
|
play_sound("sound/audio/smw_coin.wav");
|
|
}
|
|
remove_entity(vstd->ents, &vstd->ent_memlen, &vstd->ent_len, k);
|
|
is_clipping = false;
|
|
exists = false;
|
|
k =- 1;
|
|
}
|
|
}
|
|
if(update_physics && exists && updateForces && vstd->ents[k]->entity_type != 0) {
|
|
updateF(vstd->ents[k]->pos, (double)dtime, vstd->ents[k]);
|
|
}
|
|
if(exists && (
|
|
vstd->ents[k]->entity_type == 13 ||
|
|
vstd->ents[k]->entity_type == 9 ||
|
|
vstd->ents[k]->entity_type == 4 ||
|
|
vstd->ents[k]->entity_type == 5
|
|
)) {
|
|
is_clipping = false;
|
|
}
|
|
globalCollision = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return globalCollision;
|
|
}
|
|
|
|
double old_camx = 0.0;
|
|
double old_camy = 0.0;
|
|
double old_camz = 0.0;
|
|
|
|
void movePlayerG(float dtime) {
|
|
old_camx = camx;
|
|
old_camy = camy;
|
|
old_camz = camz;
|
|
|
|
updateForces = true;
|
|
fx = 0.0;
|
|
fy = 0.0;
|
|
fz = 0.0;
|
|
|
|
camvy -= gravity_factor*dtime;
|
|
bool isfalling = camvy < 0.0;
|
|
|
|
double oldvy = camvy;
|
|
|
|
double delx = camvx*dtime;
|
|
double dely = camvy*dtime;
|
|
double delz = camvz*dtime;
|
|
camx += delx;
|
|
camy += dely;
|
|
camz += delz;
|
|
is_clipping = true;
|
|
update_physics = true;
|
|
if(is_colliding(dtime)) {
|
|
if(is_clipping) {
|
|
//player_hp -= (dtime)*clip_dps;
|
|
}
|
|
//printf("HIT\n");
|
|
//printf("[%lf, %lf, %lf]\n{%lf, %lf, %lf}\n\n", fx, fy, fz, camvx, camvy, camvz);
|
|
}
|
|
camx -= delx;
|
|
camy -= dely;
|
|
camz -= delz;
|
|
//printf("%lf | %lf | %lf\n", fx, fy, fz);
|
|
|
|
updateForces = false;
|
|
camvx += fx*dtime;
|
|
camvy += fy*dtime;
|
|
camvz += fz*dtime;
|
|
//printf("%lf | %lf | %lf\n\n", camvx, camvy, camvz);
|
|
if(isfalling && camvy > 0.0) {
|
|
njumps = 1;
|
|
//printf("%lf\n", absf(oldvy));
|
|
if(is_HR==1 && absf(oldvy) >= 15.0) {
|
|
player_hp -= (int)(0.75*absf(oldvy));
|
|
}
|
|
}
|
|
camx += camvx*dtime;
|
|
camy += camvy*dtime;
|
|
camz += camvz*dtime;
|
|
|
|
camvx *= (1.0 - friction*((double)(dtime)));
|
|
camvy *= (1.0 - friction*((double)(dtime)));
|
|
camvz *= (1.0 - friction*((double)(dtime)));
|
|
|
|
if(camy <= -48) {
|
|
camx = 0.0;
|
|
camz = 0.0;
|
|
camy = 5.0;
|
|
camvx = 0.0;
|
|
camvy = 0.0;
|
|
camvz = 0.0;
|
|
player_chx = 0;
|
|
player_chy = 0;
|
|
if(is_HR==1) {
|
|
player_hp = 0;
|
|
} else {
|
|
player_hp -= 250;
|
|
}
|
|
current_room = hashtbl_find_opt(visited, player_chx, player_chy);
|
|
resetProj();
|
|
}
|
|
|
|
update_physics = false;
|
|
if(is_colliding(dtime)) {
|
|
camx = old_camx;
|
|
camy = old_camy;
|
|
camz = old_camz;
|
|
}
|
|
}
|
|
|
|
void teleport_on_edge() {
|
|
if(camx >= room_width) {
|
|
if(!is_one_room) {
|
|
camx -= 2.0*room_width;
|
|
player_chx += 1;
|
|
current_room = hashtbl_find_opt(visited, player_chx, player_chy);
|
|
resetProj();
|
|
}
|
|
} else if(camx <= -room_width) {
|
|
if(!is_one_room) {
|
|
camx += 2.0*room_width;
|
|
player_chx -= 1;
|
|
current_room = hashtbl_find_opt(visited, player_chx, player_chy);
|
|
resetProj();
|
|
}
|
|
} else if(camz >= room_depth) {
|
|
if(!is_one_room) {
|
|
camz -= 2.0*room_depth;
|
|
player_chy += 1;
|
|
current_room = hashtbl_find_opt(visited, player_chx, player_chy);
|
|
resetProj();
|
|
}
|
|
} else if(camz <= -room_depth) {
|
|
if(!is_one_room) {
|
|
camz += 2.0*room_depth;
|
|
player_chy -= 1;
|
|
current_room = hashtbl_find_opt(visited, player_chx, player_chy);
|
|
resetProj();
|
|
}
|
|
}
|
|
} |