1
0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-12-13 04:40:26 +00:00
hyperrogue/rogueviz/ads/map.cpp

318 lines
9.6 KiB
C++
Raw Normal View History

2022-09-11 10:16:50 +00:00
namespace hr {
namespace ads_game {
enum eObjType { oRock, oMissile, oParticle, oResource, oMainRock };
PPR obj_prio[5] = { PPR::MONSTER_BODY, PPR::ITEMa, PPR::ITEM_BELOW, PPR::ITEM, PPR::MONSTER_HEAD };
2022-09-11 11:43:44 +00:00
struct ads_object {
2022-09-11 11:42:51 +00:00
eObjType type;
eResourceType resource;
2022-09-11 11:42:51 +00:00
cell *owner;
2022-09-11 10:16:50 +00:00
ads_matrix at;
color_t col;
2022-09-18 15:29:01 +00:00
int expire;
vector<ld>* shape;
2022-09-11 10:16:50 +00:00
ld life_start, life_end;
2022-09-11 11:44:28 +00:00
cross_result pt_main;
vector<cross_result> pts;
2022-09-11 10:16:50 +00:00
2022-09-11 11:43:44 +00:00
ads_object(eObjType t, cell *_owner, const ads_matrix& T, color_t _col) : type(t), owner(_owner), at(T), col(_col) {
2022-09-11 10:16:50 +00:00
life_start = -HUGE_VAL;
life_end = HUGE_VAL;
}
};
enum eWalltype { wtNone, wtDestructible, wtSolid, wtGate };
2022-09-18 15:29:01 +00:00
int gen_expire() {
return 20 / randd() - 15;
}
2022-09-17 15:34:54 +00:00
struct shipstate {
ads_matrix at;
2022-09-29 12:24:57 +00:00
ads_matrix current;
2022-09-17 15:34:54 +00:00
ld start;
ld duration;
2022-09-20 10:36:16 +00:00
ld ang;
ads_matrix vctrV;
cell *vctr;
2022-09-17 15:34:54 +00:00
};
2022-09-20 10:36:16 +00:00
vector<shipstate> history;
2022-09-11 10:16:50 +00:00
struct cellinfo {
int mpd_terrain; /* 0 = fully generated terrain */
int rock_dist; /* rocks generated in this radius */
vector<std::unique_ptr<ads_object>> rocks;
2022-09-17 15:34:54 +00:00
vector<shipstate> shipstates;
2022-09-11 10:16:50 +00:00
eWalltype type;
cellinfo() {
mpd_terrain = 4;
rock_dist = -1;
type = wtNone;
}
};
std::unordered_map<cell*, cellinfo> ci_at;
using worldline_visitor = std::function<bool(cell*, ld)>;
void compute_life(cell *c, transmatrix S1, const worldline_visitor& wv) {
ld t = 0;
int iter = 0;
cell *cur_c = c;
auto cur_w = hybrid::get_where(c);
while(t < TAU) {
2022-09-11 10:16:50 +00:00
iter++;
auto last_w = cur_w;
auto next_w = cur_w;
transmatrix next_S1;
ld next_t;
ld last_time = t;
cell *next_c = nullptr;
binsearch(t, t+90._deg, [&] (ld t1) {
2022-09-11 10:16:50 +00:00
S1 = S1 * chg_shift(t1 - last_time);
last_time = t1;
virtualRebase(cur_c, S1);
cur_w = hybrid::get_where(cur_c);
if(cur_w.first != last_w.first) {
next_c = cur_c;
next_w = cur_w;
next_S1 = S1;
next_t = t1;
return true;
}
return false;
2022-09-17 13:16:26 +00:00
}, 10);
2022-09-11 10:16:50 +00:00
if(!next_c) return;
S1 = next_S1;
cur_w = next_w;
t = next_t;
cur_c = next_c;
if(iter > 1000) {
println(hlog, "compute_life c=", cur_c, " w=", cur_w, "t=", t, " S1=", S1);
fixmatrix_ads(S1);
}
if(iter > 1100) break;
if(wv(cur_w.first, t)) break;
}
}
map<int, int> genstats;
int gen_budget;
void gen_terrain(cell *c, cellinfo& ci, int level = 0) {
if(level >= ci.mpd_terrain) return;
if(!hyperbolic) { println(hlog, "wrong geometry detected in gen_terrain!"); exit(1); }
2022-09-11 10:16:50 +00:00
if(ci.mpd_terrain > level + 1) gen_terrain(c, ci, level+1);
forCellCM(c1, c) gen_terrain(c1, ci_at[c1], level+1);
genstats[level]++;
if(level == 2) {
int r = hrand(100);
2022-09-12 11:20:11 +00:00
if(r < 3) {
2022-09-11 10:16:50 +00:00
forCellCM(c1, c) if(hrand(100) < 50)
forCellCM(c2, c1) if(hrand(100) < 50)
if(ci_at[c2].type == wtNone) ci_at[c2].type = wtDestructible;
}
2022-09-12 11:20:11 +00:00
else if(r < 6) {
2022-09-11 10:16:50 +00:00
forCellCM(c1, c) if(hrand(100) < 50)
forCellCM(c2, c1) if(hrand(100) < 50)
if(ci_at[c2].type < wtSolid)
ci_at[c2].type = wtSolid;
}
2022-09-12 11:20:11 +00:00
else if(r < 8)
2022-09-11 10:16:50 +00:00
ci_at[c].type = wtGate;
}
ci.mpd_terrain = level;
}
2022-09-18 10:58:18 +00:00
void add_rock(cell *c, cellinfo& ci, const ads_matrix& T) {
eResourceType rt = eResourceType(rand() % 6);
auto r = std::make_unique<ads_object> (oRock, c, T, rock_color[rt]);
r->resource = rt;
2022-09-18 15:29:01 +00:00
r->expire = gen_expire();
2022-09-18 10:58:18 +00:00
r->shape = &(rand() % 2 ? shape_rock2 : shape_rock);
if(geometry != gRotSpace) { println(hlog, "wrong geometry detected in gen_rocks 2!"); exit(1); }
int q = 0;
auto cleanup = [&] (cell *c, ld t) {
auto& ci = ci_at[c];
hybrid::in_underlying_geometry([&] { gen_terrain(c, ci); });
ci.type = wtNone;
q++;
return false;
};
if(q == 0) ci.type = wtNone;
compute_life(hybrid::get_at(c, 0), unshift(r->at), cleanup);
/* for(int i=0; i<isize(r->shape[0]); i += 2) { // exact check is too slow here
hyperpoint h;
h[0] = r->shape[0][i];
h[1] = r->shape[0][i+1];
h[2] = 0;
h[3] = 1; */
if(0) for(int i=0; i<4; i++) {
hyperpoint h = spin(90*degree*i) * rots::uxpush(0.15) * C0;
compute_life(hybrid::get_at(c, 0), unshift(r->at) * rgpushxto0(h), cleanup);
}
ci.rocks.emplace_back(std::move(r));
}
2022-09-11 10:16:50 +00:00
void gen_rocks(cell *c, cellinfo& ci, int radius) {
if(radius <= ci.rock_dist) return;
if(ci.rock_dist < radius - 1) gen_rocks(c, ci, radius-1);
forCellCM(c1, c) gen_rocks(c1, ci_at[c1], radius-1);
if(!hyperbolic) { println(hlog, "wrong geometry detected in gen_rocks 1!"); exit(1); }
2022-09-11 10:16:50 +00:00
if(radius == 0) {
2022-09-18 10:58:18 +00:00
int q = rpoisson(rock_density);
for(int i=0; i<q; i++) {
/* any point inside the cell equally likely */
ld maxr = cgi.rhexf;
cell *c1 = nullptr;
ld r, alpha;
while(c1 != c) {
ld vol = randd() * wvolarea_auto(maxr);
r = binsearch(0, maxr, [vol] (ld r) { return wvolarea_auto(r) > vol; });
alpha = randd() * TAU;
hyperpoint h = spin(alpha) * xpush0(r);
c1 = c;
virtualRebase(c1, h);
}
hybrid::in_actual([&] {
add_rock(c, ci, ads_matrix(spin(alpha) * rots::uxpush(r/2) * chg_shift(randd() * TAU) * spin(randd() * TAU) * lorentz(0, 3, randd() * rock_max_rapidity)));
});
}
2022-09-11 10:16:50 +00:00
}
ci.rock_dist = radius;
}
2022-09-18 11:14:46 +00:00
void gen_particles(int qty, cell *c, shiftmatrix from, color_t col, ld spd, ld t, ld spread = 1) {
2022-09-11 11:42:51 +00:00
auto& ro = ci_at[c].rocks;
for(int i=0; i<qty; i++) {
2022-09-18 11:14:46 +00:00
auto r = std::make_unique<ads_object>(oParticle, c, from * spin(randd() * TAU * spread) * lorentz(0, 2, (.5 + randd() * .5) * spd), col );
r->shape = &shape_particle;
r->life_end = randd() * t;
r->life_start = 0;
ro.emplace_back(std::move(r));
2022-09-11 11:42:51 +00:00
}
}
2022-09-18 15:29:01 +00:00
void gen_resource(cell *c, shiftmatrix from, eResourceType rsrc, int expire) {
if(!rsrc) return;
auto r = std::make_unique<ads_object>(oResource, c, from, rsrc_color[rsrc]);
r->shape = rsrc_shape[rsrc];
r->life_end = HUGE_VAL;
r->life_start = 0;
2022-09-12 10:57:52 +00:00
r->resource = rsrc;
2022-09-18 15:29:01 +00:00
r->expire = expire;
ci_at[c].rocks.emplace_back(std::move(r));
}
2022-09-12 10:57:52 +00:00
bool pointcrash(hyperpoint h, const vector<cross_result>& vf) {
int winding = 0;
vector<hyperpoint> kleins;
for(auto& p: vf) kleins.push_back(kleinize(p.h) - h);
auto take = [&] (hyperpoint& a, hyperpoint& b) {
if(asign(a[1], b[1]) && xcross(b[0], b[1], a[0], a[1]) < 1e-6)
winding++;
};
for(int i=1; i<isize(kleins); i++) take(kleins[i-1], kleins[i]);
take(kleins.back(), kleins[0]);
return winding & 1;
}
2022-09-28 18:27:11 +00:00
void common_crash_ship() {
invincibility_pt = ship_pt + DS_(how_much_invincibility);
2022-09-12 10:57:52 +00:00
pdata.hitpoints--;
if(pdata.hitpoints <= 0) game_over = true;
2022-09-28 23:12:08 +00:00
playSound(nullptr, "explosion");
2022-09-28 18:27:11 +00:00
}
void ads_crash_ship() {
if(ship_pt < invincibility_pt) return;
2022-09-29 09:13:35 +00:00
common_crash_ship();
2022-09-12 11:20:04 +00:00
hybrid::in_actual([&] {
gen_particles(rpoisson(crash_particle_qty * 2), vctr, ads_inverse(current * vctrV) * spin(ang*degree), rsrc_color[rtHull], crash_particle_rapidity, crash_particle_life);
2022-09-12 11:20:04 +00:00
});
2022-09-12 10:57:52 +00:00
}
2022-09-11 11:42:51 +00:00
void handle_crashes() {
if(paused) return;
2022-10-13 23:01:50 +00:00
if(rotspace) {
if(!currentmap) { println(hlog, "no currentmap!"); return; }
PIU({ handle_crashes(); });
return;
}
2022-09-11 11:43:44 +00:00
vector<ads_object*> missiles;
vector<ads_object*> rocks;
2022-09-12 10:57:52 +00:00
vector<ads_object*> resources;
2022-09-11 11:42:51 +00:00
for(auto m: displayed) {
if(m->type == oMissile)
missiles.push_back(m);
if(m->type == oRock)
rocks.push_back(m);
2022-09-12 10:57:52 +00:00
if(m->type == oResource)
resources.push_back(m);
2022-09-11 11:42:51 +00:00
}
hybrid::in_underlying_geometry([&] {
for(auto m: missiles) {
hyperpoint h = kleinize(m->pt_main.h);
for(auto r: rocks) {
2022-09-12 10:57:52 +00:00
if(pointcrash(h, r->pts)) {
2022-09-11 11:42:51 +00:00
m->life_end = m->pt_main.shift;
r->life_end = r->pt_main.shift;
hybrid::in_actual([&] {
2022-09-18 11:14:46 +00:00
gen_particles(rpoisson(crash_particle_qty), m->owner, m->at * ads_matrix(Id, m->life_end), missile_color, crash_particle_rapidity, crash_particle_life);
gen_particles(rpoisson(crash_particle_qty), r->owner, r->at * ads_matrix(Id, r->life_end), r->col, crash_particle_rapidity, crash_particle_life);
2022-09-18 15:29:01 +00:00
gen_resource(r->owner, r->at * ads_matrix(Id, r->life_end), r->resource, r->expire);
2022-09-28 23:12:08 +00:00
playSound(nullptr, "hit-crush3");
2022-09-11 11:42:51 +00:00
});
}
}
}
if(!game_over) for(int i=0; i<isize(shape_ship); i+=2) {
hyperpoint h = spin(ang*degree) * hpxyz(shape_ship[i] * ads_scale, shape_ship[i+1] * ads_scale, 1);
2022-09-12 10:57:52 +00:00
for(auto r: rocks) {
2022-09-28 18:27:11 +00:00
if(pointcrash(h, r->pts)) ads_crash_ship();
2022-09-12 10:57:52 +00:00
}
for(auto r: resources) {
if(pointcrash(h, r->pts)) {
r->life_end = r->pt_main.shift;
gain_resource(r->resource);
}
}
2022-09-12 12:57:47 +00:00
hyperpoint h1 = normalize(h);
bool crashed = false;
hybrid::in_actual([&] {
2022-09-17 13:17:08 +00:00
swap(h1[2], h1[3]);
2022-09-12 12:57:47 +00:00
ads_point rel = ads_inverse(current * vctrV) * ads_point(h1, 0);
cell *c = hybrid::get_at(vctr, 0);
2022-09-12 12:57:47 +00:00
virtualRebase(c, rel.h);
optimize_shift(rel);
auto w = hybrid::get_where(c);
auto& ci = ci_at[w.first];
ld t = rel.shift + w.second * cgi.plevel;
if(ci.type == wtDestructible || ci.type == wtSolid || (ci.type == wtGate && (int(floor(t)) & 3) == 0)) {
if(!crashed && ship_pt > invincibility_pt) println(hlog, "crashed at t = ", t / TAU, " shift = ", rel.shift/TAU, " sec = ", w.second*cgi.plevel/TAU);
crashed = true;
}
});
2022-09-28 18:27:11 +00:00
if(crashed) ads_crash_ship();
2022-09-12 10:57:52 +00:00
}
2022-09-11 11:42:51 +00:00
});
}
2022-09-11 10:16:50 +00:00
}}