mirrors/hyperrogue
1
0
Fork 0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-10-31 19:36:16 +00:00
Code Issues Releases Wiki Activity
6935aa1cf7
hyperrogue/graph.cpp

5732 lines
187 KiB
C++
Raw Normal View History

updated the header comments to 2018, also added the missing ones
2018-02-08 23:40:26 +00:00
// Hyperbolic Rogue -- main graphics file
initial reformatting of comments for Doxygen
2019-08-10 11:43:24 +00:00
// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
initial reformatting of comments for Doxygen
2019-08-10 11:43:24 +00:00
/** \file graph.cpp
* \brief Drawing cells, monsters, items, etc.
*/
Updated to 8.3j
2016-08-26 09:58:03 +00:00
added #include hyper.h to all cpp files
2019-09-05 07:15:40 +00:00
#include "hyper.h"
moved all the HyperRogue stuff except RogueViz to namespace 'hr' -- useful when using hr as a library
2018-06-10 23:58:31 +00:00
namespace hr {
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int last_firelimit;
EX int firelimit;
show borders on fires; limit particles if there are too many fires
2019-03-13 13:04:06 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX int inmirrorcount = 0;
10.0
2017-07-16 21:00:55 +00:00
wall optimization option (-wallopt): do not draw things behind walls
2019-10-12 09:21:00 +00:00
/** wall optimization: do not draw things beyond walls */
EX bool wallopt;
in_wallopt(): auto in racing
2019-12-06 10:45:19 +00:00
EX bool in_wallopt() { return wallopt || racing::on; }
further cleanup
2019-08-09 21:24:33 +00:00
EX bool spatial_graphics;
ASCII/3D mode, also reacts to neon settings
2020-01-30 16:45:05 +00:00
EX bool wmspatial, wmescher, wmplain, wmblack, wmascii, wmascii3;
further cleanup
2019-08-09 21:24:33 +00:00
EX bool mmspatial, mmhigh, mmmon, mmitem;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Panini projection
2020-11-01 20:20:54 +00:00
EX ld panini_alpha = 0;
stereographic projection added
2021-03-21 10:28:10 +00:00
EX ld stereo_alpha = 0;
Panini projection
2020-11-01 20:20:54 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX int detaillevel = 0;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool first_cell_to_draw = true;
3d:: Euclidean tori
2019-04-15 21:29:07 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool in_perspective() {
fixed some pconf/vpconf bugs
2020-11-08 11:09:42 +00:00
return among(pconf.model, mdPerspective, mdGeodesic);
}
EX bool in_perspective_v() {
return among(vpconf.model, mdPerspective, mdGeodesic);
geodesics in Sol
2019-07-28 09:07:21 +00:00
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool hide_player() {
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
return GDIM == 3 && playermoved && vid.yshift == 0 && vid.sspeed > -5 && in_perspective() && (first_cell_to_draw || elliptic) && (WDIM == 3 || vid.camera == 0) && !inmirrorcount
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if CAP_RACING
racing forces standard_centering in quotient/nil/hybrid geometries
2019-09-27 16:04:04 +00:00
&& !(racing::on && !racing::use_standard_centering() && !racing::player_relative)
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
;
3d:: refactored the hide_player function
2019-03-09 14:31:02 +00:00
}
Replace macro ADC with a plain old function hr::span_at.
2021-07-18 21:30:07 +00:00
template<class T>
class span {
T *begin_ = nullptr;
T *end_ = nullptr;
public:
explicit span() = default;
explicit span(T *p, int n) : begin_(p), end_(p + n) {}
T *begin() const { return begin_; }
T *end() const { return end_; }
};
template<class Map, class Key>
hr::span<const shiftmatrix> span_at(const Map& map, const Key& key) {
auto it = map.find(key);
return (it == map.end()) ? hr::span<const shiftmatrix>() : hr::span<const shiftmatrix>(it->second.data(), it->second.size());
}
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
Make hookset<T> a pointer type, just like purehookset. No more declaring `hookset<T> *hooks_foo`; now it's just `hookset<T> hooks_foo` at global scope. This clears the way to make `hookset<T>` into a class type if we want.
2020-04-11 18:47:14 +00:00
EX hookset<bool(int sym, int uni)> hooks_handleKey;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX hookset<bool(cell *c, const shiftmatrix& V)> hooks_drawcell;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX purehookset hooks_frame, hooks_markers;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX ld animation_factor = 1;
EX int animation_lcm = 0;
better system of syncing game animations
2018-09-10 15:49:51 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX ld ptick(int period, ld phase IS(0)) {
better system of syncing game animations
2018-09-10 15:49:51 +00:00
if(animation_lcm) animation_lcm = animation_lcm * (period / gcd(animation_lcm, period));
return (ticks * animation_factor) / period + phase * 2 * M_PI;
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX ld fractick(int period, ld phase IS(0)) {
better system of syncing game animations
2018-09-10 15:49:51 +00:00
ld t = ptick(period, phase) / 2 / M_PI;
t -= floor(t);
if(t<0) t++;
return t;
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX ld sintick(int period, ld phase IS(0)) {
better system of syncing game animations
2018-09-10 15:49:51 +00:00
return sin(ptick(period, phase));
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX transmatrix spintick(int period, ld phase IS(0)) {
better system of syncing game animations
2018-09-10 15:49:51 +00:00
return spin(ptick(period, phase));
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
#define WOLNIEJ 1
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
#define BTOFF 0x404040
#define BTON 0xC0C000
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
// #define PANDORA
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
int colorbar;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool inHighQual; // taking high quality screenshot
more header cleanup
2019-08-09 20:07:03 +00:00
EX bool auraNOGL; // aura without GL
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
//
int axestate;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX int ticks;
export everything: modules compiled separately
2019-09-06 06:17:02 +00:00
EX int frameid;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
export everything: modules compiled separately
2019-09-06 06:17:02 +00:00
EX bool camelotcheat;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool nomap;
Updated to 9.4f (tutorial)
2017-04-08 15:18:29 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX eItem orbToTarget;
EX eMonster monsterToSummon;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX int sightrange_bonus = 0;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX string mouseovers;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX int darken = 0;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
struct fallanim {
10.0g
2017-08-06 12:50:16 +00:00
int t_mon, t_floor, pid;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
eWall walltype;
eMonster m;
10.0g
2017-08-06 12:50:16 +00:00
fallanim() { t_floor = 0; t_mon = 0; pid = 0; walltype = waNone; }
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
};
map<cell*, fallanim> fallanims;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool doHighlight() {
separated highlight
2020-09-15 18:39:15 +00:00
return mmhigh;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int dlit;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
ld spina(cell *c, int dir) {
return 2 * M_PI * dir / c->type;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
flip_dark
2020-05-29 00:42:54 +00:00
/** @brief used to alternate colors depending on distance to something. In chessboard-patterned geometries, also use a third step */
EX int flip_dark(int f, int a0, int a1) {
if(geosupport_chessboard()) {
f = gmod(f, 3);
return a0 + (a1-a0) * f / 2;
}
else
return (f&1) ? a1 : a0;
}
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t fc(int ph, color_t col, int z) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbFire]) col = darkena(firecolor(ph), 0, 0xFF);
if(items[itOrbAether]) col = (col &~0XFF) | (col&0xFF) / 2;
more fixes to multiplayer
2021-03-06 10:46:13 +00:00
for(cell *pc: player_positions())
if(items[itOrbFish] && isWatery(pc) && z != 3) return watercolor(ph);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(invismove)
col =
shmup::on ?
(col &~0XFF) | (int((col&0xFF) * .25))
remaning anim sync
2018-09-10 15:56:37 +00:00
: (col &~0XFF) | (int((col&0xFF) * (100+100*sintick(500)))/200);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return col;
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX int lightat, safetyat;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void drawLightning() { lightat = ticks; }
EX void drawSafety() { safetyat = ticks; }
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawShield(const shiftmatrix& V, eItem it) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_CURVE
better system of syncing game animations
2018-09-10 15:49:51 +00:00
float ds = ptick(300);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = iinf[it].color;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(it == itOrbShield && items[itOrbTime] && !orbused[it])
col = (col & 0xFEFEFE) / 2;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(sphere && cwt.at->land == laHalloween && !wmblack && !wmascii)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
col = 0;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
double d = it == itOrbShield ? cgi.hexf : cgi.hexf - .1;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int mt = sphere ? 7 : 5;
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueball(V * zpush(cgi.GROIN1), cgi.human_height / 2, darkena(col, 0, 0xFF), itOrbShield);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#else
if(1) ;
#endif
3d:: nicer effects for orbs
2019-05-11 13:04:54 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
for(ld a=0; a<=cgi.S84*mt+1e-6; a+=pow(.5, vid.linequality))
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
curvepoint(xspinpush0(a * M_PI/cgi.S42, d + sin(ds + M_PI*2*a/4/mt)*.1));
queuecurve(V, darkena(col, 0, 0xFF), 0x8080808, PPR::LINE);
3d:: nicer effects for orbs
2019-05-11 13:04:54 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawSpeed(const shiftmatrix& V) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_CURVE
better system of syncing game animations
2018-09-10 15:49:51 +00:00
ld ds = ptick(10);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(iinf[itOrbSpeed].color, 0, 0xFF);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) queueball(V * zpush(cgi.GROIN1), cgi.human_height * 0.55, col, itOrbSpeed);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
else
#endif
for(int b=0; b<cgi.S84; b+=cgi.S14) {
line quality option
2018-08-01 09:07:22 +00:00
PRING(a)
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
curvepoint(xspinpush0((ds+b+a) * M_PI/cgi.S42, cgi.hexf*a/cgi.S84));
queuecurve(V, col, 0x8080808, PPR::LINE);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawSafety(const shiftmatrix& V, int ct) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_QUEUE
better system of syncing game animations
2018-09-10 15:49:51 +00:00
ld ds = ptick(50);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueball(V * zpush(cgi.GROIN1), 2*cgi.hexf, col, itOrbSafety);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
return;
}
#endif
for(int a=0; a<ct; a++)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueline(V*xspinpush0((ds+a*cgi.S84/ct) * M_PI/cgi.S42, 2*cgi.hexf), V*xspinpush0((ds+(a+(ct-1)/2)*cgi.S84/ct) * M_PI / cgi.S42, 2*cgi.hexf), col, vid.linequality);
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawFlash(const shiftmatrix& V) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_CURVE
better system of syncing game animations
2018-09-10 15:49:51 +00:00
float ds = ptick(300);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(iinf[itOrbFlash].color, 0, 0xFF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
col &= ~1;
for(int u=0; u<5; u++) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ld rad = cgi.hexf * (2.5 + .5 * sin(ds+u*.3));
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueball(V * zpush(cgi.GROIN1), rad, col, itOrbFlash);
3d:: nicer effects for orbs
2019-05-11 13:04:54 +00:00
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#else
if(1) ;
#endif
3d:: nicer effects for orbs
2019-05-11 13:04:54 +00:00
else {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
PRING(a) curvepoint(xspinpush0(a * M_PI / cgi.S42, rad));
queuecurve(V, col, 0x8080808, PPR::LINE);
3d:: nicer effects for orbs
2019-05-11 13:04:54 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX ld cheilevel(ld v) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
return cgi.FLOOR + (cgi.HEAD - cgi.FLOOR) * v;
2D3D:: gravity particles
2019-05-15 08:51:46 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX transmatrix chei(const transmatrix V, int a, int b) {
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 2) return V;
2D3D:: gravity particles
2019-05-15 08:51:46 +00:00
return V * zpush(cheilevel((a+.5) / b));
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#else
return V;
#endif
3d:: nicer effects for orbs
2019-05-11 13:04:54 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX shiftmatrix chei(const shiftmatrix V, int a, int b) {
#if MAXMDIM >= 4
if(GDIM == 2) return V;
return V * zpush(cheilevel((a+.5) / b));
#else
return V;
#endif
}
void drawLove(const shiftmatrix& V, int hdir) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_CURVE
better system of syncing game animations
2018-09-10 15:49:51 +00:00
float ds = ptick(300);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(iinf[itOrbLove].color, 0, 0xFF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
col &= ~1;
for(int u=0; u<5; u++) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V1 = chei(V, u, 5);
line quality option
2018-08-01 09:07:22 +00:00
PRING(a) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
double d = (1 + cos(a * M_PI/cgi.S42)) / 2;
double z = a; if(z>cgi.S42) z = cgi.S84-z;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(z <= 10) d += (10-z) * (10-z) * (10-z) / 3000.;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ld rad = cgi.hexf * (2.5 + .5 * sin(ds+u*.3)) * d;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
curvepoint(xspinpush0((cgi.S42+hdir+a-1) * M_PI/cgi.S42, rad));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
queuecurve(V1, col, 0x8080808, PPR::LINE);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
graphical effects for some curses
2021-05-21 23:26:59 +00:00
void drawWinter(const shiftmatrix& V, ld hdir, color_t col) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_QUEUE
better system of syncing game animations
2018-09-10 15:49:51 +00:00
float ds = ptick(300);
graphical effects for some curses
2021-05-21 23:26:59 +00:00
col = darkena(col, 0, 0xFF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int u=0; u<20; u++) {
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
ld rad = sin(ds+u * 2 * M_PI / 20) * M_PI / S7;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V1 = chei(V, u, 20);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueline(V1*xspinpush0(M_PI+hdir+rad, cgi.hexf*.5), V1*xspinpush0(M_PI+hdir+rad, cgi.hexf*3), col, 2 + vid.linequality);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawLightning(const shiftmatrix& V) {
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_QUEUE
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(iinf[itOrbLightning].color, 0, 0xFF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int u=0; u<20; u++) {
ld leng = 0.5 / (0.1 + (rand() % 100) / 100.0);
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
ld rad = rand() % 1000;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V1 = chei(V, u, 20);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueline(V1*xspinpush0(rad, cgi.hexf*0.3), V1*xspinpush0(rad, cgi.hexf*leng), col, 2 + vid.linequality);
work in progress for 10.0
2017-07-04 13:38:33 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
work in progress for 10.0
2017-07-04 13:38:33 +00:00
graphical effects for some curses
2021-05-21 23:26:59 +00:00
void drawCurse(const shiftmatrix& V, color_t col) {
#if CAP_QUEUE
col = darkena(col, 0, 0xFF);
for(int u=0; u<20; u++) {
ld leng = 0.6 + 0.3 * randd();
ld rad = rand() % 1000;
shiftmatrix V1 = chei(V, u, 20);
queueline(V1*xspinpush0(rad, cgi.hexf*0.3), V1*xspinpush0(rad, cgi.hexf*leng), col, 2 + vid.linequality);
}
#endif
}
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
#define UNTRANS (GDIM == 3 ? 0x000000FF : 0)
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void drawPlayerEffects(const shiftmatrix& V, cell *c, bool onplayer) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!onplayer && !items[itOrbEmpathy]) return;
if(items[itOrbShield] > (shmup::on ? 0 : ORBBASE)) drawShield(V, itOrbShield);
if(items[itOrbShell] > (shmup::on ? 0 : ORBBASE)) drawShield(V, itOrbShell);
work in progress for 10.0
2017-07-04 13:38:33 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbSpeed]) drawSpeed(V);
graphical effects for some curses
2021-05-21 23:26:59 +00:00
if(items[itCurseGluttony]) drawCurse(V, iinf[itCurseGluttony].color);
if(items[itCurseRepulsion]) drawCurse(V, iinf[itCurseRepulsion].color);
work in progress for 10.0
2017-07-04 13:38:33 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(onplayer && (items[itOrbSword] || items[itOrbSword2])) {
using namespace sword;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
product: Orb of the Sword
2019-08-19 08:55:02 +00:00
if(shmup::on && SWORDDIM == 2) {
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbSword])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V*spin(shmup::pc[multi::cpid]->swordangle), (peace::on ? cgi.shMagicShovel : cgi.shMagicSword), darkena(iinf[itOrbSword].color, 0, 0xC0 + 0x30 * sintick(200)));
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbSword2])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V*spin(shmup::pc[multi::cpid]->swordangle+M_PI), (peace::on ? cgi.shMagicShovel : cgi.shMagicSword), darkena(iinf[itOrbSword2].color, 0, 0xC0 + 0x30 * sintick(200)));
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
3d:: sword
2019-03-09 16:38:23 +00:00
product: Orb of the Sword
2019-08-19 08:55:02 +00:00
else if(SWORDDIM == 3) {
3d:: sword
2019-03-09 16:38:23 +00:00
#if CAP_SHAPES
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vsword =
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
shmup::on ? V * shmup::swordmatrix[multi::cpid] * cspin(2, 0, M_PI/2)
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
: gmatrix[c] * rgpushxto0(inverse_shift(gmatrix[c], tC0(V))) * sword::dir[multi::cpid].T;
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
3d:: sword
2019-03-09 16:38:23 +00:00
if(items[itOrbSword])
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
queuepoly(Vsword * cspin(1,2, ticks / 150.), (peace::on ? cgi.shMagicShovel : cgi.shMagicSword), darkena(iinf[itOrbSword].color, 0, 0xC0 + 0x30 * sintick(200)));
3d:: sword
2019-03-09 16:38:23 +00:00
if(items[itOrbSword2])
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
queuepoly(Vsword * pispin * cspin(1,2, ticks / 150.), (peace::on ? cgi.shMagicShovel : cgi.shMagicSword), darkena(iinf[itOrbSword2].color, 0, 0xC0 + 0x30 * sintick(200)));
3d:: sword
2019-03-09 16:38:23 +00:00
#endif
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
else {
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
int& ang = sword::dir[multi::cpid].angle;
sword:: accurate sword angles
2019-05-28 23:01:13 +00:00
ang %= sword::sword_angles;
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_QUEUE || CAP_SHAPES
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vnow = gmatrix[c] * rgpushxto0(inverse_shift(gmatrix[c], tC0(V))) * ddspin(c,0,M_PI);
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
sword:: accurate sword angles
2019-05-28 23:01:13 +00:00
int adj = 1 - ((sword_angles/cwt.at->type)&1);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#if CAP_QUEUE
hybrid:: refactored the common parts of prod and sl2, also used them when applicable
2019-08-24 12:07:46 +00:00
if(!euclid && !hybri) for(int a=0; a<sword_angles; a++) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(a == ang && items[itOrbSword]) continue;
sword:: removed the dependence on the S* constants
2019-02-26 13:10:23 +00:00
if((a+sword_angles/2)%sword_angles == ang && items[itOrbSword2]) continue;
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
bool longer = sword::pos2(cwt.at, a-1) != sword::pos2(cwt.at, a+1);
sword:: accurate sword angles
2019-05-28 23:01:13 +00:00
if(sword_angles > 48 && !longer) continue;
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(0xC0C0C0, 0, 0xFF);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ld l0 = PURE ? 0.6 * cgi.scalefactor : longer ? 0.36 : 0.4;
ld l1 = PURE ? 0.7 * cgi.scalefactor : longer ? 0.44 : 0.42;
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
hyperpoint h0 = GDIM == 3 ? xpush(l0) * zpush(cgi.FLOOR - cgi.human_height/50) * C0 : xpush0(l0);
hyperpoint h1 = GDIM == 3 ? xpush(l1) * zpush(cgi.FLOOR - cgi.human_height/50) * C0 : xpush0(l1);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#else
hyperpoint h0 = xpush0(l0);
hyperpoint h1 = xpush0(l1);
#endif
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix T = Vnow*spin((sword_angles + (-adj-2*a)) * M_PI / sword_angles);
2d3d:: sword markers on the floor level
2019-05-11 13:19:32 +00:00
queueline(T*h0, T*h1, col, 1, PPR::SUPERLINE);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbSword])
sword:: accurate sword angles
2019-05-28 23:01:13 +00:00
queuepoly(Vnow*spin(M_PI+(-adj-2*ang)*M_PI/sword_angles), (peace::on ? cgi.shMagicShovel : cgi.shMagicSword), darkena(iinf[itOrbSword].color, 0, 0x80 + 0x70 * sintick(200)));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbSword2])
sword:: accurate sword angles
2019-05-28 23:01:13 +00:00
queuepoly(Vnow*spin((-adj-2*ang)*M_PI/sword_angles), (peace::on ? cgi.shMagicShovel : cgi.shMagicSword), darkena(iinf[itOrbSword2].color, 0, 0x80 + 0x70 * sintick(200)));
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
}
more work on new geometries
2017-10-28 08:04:28 +00:00
if(onplayer && items[itOrbSafety]) drawSafety(V, c->type);
work in progress for 10.0
2017-07-04 13:38:33 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(onplayer && items[itOrbFlash]) drawFlash(V);
if(onplayer && items[itOrbLove]) drawLove(V, 0); // displaydir(c, cwt.spin));
work in progress for 10.0
2017-07-04 13:38:33 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbWinter])
graphical effects for some curses
2021-05-21 23:26:59 +00:00
drawWinter(V, 0, iinf[itOrbWinter].color); // displaydir(c, cwt.spin));
if(items[itOrbFire])
drawWinter(V, 0, iinf[itOrbFire].color); // displaydir(c, cwt.spin));
if(items[itCurseWater])
drawWinter(V, 0, iinf[itCurseWater].color); // displaydir(c, cwt.spin));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(onplayer && items[itOrbLightning]) drawLightning(V);
if(safetyat > 0) {
int tim = ticks - safetyat;
if(tim > 2500) safetyat = 0;
for(int u=tim; u<=2500; u++) {
if((u-tim)%250) continue;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ld rad = cgi.hexf * u / 250;
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
line quality option
2018-08-01 09:07:22 +00:00
PRING(a)
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
curvepoint(xspinpush0(a * M_PI / cgi.S42, rad));
queuecurve(V, col, 0, PPR::LINE);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawStunStars(const shiftmatrix& V, int t) {
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int i=0; i<3*t; i++) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = V * spin(M_PI * 2 * i / (3*t) + ptick(200));
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(GDIM == 3) V2 = V2 * zpush(cgi.HEAD);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepolyat(V2, cgi.shFlailBall, 0xFFFFFFFF, PPR::STUNSTARS);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX namespace tortoise {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// small is 0 or 2
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void draw(const shiftmatrix& V, int bits, int small, int stuntime) {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t eyecolor = getBit(bits, tfEyeHue) ? 0xFF0000 : 0xC0C0C0;
color_t shellcolor = getBit(bits, tfShellHue) ? 0x00C040 : 0xA06000;
color_t scutecolor = getBit(bits, tfScuteHue) ? 0x00C040 : 0xA06000;
color_t skincolor = getBit(bits, tfSkinHue) ? 0x00C040 : 0xA06000;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(getBit(bits, tfShellSat)) shellcolor = gradient(shellcolor, 0xB0B0B0, 0, .5, 1);
if(getBit(bits, tfScuteSat)) scutecolor = gradient(scutecolor, 0xB0B0B0, 0, .5, 1);
if(getBit(bits, tfSkinSat)) skincolor = gradient(skincolor, 0xB0B0B0, 0, .5, 1);
if(getBit(bits, tfShellDark)) shellcolor = gradient(shellcolor, 0, 0, .5, 1);
if(getBit(bits, tfSkinDark)) skincolor = gradient(skincolor, 0, 0, .5, 1);
world turtles
2020-03-02 02:06:15 +00:00
if(bits < 0) {
skincolor = 0xC00060;
shellcolor = 0xFF00FF;
scutecolor = 0x6000C0;
eyecolor = 0xFFFFFF;
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
for(int i=0; i<12; i++) {
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col =
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
i == 0 ? shellcolor:
i < 8 ? scutecolor :
skincolor;
int b = getBit(bits, i);
int d = darkena(col, 0, 0xFF);
if(i >= 1 && i <= 7) if(b) { d = darkena(col, 1, 0xFF); b = 0; }
if(i >= 8 && i <= 11 && stuntime >= 3) continue;
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shTortoise[i][b+small], d);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if((i >= 5 && i <= 7) || (i >= 9 && i <= 10))
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V * Mirror, cgi.shTortoise[i][b+small], d);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(i == 8) {
for(int k=0; k<stuntime; k++) {
eyecolor &= 0xFEFEFE;
eyecolor >>= 1;
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shTortoise[12][b+small], darkena(eyecolor, 0, 0xFF));
queuepoly(V * Mirror, cgi.shTortoise[12][b+small], darkena(eyecolor, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int getMatchColor(int bits) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int mcol = 1;
double d = tortoise::getScent(bits);
if(d > 0) mcol = 0xFFFFFF;
else if(d < 0) mcol = 0;
int dd = 0xFF * (atan(fabs(d)/2) / (M_PI/2));
return gradient(0x487830, mcol, 0, dd, 0xFF);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Remove extraneous semicolons to quiet pedantic GCC warnings.
2020-02-23 01:51:27 +00:00
EX }
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
double footfun(double d) {
d -= floor(d);
return
d < .25 ? d :
d < .75 ? .5-d :
d-1;
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
more header cleanup
2019-08-09 21:08:42 +00:00
EX bool ivoryz;
converted if sequences to case instructions
2018-02-05 00:17:11 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void animallegs(const shiftmatrix& V, eMonster mo, color_t col, double footphase) {
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
footphase /= SCALE;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool dog = mo == moRunDog;
bool bug = mo == moBug0 || mo == moMetalBeast;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(bug) footphase *= 2.5;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
double rightfoot = footfun(footphase / .4 / 2) / 4 * 2;
double leftfoot = footfun(footphase / .4 / 2 - (bug ? .5 : dog ? .1 : .25)) / 4 * 2;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(bug) rightfoot /= 2.5, leftfoot /= 2.5;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
used scalefactor when it was not used while it should: WOLF scaling, leg animation, shmup
2019-02-28 02:38:22 +00:00
rightfoot *= SCALE;
leftfoot *= SCALE;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!footphase) rightfoot = leftfoot = 0;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hpcshape* sh[6][4] = {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
{&cgi.shDogFrontPaw, &cgi.shDogRearPaw, &cgi.shDogFrontLeg, &cgi.shDogRearLeg},
{&cgi.shWolfFrontPaw, &cgi.shWolfRearPaw, &cgi.shWolfFrontLeg, &cgi.shWolfRearLeg},
{&cgi.shReptileFrontFoot, &cgi.shReptileRearFoot, &cgi.shReptileFrontLeg, &cgi.shReptileRearLeg},
{&cgi.shBugLeg, NULL, NULL, NULL},
{&cgi.shTrylobiteFrontClaw, &cgi.shTrylobiteRearClaw, &cgi.shTrylobiteFrontLeg, &cgi.shTrylobiteRearLeg},
{&cgi.shBullFrontHoof, &cgi.shBullRearHoof, &cgi.shBullFrontHoof, &cgi.shBullRearHoof},
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
};
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hpcshape **x = sh[mo == moRagingBull ? 5 : mo == moBug0 ? 3 : mo == moMetalBeast ? 4 : mo == moRunDog ? 0 : mo == moReptile ? 2 : 1];
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
improved dog leg animation
2019-05-16 15:22:04 +00:00
if(GDIM == 3) {
3D:: fixed a crash on drawing Hyperbugs
2019-05-24 21:50:06 +00:00
if(x[0]) queuepolyat(V * front_leg_move * cspin(0, 2, rightfoot / leg_length) * front_leg_move_inverse, *x[0], col, PPR::MONSTER_FOOT);
if(x[0]) queuepolyat(V * Mirror * front_leg_move * cspin(0, 2, leftfoot / leg_length) * front_leg_move_inverse, *x[0], col, PPR::MONSTER_FOOT);
if(x[1]) queuepolyat(V * rear_leg_move * cspin(0, 2, -rightfoot / leg_length) * rear_leg_move_inverse, *x[1], col, PPR::MONSTER_FOOT);
if(x[1]) queuepolyat(V * Mirror * rear_leg_move * cspin(0, 2, -leftfoot / leg_length) * rear_leg_move_inverse, *x[1], col, PPR::MONSTER_FOOT);
improved dog leg animation
2019-05-16 15:22:04 +00:00
return;
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VL = mmscale(V, cgi.ALEG0);
const shiftmatrix VAML = mmscale(V, cgi.ALEG);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
3d:: 3D models are now centered correctly instead of on legs
2019-02-27 17:59:21 +00:00
if(x[0]) queuepolyat(VL * xpush(rightfoot), *x[0], col, PPR::MONSTER_FOOT);
if(x[0]) queuepolyat(VL * Mirror * xpush(leftfoot), *x[0], col, PPR::MONSTER_FOOT);
if(x[1]) queuepolyat(VL * xpush(-rightfoot), *x[1], col, PPR::MONSTER_FOOT);
if(x[1]) queuepolyat(VL * Mirror * xpush(-leftfoot), *x[1], col, PPR::MONSTER_FOOT);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
enum class used for PPR
2018-08-28 12:27:23 +00:00
if(x[2]) queuepolyat(VAML * xpush(rightfoot/2), *x[2], col, PPR::MONSTER_FOOT);
if(x[2]) queuepolyat(VAML * Mirror * xpush(leftfoot/2), *x[2], col, PPR::MONSTER_FOOT);
if(x[3]) queuepolyat(VAML * xpush(-rightfoot/2), *x[3], col, PPR::MONSTER_FOOT);
if(x[3]) queuepolyat(VAML * Mirror * xpush(-leftfoot/2), *x[3], col, PPR::MONSTER_FOOT);
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool noshadow;
new commandline options: -fsh and -noshadow
2018-06-25 20:59:29 +00:00
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void ShadowV(const shiftmatrix& V, const hpcshape& bp, PPR prio IS(PPR::MONSTER_SHADOW)) {
2d3d:: shadows
2019-05-13 07:34:22 +00:00
if(WDIM == 2 && GDIM == 3 && bp.shs != bp.she) {
3D:: improvements to transparency: works correctly (e.g. in 2D HoM), including models
2019-05-13 11:18:55 +00:00
auto& p = queuepolyat(V, bp, 0x18, PPR::TRANSPARENT_SHADOW);
2d3d:: shadows
2019-05-13 07:34:22 +00:00
p.outline = 0;
p.subprio = -100;
p.offset = bp.shs;
p.cnt = bp.she - bp.shs;
p.flags &=~ POLY_TRIANGLES;
p.tinf = NULL;
return;
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(mmspatial) {
shadows are now drawn or not correctly -- depending on model_needs_depth()
2019-02-22 20:27:42 +00:00
if(model_needs_depth() || noshadow)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return; // shadows break the depth testing
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
dynamicval<color_t> p(poly_outline, OUTLINE_TRANS);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
queuepolyat(V, bp, SHADOW_MON, prio);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
transmatrix otherbodyparts(const shiftmatrix& V, color_t col, eMonster who, double footphase) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
fixed legs in rotspaces being drawn far away
2020-05-15 12:54:11 +00:00
#define VFOOT ((GDIM == 2 || hybri) ? V : mmscale(V, cgi.LEG0))
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
#define VLEG mmscale(V, cgi.LEG)
#define VGROIN mmscale(V, cgi.GROIN)
#define VBODY mmscale(V, cgi.BODY)
#define VBODY1 mmscale(V, cgi.BODY1)
#define VBODY2 mmscale(V, cgi.BODY2)
#define VBODY3 mmscale(V, cgi.BODY3)
#define VNECK mmscale(V, cgi.NECK)
#define VHEAD mmscale(V, cgi.HEAD)
#define VHEAD1 mmscale(V, cgi.HEAD1)
#define VHEAD2 mmscale(V, cgi.HEAD2)
#define VHEAD3 mmscale(V, cgi.HEAD3)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
#define VALEGS V
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
#define VABODY mmscale(V, cgi.ABODY)
#define VAHEAD mmscale(V, cgi.AHEAD)
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
#define VFISH V
Turn C-style casts into reinterpret_casts for clarity. NFC.
2020-03-23 18:48:41 +00:00
#define VBIRD ((GDIM == 3 || (where && bird_disruption(where))) ? (WDIM == 2 ? mmscale(V, cgi.BIRD) : V) : mmscale(V, cgi.BIRD + .05 * sintick(1000, static_cast<int>(reinterpret_cast<size_t>(where))/1000.)))
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
#define VGHOST mmscale(V, cgi.GHOST)
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
#define VSLIMEEYE mscale(V, cgi.FLATEYE)
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// if(!mmspatial && !footphase && who != moSkeleton) return;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
footphase /= SCALE;
used scalefactor when it was not used while it should: WOLF scaling, leg animation, shmup
2019-02-28 02:38:22 +00:00
double rightfoot = footfun(footphase / .4 / 2.5) / 4 * 2.5 * SCALE;
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
const double wobble = -1;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// todo
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(detaillevel >= 2 && GDIM == 2) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix VL = mmscale(V, cgi.LEG1);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VL * xpush(rightfoot*3/4), cgi.shHumanLeg, col);
queuepoly(VL * Mirror * xpush(-rightfoot*3/4), cgi.shHumanLeg, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 2) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix VL = mmscale(V, cgi.LEG);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VL * xpush(rightfoot/2), cgi.shHumanLeg, col);
queuepoly(VL * Mirror * xpush(-rightfoot/2), cgi.shHumanLeg, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(detaillevel >= 2 && GDIM == 2) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix VL = mmscale(V, cgi.LEG3);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VL * xpush(rightfoot/4), cgi.shHumanLeg, col);
queuepoly(VL * Mirror * xpush(-rightfoot/4), cgi.shHumanLeg, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Tright, Tleft;
3d:: converting the old vector graphics into 3D models
2019-04-20 23:21:03 +00:00
fixed legs in product
2019-08-26 07:26:03 +00:00
if(GDIM == 2 || hybri) {
3d:: converting the old vector graphics into 3D models
2019-04-20 23:21:03 +00:00
Tright = VFOOT * xpush(rightfoot);
Tleft = VFOOT * Mirror * xpush(-rightfoot);
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
3d:: converting the old vector graphics into 3D models
2019-04-20 23:21:03 +00:00
else {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V1 = V;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(WDIM == 2) V1 = V1 * zpush(cgi.GROIN);
improved dog leg animation
2019-05-16 15:22:04 +00:00
Tright = V1 * cspin(0, 2, rightfoot/ leg_length);
Tleft = V1 * Mirror * cspin(2, 0, rightfoot / leg_length);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(WDIM == 2) Tleft = Tleft * zpush(-cgi.GROIN), Tright = Tright * zpush(-cgi.GROIN);
3d:: converting the old vector graphics into 3D models
2019-04-20 23:21:03 +00:00
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
3d:: converting the old vector graphics into 3D models
2019-04-20 23:21:03 +00:00
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(who == moWaterElemental && GDIM == 2) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
double fishtail = footfun(footphase / .4) / 4 * 1.5;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VFOOT * xpush(fishtail), cgi.shFishTail, watercolor(100));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(who == moSkeleton) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Tright, cgi.shSkeletalFoot, col);
queuepoly(Tleft, cgi.shSkeletalFoot, col);
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
return spin(rightfoot * wobble);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(isTroll(who) || who == moMonkey || who == moYeti || who == moRatling || who == moRatlingAvenger || who == moGoblin) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Tright, cgi.shYetiFoot, col);
queuepoly(Tleft, cgi.shYetiFoot, col);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Tright, cgi.shHumanFoot, col);
queuepoly(Tleft, cgi.shHumanFoot, col);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3 || !mmspatial) return spin(rightfoot * wobble);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(detaillevel >= 2 && who != moZombie)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(mmscale(V, cgi.NECK1), cgi.shHumanNeck, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(detaillevel >= 1) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VGROIN, cgi.shHumanGroin, col);
if(who != moZombie) queuepoly(VNECK, cgi.shHumanNeck, col);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(detaillevel >= 2) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(mmscale(V, cgi.GROIN1), cgi.shHumanGroin, col);
if(who != moZombie) queuepoly(mmscale(V, cgi.NECK3), cgi.shHumanNeck, col);
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
return spin(rightfoot * wobble);
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#endif
Updated to 8.3j
2016-08-26 09:58:03 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX bool drawstar(cell *c) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int t=0; t<c->type; t++)
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(c->move(t) && c->move(t)->wall != waSulphur && c->move(t)->wall != waSulphurC &&
c->move(t)->wall != waBarrier)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return false;
return true;
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX bool drawing_usershape_on(cell *c, mapeditor::eShapegroup sg) {
fixed compilation without CAP_EDIT and CAP_CONFIG
2018-08-31 18:59:58 +00:00
#if CAP_EDIT
some more bugfixes
2018-08-28 12:09:36 +00:00
return c && c == mapeditor::drawcell && mapeditor::drawcellShapeGroup() == sg;
fixed compilation without CAP_EDIT and CAP_CONFIG
2018-08-31 18:59:58 +00:00
#else
return false;
#endif
fixed a crash when drawing inventory items while drawcell is also NULL; priority functions now use PPR_DEFAULT not -1; priority is passed as PPR not int
2018-08-28 11:45:11 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX color_t kind_outline(eItem it) {
3d:: radar feature
2019-02-28 15:24:46 +00:00
int k = itemclass(it);
if(k == IC_TREASURE)
return OUTLINE_TREASURE;
else if(k == IC_ORB)
return OUTLINE_ORB;
else
return OUTLINE_OTHER;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX shiftmatrix face_the_player(const shiftmatrix V) {
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 2) return V;
product:: move other face_the_player stuff
2019-08-19 11:56:09 +00:00
if(prod) return mscale(V, cos(ptick(750)) * cgi.plevel / 16);
better flagging of geometries, and isometry spaces nicely selectable
2019-08-26 14:21:05 +00:00
if(hybri) return V * zpush(cos(ptick(750)) * cgi.plevel / 16);
shmup for product: player movement
2019-08-26 07:06:39 +00:00
transmatrix dummy; /* used only in prod anyways */
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
if(nonisotropic) return shiftless(spin_towards(unshift(V), dummy, C0, 2, 0));
vr:: better face_the_player
2021-02-04 20:29:11 +00:00
#if CAP_VR
if(vrhr::enabled) {
shiftpoint h = tC0(V);
hyperpoint uh = unshift(h);
fixed face_the_player to orient ASCII correctly in VR
2021-05-29 18:31:30 +00:00
return shiftless(cspin(1, 2, 90*degree) * rspintox(cspin(2, 1, 90*degree) * uh) * xpush(hdist0(uh)) * cspin(0, 2, 90*degree) * cspin(1, 0, 90*degree));
vr:: better face_the_player
2021-02-04 20:29:11 +00:00
}
#endif
item/monster/wall/land types done with X-macros; flags given too
2019-03-23 15:26:53 +00:00
return rgpushxto0(tC0(V));
}
more header cleanup
2019-08-09 21:08:42 +00:00
EX hpcshape& orbshape(eOrbshape s) {
item/monster/wall/land types done with X-macros; flags given too
2019-03-23 15:26:53 +00:00
switch(s) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
case osLove: return cgi.shLoveRing;
case osRanged: return cgi.shTargetRing;
case osOffensive: return cgi.shSawRing;
case osFriend: return cgi.shPeaceRing;
case osUtility: return cgi.shGearRing;
extra Orb shapes
2021-05-02 11:39:09 +00:00
case osPowerUtility: return cgi.shPowerGearRing;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
case osDirectional: return cgi.shSpearRing;
case osWarping: return cgi.shHeptaRing;
new ring shape: shFrogRing
2020-02-25 23:56:06 +00:00
case osFrog: return cgi.shFrogRing;
extra Orb shapes
2021-05-02 11:39:09 +00:00
case osProtective: return cgi.shProtectiveRing;
case osTerraform: return cgi.shTerraRing;
case osMovement: return cgi.shMoveRing;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
default: return cgi.shRing;
item/monster/wall/land types done with X-macros; flags given too
2019-03-23 15:26:53 +00:00
}
}
no inner line drawn in rings
2021-05-09 00:25:05 +00:00
void queue_ring(const shiftmatrix& V, hpcshape& sh, color_t col, PPR p) {
queuepolyat(V, sh, col, p).outline = 0;
auto& p1 = queuepolyat(V, sh, col, p);
p1.cnt = cgi.orb_inner_ring;
p1.color = 0;
auto& p2 = queuepolyat(V, sh, col, p);
p2.color = 0;
p2.offset += cgi.orb_inner_ring;
p2.cnt -= cgi.orb_inner_ring + 1;
}
factored out orb_auxiliary_color
2020-02-29 19:30:15 +00:00
EX color_t orb_auxiliary_color(eItem it) {
if(it == itOrbFire) return firecolor(200);
if(it == itOrbFriend || it == itOrbDiscord) return 0xC0C0C0;
if(it == itOrbFrog) return 0xFF0000;
if(it == itOrbImpact) return 0xFF0000;
if(it == itOrbPhasing) return 0xFF0000;
if(it == itOrbDash) return 0xFF0000;
if(it == itOrbFreedom) return 0xC0FF00;
if(it == itOrbPlague) return 0x409040;
if(it == itOrbChaos) return 0xFF00FF;
if(it == itOrbAir) return 0xFFFFFF;
if(it == itOrbUndeath) return minf[moFriendlyGhost].color;
if(it == itOrbRecall) return 0x101010;
if(it == itOrbSlaying) return 0xFF0000;
return iinf[it].color;
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
EX void draw_ascii(const shiftmatrix& V, char glyph, color_t col, ld size) {
string s = s0 + glyph;
int id = isize(ptds);
if(WDIM == 2 && GDIM == 3)
queuestrn(V * zpush(cgi.FLOOR - cgi.scalefactor * size / 4), size, s, darkenedby(col, darken), 0);
else
queuestrn(V, 1, s, darkenedby(col, darken), GDIM == 3 ? 0 : 2);
while(id < isize(ptds)) ptds[id++]->prio = PPR::MONSTER_BODY;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX bool drawItemType(eItem it, cell *c, const shiftmatrix& V, color_t icol, int pticks, bool hidden) {
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
if(!it) return false;
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
char xch = iinf[it].glyph;
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
#if MAXMDIM >= 4
if(c && GDIM == 3)
addradar(V, xch, icol, kind_outline(it));
#endif
if(WDIM == 3 && c == centerover && in_perspective() && hdist0(tC0(V)) < cgi.orbsize * 0.25) return false;
if(!mmitem || !CAP_SHAPES) {
draw_ascii(V, iinf[it].glyph, icol, 1);
return true;
}
#if CAP_SHAPES
better system of syncing game animations
2018-09-10 15:49:51 +00:00
auto sinptick = [c, pticks] (int period) { return c ? sintick(period) : sin(animation_factor * pticks / period);};
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
auto spinptick = [c, pticks] (int period, ld phase) { return c ? spintick(period, phase) : spin((animation_factor * pticks + phase) / period); };
more work on new geometries
2017-10-28 08:04:28 +00:00
int ct6 = c ? ctof(c) : 1;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hpcshape *xsh =
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
(it == itPirate || it == itKraken) ? &cgi.shPirateX :
(it == itBuggy || it == itBuggy2) ? &cgi.shPirateX :
it == itHolyGrail ? &cgi.shGrail :
isElementalShard(it) ? &cgi.shElementalShard :
improved theme for Dice Heaven and Cursed Canyon
2021-05-29 13:47:02 +00:00
(it == itBombEgg || it == itTrollEgg || it == itCursed) ? &cgi.shEgg :
Gold Ball looks like ball
2020-02-26 00:40:11 +00:00
it == itFrog ? &cgi.shDisk :
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
it == itHunting ? &cgi.shTriangle :
first version of the Land of Dice
2021-05-27 11:00:20 +00:00
(it == itDodeca || it == itDice) ? &cgi.shDodeca :
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
xch == '*' ? &cgi.shGem[ct6] :
xch == '(' ? &cgi.shKnife :
it == itShard ? &cgi.shMFloor.b[0] :
it == itTreat ? &cgi.shTreat :
it == itSlime ? &cgi.shEgg :
xch == '%' ? &cgi.shDaisy : xch == '$' ? &cgi.shStar : xch == ';' ? &cgi.shTriangle :
xch == '!' ? &cgi.shTriangle : it == itBone ? &cgi.shNecro : it == itStatue ? &cgi.shStatue :
fixed/changed some descriptions
2020-03-02 18:52:22 +00:00
among(it, itIvory, itEclectic) ? &cgi.shFigurine :
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
xch == '?' ? &cgi.shBookCover :
it == itKey ? &cgi.shKey :
it == itRevolver ? &cgi.shGun :
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
NULL;
3d:: radar feature
2019-02-28 15:24:46 +00:00
if(c && doHighlight())
poly_outline = kind_outline(it);
3d:: draw:: draw items without rotation, draw them in current location
2019-04-07 01:07:39 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vit = V;
improved Tortoise graphics in 3D, Baby Tortoises appear
2019-06-24 11:46:10 +00:00
if(GDIM == 3 && WDIM == 2 && c && it != itBabyTortoise) Vit = mscale(V, cgi.STUFF);
product:: item placement
2019-08-18 19:30:39 +00:00
if(c && prod)
Vit = mscale(Vit, sin(ptick(750)) * cgi.plevel / 4);
sl2:: 3d-models
2019-08-24 12:49:49 +00:00
else if(c && sl2)
Vit = Vit * zpush(sin(ptick(750)) * cgi.plevel / 4);
product:: item placement
2019-08-18 19:30:39 +00:00
else
if(GDIM == 3 && c && it != itBabyTortoise) Vit = face_the_player(Vit);
3D:: item graphics now face the player
2019-02-26 13:35:04 +00:00
// V * cspin(0, 2, ptick(618, 0));
3D:: spinning items; improved Grimoire gfx
2019-02-22 20:29:01 +00:00
fixed item graphics
2021-06-17 07:39:08 +00:00
#if CAP_SHAPES
if(mapeditor::drawUserShape(Vit, mapeditor::sgItem, it, darkena(icol, 0, 0xFF), c)) return true;
#endif
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
if(c && history::includeHistory && history::infindhistory.count(c)) poly_outline = OUTLINE_DEAD;
Fixed mapediting floorshapes. Also works nicely for all geometries now. Enum used for shapegroups.
2018-08-27 17:27:35 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itSavedPrincess) {
fixed the monster color in the minimap for Dragons etc
2019-06-24 10:57:00 +00:00
drawMonsterType(moPrincess, c, V, icol, 0, icol);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itStrongWind) {
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
queuepoly(Vit * spinptick(750, 0), cgi.shFan, darkena(icol, 0, 255));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
implemented curses
2021-05-02 13:16:29 +00:00
else if(it == itFatigue) {
queuepoly(Vit * spinptick(750, 0), cgi.shFan, darkena(icol, 0, 255));
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itWarning) {
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
queuepoly(Vit * spinptick(750, 0), cgi.shTriangle, darkena(icol, 0, 255));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itBabyTortoise) {
int bits = c ? tortoise::babymap[c] : tortoise::last;
int over = c && c->monst == moTortoise;
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
tortoise::draw(Vit * spinptick(5000, 0) * ypush(cgi.crossf*.15), bits, over ? 4 : 2, 0);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
// queuepoly(Vit, cgi.shHeptaMarker, darkena(tortoise::getMatchColor(bits), 0, 0xC0));
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itCompass) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2;
geometry flags part 1
2019-02-17 17:28:20 +00:00
#if CAP_CRYSTAL
fixed new geometry handling for Archimedean
2019-08-22 10:14:39 +00:00
if(cryst) {
crystal:: added a conduct for doing Camelot without compasses
2018-12-25 22:54:34 +00:00
if(crystal::compass_probability <= 0) return true;
if(cwt.at->land == laCamelot && celldistAltRelative(cwt.at) < 0) crystal::used_compass_inside = true;
crystal:: compass generation
2018-12-03 22:03:35 +00:00
V2 = V * spin(crystal::compass_angle() + M_PI);
crystal:: added a conduct for doing Camelot without compasses
2018-12-25 22:54:34 +00:00
}
geometry flags part 1
2019-02-17 17:28:20 +00:00
else
#endif
if(1) {
crystal:: compass generation
2018-12-03 22:03:35 +00:00
cell *c1 = c ? findcompass(c) : NULL;
if(c1) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix P = ggmatrix(c1);
shiftpoint P1 = tC0(P);
crystal:: compass generation
2018-12-03 22:03:35 +00:00
if(isPlayerOn(c)) {
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(P1, 2*vid.fsize, "X", 0x10100 * int(128 + 100 * sintick(150)));
crystal:: compass generation
2018-12-03 22:03:35 +00:00
// queuestr(V, 1, its(compassDist(c)), 0x10101 * int(128 - 100 * sin(ticks / 150.)), 1);
queuestr(P1, vid.fsize, its(-compassDist(c)), 0x10101 * int(128 - 100 * sintick(150)));
Fixed the meaningo of color parameter in addauraspecial
2018-12-23 13:30:09 +00:00
addauraspecial(P1, 0xFF0000, 0);
crystal:: compass generation
2018-12-03 22:03:35 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
V2 = V * rspintox(inverse_shift(V, P1));
10.0g
2017-08-06 12:50:16 +00:00
}
crystal:: compass generation
2018-12-03 22:03:35 +00:00
else V2 = V;
10.0g
2017-08-06 12:50:16 +00:00
}
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) {
no inner line drawn in rings
2021-05-09 00:25:05 +00:00
queue_ring(Vit, cgi.shRing, 0xFFFFFFFF, PPR::ITEM);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(WDIM == 2) V2 = mscale(V2, cgi.STUFF);
3d:: a 3d image for compasses in the world
2019-03-04 16:57:54 +00:00
V2 = V2 * cspin(1, 2, M_PI * sintick(100) / 39);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V2, cgi.shCompass3, 0xFF0000FF);
queuepoly(V2 * pispin, cgi.shCompass3, 0x000000FF);
3d:: a 3d image for compasses in the world
2019-03-04 16:57:54 +00:00
}
else {
if(c) V2 = V2 * spin(M_PI * sintick(100) / 30);
fixed colors of underwater compasses and rugs
2020-07-24 14:21:11 +00:00
color_t hider = hidden ? 0xFFFFFF20 : 0xFFFFFFFF;
queuepoly(V2, cgi.shCompass1, 0xFF8080FF & hider);
queuepoly(V2, cgi.shCompass2, 0xFFFFFFFF & hider);
queuepoly(V2, cgi.shCompass3, 0xFF0000FF & hider);
queuepoly(V2 * pispin, cgi.shCompass3, 0x000000FF & hider);
3d:: a 3d image for compasses in the world
2019-03-04 16:57:54 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
xsh = NULL;
}
Updated to 9.4g (mostly tutorial fixes)
2017-04-14 18:12:23 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itPalace) {
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
if(GDIM == 3 && WDIM == 2) {
added some guards for MAXMDIM >= 4 and CAP_SOLV
2021-03-30 09:27:48 +00:00
ld h = cgi.human_height;
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
dynamicval<qfloorinfo> qfi2(qfi, qfi);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = V * spin(ticks / 1500.);
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
/* divisors should be higher than in plate renderer */
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
qfi.fshape = &cgi.shMFloor2;
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
draw_shapevec(c, V2 * zpush(-h/30), qfi.fshape->levels[0], 0xFFD500FF, PPR::WALL);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
qfi.fshape = &cgi.shMFloor3;
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
draw_shapevec(c, V2 * zpush(-h/25), qfi.fshape->levels[0], darkena(icol, 0, 0xFF), PPR::WALL);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
qfi.fshape = &cgi.shMFloor4;
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
draw_shapevec(c, V2 * zpush(-h/20), qfi.fshape->levels[0], 0xFFD500FF, PPR::WALL);
}
fixed crash on displaying Rugs in inventory in 3D geometries
2019-07-30 11:00:30 +00:00
else if(WDIM == 3 && c) {
one more guard fixup
2021-03-30 09:33:35 +00:00
ld h = cgi.human_height;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = Vit * spin(ticks / 1500.);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
draw_floorshape(c, V2 * zpush(h/100), cgi.shMFloor3, 0xFFD500FF);
draw_floorshape(c, V2 * zpush(h/50), cgi.shMFloor4, darkena(icol, 0, 0xFF));
queuepoly(V2, cgi.shGem[ct6], 0xFFD500FF);
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
}
fixed crash on displaying Rugs in inventory in 3D geometries
2019-07-30 11:00:30 +00:00
else if(WDIM == 3 && !c) {
queuepoly(Vit, cgi.shGem[ct6], 0xFFD500FF);
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
else
#endif
{
fixed colors of underwater compasses and rugs
2020-07-24 14:21:11 +00:00
color_t hider = hidden ? 0xFFFFFF20 : 0xFFFFFFFF;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = Vit * spin(ticks / 1500.);
fixed colors of underwater compasses and rugs
2020-07-24 14:21:11 +00:00
draw_floorshape(c, V2, cgi.shMFloor3, 0xFFD500FF & hider);
draw_floorshape(c, V2, cgi.shMFloor4, darkena(icol, 0, 0xFF) & hider);
queuepoly(V2, cgi.shGem[ct6], 0xFFD500FF & hider);
2D3D:: better Rugs
2019-05-25 01:36:48 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
xsh = NULL;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itRose) {
for(int u=0; u<4; u++)
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
queuepoly(Vit * spinptick(1500, 0) * spin(2*M_PI / 3 / 4 * u), cgi.shRoseItem, darkena(icol, 0, hidden ? 0x30 : 0xA0));
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(it == itBarrow && c) {
for(int i = 0; i<c->landparam; i++)
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
queuepolyat(Vit * spin(2 * M_PI * i / c->landparam) * xpush(.15) * spinptick(1500, 0), *xsh, darkena(icol, 0, hidden ? 0x40 :
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
(highwall(c) && wmspatial) ? 0x60 : 0xFF),
enum class used for PPR
2018-08-28 12:27:23 +00:00
PPR::HIDDEN);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
// queuepoly(Vit*spin(M_PI+(1-2*ang)*2*M_PI/cgi.S84), cgi.shMagicSword, darkena(0xC00000, 0, 0x80 + 0x70 * sin(ticks / 200.0)));
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(xsh) {
if(it == itFireShard) icol = firecolor(100);
if(it == itWaterShard) icol = watercolor(100) >> 8;
if(it == itZebra) icol = 0xFFFFFF;
if(it == itLotus) icol = 0x101010;
graphics/theming for Jelly/Ruins
2018-01-04 14:46:06 +00:00
if(it == itSwitch) icol = minf[active_switch()].color;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = Vit * spinptick(1500, 0);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(xsh == &cgi.shBookCover && mmitem) {
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V2 * cpush(2, 1e-3), cgi.shBook, 0x805020FF);
3D:: spinning items; improved Grimoire gfx
2019-02-22 20:29:01 +00:00
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V2, cgi.shBook, 0x805020FF);
3D:: spinning items; improved Grimoire gfx
2019-02-22 20:29:01 +00:00
}
new lands for 10.1 -- initial commit
2017-09-30 09:46:41 +00:00
enum class used for PPR
2018-08-28 12:27:23 +00:00
PPR pr = PPR::ITEM;
new lands for 10.1 -- initial commit
2017-09-30 09:46:41 +00:00
int alpha = hidden ? (it == itKraken ? 0xC0 : 0x40) : 0xF0;
enum class used for PPR
2018-08-28 12:27:23 +00:00
if(c && c->wall == waIcewall) pr = PPR::HIDDEN, alpha = 0x80;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
new lands for 10.1 -- initial commit
2017-09-30 09:46:41 +00:00
queuepolyat(V2, *xsh, darkena(icol, 0, alpha), pr);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
fixed z-fighting when drawing Onyx in 3D
2020-01-28 12:01:28 +00:00
if(it == itZebra) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vx = Vit * spinptick(1500, .5/(ct6+6));
fixed z-fighting when drawing Onyx in 3D
2020-01-28 12:01:28 +00:00
if(GDIM == 3)
Vx = Vx * cpush(2, -1e-3);
queuepolyat(Vx, *xsh, darkena(0x202020, 0, hidden ? 0x40 : 0xF0), PPR::ITEMb);
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
implemented curses
2021-05-02 13:16:29 +00:00
else if(xch == 'o' || xch == 'c' || it == itInventory) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(it == itOrbFire) icol = firecolor(100);
enum class used for PPR
2018-08-28 12:27:23 +00:00
PPR prio = PPR::ITEM;
the new orbs appear (also some more refactoring and updated graphics for Swords)
2017-10-10 12:05:36 +00:00
bool inice = c && c->wall == waIcewall;
enum class used for PPR
2018-08-28 12:27:23 +00:00
if(inice) prio = PPR::HIDDEN;
consistent coloring of Frog-orbs and Impact
2020-02-26 00:20:22 +00:00
color_t icol1 = icol;
factored out orb_auxiliary_color
2020-02-29 19:30:15 +00:00
icol = orb_auxiliary_color(it);
better system of syncing game animations
2018-09-10 15:49:51 +00:00
color_t col = darkena(icol, 0, int(0x80 + 0x70 * sinptick(300)));
Theming Ruins. Implemented Orb of Slaying (also cleaning up some kill/stun/Vizier code).
2018-01-03 20:49:14 +00:00
Orb of Fish has a tail now
2017-10-17 11:13:36 +00:00
if(it == itOrbFish)
Lambdas can't have default arguments until C++14. Arguably this is a reason to upgrade from C++11 to C++14, or to give up completely on `-pedantic`, but I think it's easy enough to eliminate these few nits.
2020-02-23 03:42:52 +00:00
queuepolyat(Vit * spinptick(1500, 0), cgi.shFishTail, col, PPR::ITEM_BELOW);
implemented curses
2021-05-02 13:16:29 +00:00
if(xch == 'c')
queuepolyat(Vit * spinptick(500, 0), cgi.shMoonDisk, darkena(0x801080, 0, hidden ? 0x20 : 0xC0), prio);
else
queuepolyat(Vit, cgi.shDisk, darkena(icol1, 0, inice ? 0x80 : hidden ? 0x20 : 0xC0), prio);
item/monster/wall/land types done with X-macros; flags given too
2019-03-23 15:26:53 +00:00
no inner line drawn in rings
2021-05-09 00:25:05 +00:00
queue_ring(Vit * spinptick(1500, 0), orbshape(iinf[it].orbshape), col, prio);
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
else {
draw_ascii(V, xch, icol, 1);
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
eyes on warrior statues
2019-06-16 13:24:48 +00:00
color_t skincolor = 0xD0C080FF;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void humanoid_eyes(const shiftmatrix& V, color_t ecol, color_t hcol = skincolor) {
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) {
eyes on warrior statues
2019-06-16 13:24:48 +00:00
queuepoly(VHEAD, cgi.shPHeadOnly, hcol);
queuepoly(VHEAD, cgi.shSkullEyes, ecol);
}
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void drawTerraWarrior(const shiftmatrix& V, int t, int hp, double footphase) {
ASCII displayed for terracotta warriors in the ASCII mode
2021-04-15 15:17:01 +00:00
if(!mmmon) {
draw_ascii(V, 'T', gradient(0x202020, 0xFFFFFF, 0, t, 6), 1.5);
return;
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = linf[laTerracotta].color;
more work into Terracotta Army
2017-10-04 19:26:26 +00:00
int bcol = darkena(false ? 0xC0B23E : col, 0, 0xFF);
3d:: added VBODY1, VBODY2, VBODY3 to draw clothing correctly
2019-02-27 18:15:58 +00:00
const transmatrix VBS = otherbodyparts(V, bcol, moDesertman, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPBody, bcol);
if(!peace::on) queuepoly(VBODY * VBS * Mirror, cgi.shPSword, darkena(0xC0C0C0, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shTerraArmor1, darkena(t > 0 ? 0x4040FF : col, 0, 0xFF));
if(hp >= 4) queuepoly(VBODY2 * VBS, cgi.shTerraArmor2, darkena(t > 1 ? 0xC00000 : col, 0, 0xFF));
if(hp >= 2) queuepoly(VBODY3 * VBS, cgi.shTerraArmor3, darkena(t > 2 ? 0x612600 : col, 0, 0xFF));
queuepoly(VHEAD, cgi.shTerraHead, darkena(t > 4 ? 0x202020 : t > 3 ? 0x504040 : col, 0, 0xFF));
queuepoly(VHEAD1, cgi.shPFace, bcol);
eyes on warrior statues
2019-06-16 13:24:48 +00:00
humanoid_eyes(V, 0x400000FF, darkena(col, 0, 0xFF));
new lands for 10.1 -- initial commit
2017-09-30 09:46:41 +00:00
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#endif
new lands for 10.1 -- initial commit
2017-09-30 09:46:41 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void drawPlayer(eMonster m, cell *where, const shiftmatrix& V, color_t col, double footphase, bool stop IS(false)) {
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
charstyle& cs = getcs();
extra guards
2020-10-15 14:33:52 +00:00
#if CAP_COMPLEX2
subdivided game.cpp; split movepcto into separate functions
2019-12-08 18:17:28 +00:00
auto& knighted = camelot::knighted;
extra guards
2020-10-15 14:33:52 +00:00
#else
const bool knighted = false;
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
if(GDIM == 3) {
addradar(V, '@', cs.uicolor >> 8, 0xFF00FF00);
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mapeditor::drawplayer && !mapeditor::drawUserShape(V, mapeditor::sgPlayer, cs.charid, cs.skincolor, where)) {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(cs.charid >= 8) {
/* famililar */
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
if(!mmspatial && !footphase) {
if(stop) return;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shWolfLegs, fc(150, cs.dresscolor, 4));
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWolfBody);
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
if(stop) return;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moWolf, fc(500, cs.dresscolor, 4), footphase);
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shWolfBody, fc(0, cs.skincolor, 0));
queuepoly(VAHEAD, cgi.shFamiliarHead, fc(500, cs.haircolor, 2));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
improved armor models; head lower; configurable human eye color
2019-05-12 19:09:27 +00:00
color_t col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.eyecolor, 3);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shFamiliarEye, col);
queuepoly(VAHEAD * Mirror, cgi.shFamiliarEye, col);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Fixed mapediting floorshapes. Also works nicely for all geometries now. Enum used for shapegroups.
2018-08-27 17:27:35 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(knighted)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shKnightCloak, darkena(cloakcolor(knighted), 1, 0xFF));
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(tortoise::seek())
tortoise::draw(VABODY, tortoise::seekbits, 4, 0);
}
else if(cs.charid >= 6) {
/* dog */
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
if(!mmspatial && !footphase) {
if(stop) return;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shDogBody, fc(0, cs.skincolor, 0));
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shDogTorso);
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
if(stop) return;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moRunDog, fc(500, cs.dresscolor, 4), footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shDogTorso, fc(0, cs.skincolor, 0));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shDogHead, fc(150, cs.haircolor, 2));
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
improved armor models; head lower; configurable human eye color
2019-05-12 19:09:27 +00:00
color_t col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.eyecolor, 3);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shWolf1, col);
queuepoly(VAHEAD, cgi.shWolf2, col);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
the Dog PC's nose is now always black (instead of eye-colored)
2017-12-03 19:10:42 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
color_t colnose = items[itOrbDiscord] ? watercolor(0) : fc(314, 0xFF, 3);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shWolf3, colnose);
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(knighted)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shKnightCloak, darkena(cloakcolor(knighted), 1, 0xFF));
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(tortoise::seek())
tortoise::draw(VABODY, tortoise::seekbits, 4, 0);
}
else if(cs.charid >= 4) {
/* cat */
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
if(!mmspatial && !footphase) {
if(stop) return;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shCatLegs, fc(500, cs.dresscolor, 4));
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shCatBody);
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
if(stop) return;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moRunDog, fc(500, cs.dresscolor, 4), footphase);
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shCatBody, fc(0, cs.skincolor, 0));
queuepoly(VAHEAD, cgi.shCatHead, fc(150, cs.haircolor, 2));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
improved armor models; head lower; configurable human eye color
2019-05-12 19:09:27 +00:00
color_t col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.eyecolor, 3);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD * xpush(.04), cgi.shWolf1, col);
queuepoly(VAHEAD * xpush(.04), cgi.shWolf2, col);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(knighted)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shKnightCloak, darkena(cloakcolor(knighted), 1, 0xFF));
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(tortoise::seek())
tortoise::draw(VABODY, tortoise::seekbits, 4, 0);
}
else {
/* human */
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
ShadowV(V, (cs.charid&1) ? cgi.shFemaleBody : cgi.shPBody);
if(stop) return;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
const transmatrix VBS = otherbodyparts(V, fc(0, cs.skincolor, 0), items[itOrbFish] ? moWaterElemental : moPlayer, footphase);
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
queuepoly(VBODY * VBS, (cs.charid&1) ? cgi.shFemaleBody : cgi.shPBody, fc(0, cs.skincolor, 0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(cs.charid&1)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY1 * VBS, cgi.shFemaleDress, fc(500, cs.dresscolor, 4));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(cs.charid == 2)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shPrinceDress, fc(400, cs.dresscolor, 5));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(cs.charid == 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shPrincessDress, fc(400, cs.dresscolor2, 5));
Graphical effects for the side-orbs.
2017-10-12 10:05:12 +00:00
if(items[itOrbSide3])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, (cs.charid&1) ? cgi.shFerocityF : cgi.shFerocityM, fc(0, cs.skincolor, 0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbHorns]) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shBullHead, items[itOrbDiscord] ? watercolor(0) : 0xFF000030);
queuepoly(VBODY * VBS, cgi.shBullHorn, items[itOrbDiscord] ? watercolor(0) : 0xFF000040);
queuepoly(VBODY * VBS * Mirror, cgi.shBullHorn, items[itOrbDiscord] ? watercolor(0) : 0xFF000040);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Graphical effects for the side-orbs.
2017-10-12 10:05:12 +00:00
if(items[itOrbSide1] && !shmup::on)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS * spin(-M_PI/24), cs.charid >= 2 ? cgi.shSabre : cgi.shPSword, fc(314, cs.swordcolor, 3)); // 3 not colored
Graphical effects for the side-orbs.
2017-10-12 10:05:12 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix VWPN = cs.lefthanded ? VBODY * VBS * Mirror : VBODY * VBS;
left-handed player characters
2018-11-10 17:32:55 +00:00
racing:: trophies
2019-01-07 03:55:21 +00:00
if(peace::on) ;
else if(racing::on) {
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
#if CAP_RACING
racing:: trophies
2019-01-07 03:55:21 +00:00
if(racing::trophy[multi::cpid])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cgi.shTrophy, racing::trophy[multi::cpid]);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
#endif
racing:: trophies
2019-01-07 03:55:21 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(items[itOrbThorns])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cgi.shHedgehogBladePlayer, items[itOrbDiscord] ? watercolor(0) : 0x00FF00FF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(!shmup::on && items[itOrbDiscord])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cs.charid >= 2 ? cgi.shSabre : cgi.shPSword, watercolor(0));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(items[itRevolver])
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cgi.shGunInHand, fc(314, cs.swordcolor, 3)); // 3 not colored
graphics for Crusher/Slaying
2018-01-03 21:32:34 +00:00
else if(items[itOrbSlaying]) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cgi.shFlailTrunk, fc(314, cs.swordcolor, 3));
queuepoly(VWPN, cgi.shHammerHead, fc(314, cs.swordcolor, 3));
graphics for Crusher/Slaying
2018-01-03 21:32:34 +00:00
}
graphical effects for some curses
2021-05-21 23:26:59 +00:00
else if(items[itCurseWeakness]) {
/* no weapon shown */
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(!shmup::on)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cs.charid >= 2 ? cgi.shSabre : cgi.shPSword, fc(314, cs.swordcolor, 3)); // 3 not colored
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(shmup::curtime >= shmup::getPlayer()->nextshot)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cgi.shPKnife, fc(314, cs.swordcolor, 3)); // 3 not colored
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(items[itOrbBeauty]) {
if(cs.charid&1)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, cgi.shFlowerHair, darkena(iinf[itOrbBeauty].color, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VWPN, cgi.shFlowerHand, darkena(iinf[itOrbBeauty].color, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
if(where && where->land == laWildWest) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, cgi.shWestHat1, darkena(cs.swordcolor, 1, 0XFF));
queuepoly(VHEAD2, cgi.shWestHat2, darkena(cs.swordcolor, 0, 0XFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(cheater && !autocheat) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, (cs.charid&1) ? cgi.shGoatHead : cgi.shDemon, darkena(0xFFFF00, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// queuepoly(V, shHood, darkena(0xFF00, 1, 0xFF));
}
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD, cgi.shPFace, fc(500, cs.skincolor, 1));
queuepoly(VHEAD1, (cs.charid&1) ? cgi.shFemaleHair : cgi.shPHead, fc(150, cs.haircolor, 2));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
improved armor models; head lower; configurable human eye color
2019-05-12 19:09:27 +00:00
humanoid_eyes(V, cs.eyecolor, cs.skincolor);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(knighted)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shKnightCloak, darkena(cloakcolor(knighted), 1, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(tortoise::seek())
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
tortoise::draw(VBODY * VBS * ypush(-cgi.crossf*.25), tortoise::seekbits, 4, 0);
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX int wingphase(int period, int phase IS(0)) {
3D:: animation for all birds; fixed a crash on Butterfly drawing
2019-05-16 15:08:12 +00:00
ld t = fractick(period, phase);
reduced the number of bird animation frames
2019-06-18 14:15:57 +00:00
const int WINGS2 = WINGS * 2;
int ti = int(t * WINGS2) % WINGS2;
if(ti > WINGS) ti = WINGS2 - ti;
halved animatedbird space usage
2019-06-18 14:09:54 +00:00
return ti;
3D:: animation for all birds; fixed a crash on Butterfly drawing
2019-05-16 15:08:12 +00:00
}
transmatrix wingmatrix(int period, int phase = 0) {
ld t = fractick(period, phase) * 2 * M_PI;
transmatrix Vwing = Id;
Vwing[1][1] = .85 + .15 * sin(t);
return Vwing;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void drawMimic(eMonster m, cell *where, const shiftmatrix& V, color_t col, double footphase) {
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
charstyle& cs = getcs();
minor refactor to drawMonster
2019-03-30 12:17:51 +00:00
if(mapeditor::drawUserShape(V, mapeditor::sgPlayer, cs.charid, darkena(col, 0, 0x80), where)) return;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(cs.charid >= 8) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shWolfBody, darkena(col, 0, 0xC0));
ShadowV(V, cgi.shWolfBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mmspatial || footphase)
animallegs(VALEGS, moWolf, darkena(col, 0, 0xC0), footphase);
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shWolfLegs, darkena(col, 0, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shFamiliarHead, darkena(col, 0, 0xC0));
queuepoly(VAHEAD, cgi.shFamiliarEye, darkena(col, 0, 0xC0));
queuepoly(VAHEAD * Mirror, cgi.shFamiliarEye, darkena(col, 0, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else if(cs.charid >= 6) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shDogBody);
queuepoly(VAHEAD, cgi.shDogHead, darkena(col, 0, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mmspatial || footphase) {
animallegs(VALEGS, moRunDog, darkena(col, 0, 0xC0), footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shDogTorso, darkena(col, 0, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shDogBody, darkena(col, 0, 0xC0));
queuepoly(VABODY, cgi.shWolf1, darkena(col, 1, 0xC0));
queuepoly(VABODY, cgi.shWolf2, darkena(col, 1, 0xC0));
queuepoly(VABODY, cgi.shWolf3, darkena(col, 1, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else if(cs.charid >= 4) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shCatBody);
queuepoly(VABODY, cgi.shCatBody, darkena(col, 0, 0xC0));
queuepoly(VAHEAD, cgi.shCatHead, darkena(col, 0, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mmspatial || footphase)
animallegs(VALEGS, moRunDog, darkena(col, 0, 0xC0), footphase);
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shCatLegs, darkena(col, 0, 0xC0));
queuepoly(VAHEAD * xpush(.04), cgi.shWolf1, darkena(col, 1, 0xC0));
queuepoly(VAHEAD * xpush(.04), cgi.shWolf2, darkena(col, 1, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0x40), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, (cs.charid&1) ? cgi.shFemaleBody : cgi.shPBody, darkena(col, 0, 0X80));
wobbling added to moving humanoid characters
2018-12-23 13:00:52 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(!shmup::on) {
bool emp = items[itOrbEmpathy] && m != moShadow;
if(items[itOrbThorns] && emp)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shHedgehogBladePlayer, darkena(col, 0, 0x40));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(items[itOrbSide1] && !shmup::on)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS * spin(-M_PI/24), cs.charid >= 2 ? cgi.shSabre : cgi.shPSword, darkena(col, 0, 0x40));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(items[itOrbSide3] && emp)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, (cs.charid&1) ? cgi.shFerocityF : cgi.shFerocityM, darkena(col, 0, 0x40));
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, (cs.charid >= 2 ? cgi.shSabre : cgi.shPSword), darkena(col, 0, 0XC0));
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else if(!where || shmup::curtime >= shmup::getPlayer()->nextshot)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPKnife, darkena(col, 0, 0XC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
extra guards
2020-10-15 14:33:52 +00:00
#if CAP_COMPLEX2
subdivided game.cpp; split movepcto into separate functions
2019-12-08 18:17:28 +00:00
if(camelot::knighted)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY3 * VBS, cgi.shKnightCloak, darkena(col, 1, 0xC0));
extra guards
2020-10-15 14:33:52 +00:00
#endif
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, (cs.charid&1) ? cgi.shFemaleHair : cgi.shPHead, darkena(col, 1, 0XC0));
queuepoly(VHEAD, cgi.shPFace, darkena(col, 0, 0XC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(cs.charid&1)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY1 * VBS, cgi.shFemaleDress, darkena(col, 1, 0XC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(cs.charid == 2)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shPrinceDress, darkena(col, 1, 0XC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(cs.charid == 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shPrincessDress, darkena(col, 1, 0XC0));
3D:: added missing eyes and faces in drawMimic
2019-05-20 13:28:20 +00:00
humanoid_eyes(V, 0xFF, darkena(col, 0, 0x40));
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX bool drawMonsterType(eMonster m, cell *where, const shiftmatrix& V1, color_t col, double footphase, color_t asciicol) {
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
#if MAXMDIM >= 4
display other players in 2.5D radar
2020-08-01 14:48:08 +00:00
if(GDIM == 3 && asciicol != NOCOLOR) {
fixed the monster color in the minimap for Dragons etc
2019-06-24 10:57:00 +00:00
addradar(V1, minf[m].glyph, asciicol, isFriendly(m) ? 0x00FF00FF : 0xFF0000FF);
display other players in 2.5D radar
2020-08-01 14:48:08 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
#endif
char xch = minf[m].glyph;
3d:: make monster facing correct, based on FACEUP/FACESIDE
2019-04-20 23:08:27 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V = V1;
sl2:: 3d-models
2019-08-24 12:49:49 +00:00
if(WDIM == 3 && (classflag(m) & CF_FACE_UP) && where && !hybri) V = V1 * cspin(0, 2, M_PI/2);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
#if CAP_SHAPES
world turtles
2020-03-02 02:06:15 +00:00
if(among(m, moTortoise, moWorldTurtle) && where && where->stuntime >= 3)
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
drawStunStars(V, where->stuntime-2);
ASCII monsters: don't draw stun stars for Mutant Ivy
2021-07-17 09:24:38 +00:00
else if (among(m, moTortoise, moWorldTurtle, moMutant) || m == moPlayer || (where && !where->stuntime)) ;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else if(where && !(isMetalBeast(m) && where->stuntime == 1))
drawStunStars(V, where->stuntime);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mapeditor::drawUserShape(V, mapeditor::sgMonster, m, darkena(col, 0, 0xFF), where))
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
#endif
if(!mmmon || !CAP_SHAPES) {
draw_ascii(V1, xch, asciicol, 1.5);
return true;
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
#if CAP_SHAPES
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
switch(m) {
case moTortoise: {
int bits = where ? tortoise::getb(where) : tortoise::last;
tortoise::draw(V, bits, 0, where ? where->stuntime : 0);
if(tortoise::seek() && !tortoise::diff(bits) && where)
no inner line drawn in rings
2021-05-09 00:25:05 +00:00
queue_ring(V, cgi.shRing, darkena(0xFFFFFF, 0, 0x80 + 0x70 * sintick(200)), PPR::ITEM);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
world turtles
2020-03-02 02:06:15 +00:00
case moWorldTurtle: {
tortoise::draw(V, -1, 0, where ? where->stuntime : 0);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
world turtles
2020-03-02 02:06:15 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moPlayer:
drawPlayer(m, where, V, col, footphase);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
minor refactor to drawMonster
2019-03-30 12:17:51 +00:00
case moMimic: case moShadow: case moIllusion:
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
drawMimic(m, where, V, col, footphase);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moBullet:
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shKnife);
queuepoly(VBODY * spin(-M_PI/4), cgi.shKnife, getcs().swordcolor);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moKnight: case moKnightMoved: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
const transmatrix VBS = otherbodyparts(V, darkena(0xC0C0A0, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPBody, darkena(0xC0C0A0, 0, 0xC0));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(!racing::on)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPSword, darkena(0xFFFF00, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shKnightArmor, darkena(0xD0D0D0, 1, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
color_t col;
if(!eubinary && where && where->master->alt)
col = cloakcolor(roundTableRadius(where));
else
col = cloakcolor(newRoundTableRadius());
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shKnightCloak, darkena(col, 1, 0xFF));
queuepoly(VHEAD1, cgi.shPHead, darkena(0x703800, 1, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xC0C0A0, 0, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moGolem: case moGolemMoved: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0XC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, cgi.shGolemhead, darkena(col, 1, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xC0C000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moEvilGolem: case moIceGolem: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 2, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, cgi.shGolemhead, darkena(col, 1, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFF0000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Mimics/Illusions/Shadows wear knight cloak when appropriate
2017-10-14 17:29:20 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moFalsePrincess: case moRoseLady: case moRoseBeauty: {
princess:
bool girl = princessgender() == GEN_F;
bool evil = !isPrincess(m);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
int facecolor = evil ? 0xC0B090FF : 0xD0C080FF;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, girl ? cgi.shFemaleBody : cgi.shPBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
const transmatrix VBS = otherbodyparts(V, facecolor, m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, girl ? cgi.shFemaleBody : cgi.shPBody, facecolor);
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moPrincessArmed)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS * Mirror, vid.cs.charid < 2 ? cgi.shSabre : cgi.shPSword, 0xFFFFFFFF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if((m == moFalsePrincess || m == moRoseBeauty) && where && where->cpdist == 1)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPKnife, 0xFFFFFFFF);
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moRoseLady) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPKnife, 0xFFFFFFFF);
queuepoly(VBODY * VBS * Mirror, cgi.shPKnife, 0xFFFFFFFF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(girl) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY1 * VBS, cgi.shFemaleDress, evil ? 0xC000C0FF : 0x00C000FF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(vid.cs.charid < 2)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shPrincessDress, (evil ? 0xC040C0C0 : 0x8080FFC0) | UNTRANS);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else {
if(vid.cs.charid < 2)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY1 * VBS, cgi.shPrinceDress, evil ? 0x802080FF : 0x404040FF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moRoseLady) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
// queuepoly(V, girl ? cgi.shGoatHead : cgi.shDemon, 0x800000FF);
3d:: Princess hair darker to make it stand out better in 3d
2019-05-12 18:11:05 +00:00
// make her hair a bit darker to stand out in 3D
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepoly(VHEAD1, girl ? cgi.shFemaleHair : cgi.shPHead, evil ? 0x500050FF : GDIM == 3 ? 0x666A64FF : 0x332A22FF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else if(m == moRoseBeauty) {
if(girl) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, cgi.shBeautyHair, 0xF0A0D0FF);
queuepoly(VHEAD2, cgi.shFlowerHair, 0xC00000FF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, cgi.shPHead, 0xF0A0D0FF);
fixed the Handsome Gardener's Flower
2020-04-17 13:03:23 +00:00
queuepoly(VBODY * VBS, cgi.shFlowerHand, 0xC00000FF);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shSuspenders, 0xC00000FF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
}
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, girl ? cgi.shFemaleHair : cgi.shPHead,
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
evil ? 0xC00000FF : 0x332A22FF);
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD, cgi.shPFace, facecolor);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, evil ? 0x0000C0FF : 0x00C000FF, facecolor);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moWolf: case moRedFox: case moWolfMoved: case moLavaWolf: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWolfBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mmspatial || footphase)
animallegs(VALEGS, moWolf, darkena(col, 0, 0xFF), footphase);
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shWolfLegs, darkena(col, 0, 0xFF));
queuepoly(VABODY, cgi.shWolfBody, darkena(col, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moRedFox) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shFoxTail1, darkena(col, 0, 0xFF));
queuepoly(VABODY, cgi.shFoxTail2, darkena(0xFFFFFF, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shWolfHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, cgi.shWolfEyes, darkena(col, 3, 0xFF));
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shFamiliarEye, 0xFF);
queuepoly(VAHEAD * Mirror, cgi.shFamiliarEye, 0xFF);
3d:: correct eyes
2019-05-11 13:11:55 +00:00
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moReptile: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shReptileBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moReptile, darkena(col, 0, 0xFF), footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shReptileBody, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, cgi.shReptileHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, cgi.shReptileEye, darkena(col, 3, 0xFF));
queuepoly(VAHEAD * Mirror, cgi.shReptileEye, darkena(col, 3, 0xFF));
do not show Reptile Tail
2019-09-28 12:18:23 +00:00
if(GDIM == 2) queuepoly(VABODY, cgi.shReptileTail, darkena(col, 2, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moSalamander: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shReptileBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moReptile, darkena(0xD00000, 1, 0xFF), footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shReptileBody, darkena(0xD00000, 0, 0xFF));
queuepoly(VAHEAD, cgi.shReptileHead, darkena(0xD00000, 1, 0xFF));
queuepoly(VAHEAD, cgi.shReptileEye, darkena(0xD00000, 0, 0xFF));
queuepoly(VAHEAD * Mirror, cgi.shReptileEye, darkena(0xD00000, 0, 0xFF));
queuepoly(VABODY, cgi.shReptileTail, darkena(0xD08000, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
vector graphics of Frogs and Pikes
2020-02-26 00:19:49 +00:00
case moFrog: case moPhaser: case moVaulter: {
ShadowV(V, cgi.shFrogBody);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VL = GDIM == 3 ? V : mmscale(V, cgi.ALEG0);
vector graphics of Frogs and Pikes
2020-02-26 00:19:49 +00:00
color_t xcolor = darkena(0xFF0000, 1, 0xFF);
int alpha = (m == moPhaser ? 0xC0 : 0xFF);
if(footphase) {
colored Frog Jump Legs
2020-02-28 23:05:06 +00:00
queuepoly(VL, cgi.shFrogJumpFoot, darkena(col, 0, alpha));
queuepoly(VL * Mirror, cgi.shFrogJumpFoot, darkena(col, 0, alpha));
queuepoly(VALEGS, cgi.shFrogJumpLeg, xcolor);
queuepoly(VALEGS * Mirror, cgi.shFrogJumpLeg, xcolor);
vector graphics of Frogs and Pikes
2020-02-26 00:19:49 +00:00
}
else {
queuepoly(VL, cgi.shFrogRearFoot, darkena(col, 0, alpha));
queuepoly(VL * Mirror, cgi.shFrogRearFoot, darkena(col, 0, alpha));
queuepoly(VALEGS, cgi.shFrogRearLeg, xcolor);
queuepoly(VALEGS * Mirror, cgi.shFrogRearLeg, xcolor);
queuepoly(VALEGS, cgi.shFrogRearLeg2, xcolor);
queuepoly(VALEGS * Mirror, cgi.shFrogRearLeg2, xcolor);
}
queuepoly(VL, cgi.shFrogFrontFoot, darkena(col, 0, alpha));
queuepoly(VL * Mirror, cgi.shFrogFrontFoot, darkena(col, 0, alpha));
queuepoly(VALEGS, cgi.shFrogFrontLeg, xcolor);
queuepoly(VALEGS * Mirror, cgi.shFrogFrontLeg, xcolor);
queuepoly(VABODY, cgi.shFrogBody, darkena(col, 0, alpha));
queuepoly(VABODY, cgi.shFrogEye, darkena(col, 3, alpha));
queuepoly(VABODY * Mirror, cgi.shFrogEye, darkena(col, 3, alpha));
queuepoly(VABODY, cgi.shFrogStripe, xcolor);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
vector graphics of Frogs and Pikes
2020-02-26 00:19:49 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moVineBeast: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWolfBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mmspatial || footphase)
animallegs(VALEGS, moWolf, 0x00FF00FF, footphase);
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shWolfLegs, 0x00FF00FF);
queuepoly(VABODY, cgi.shWolfBody, darkena(col, 1, 0xFF));
queuepoly(VAHEAD, cgi.shWolfHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, cgi.shWolfEyes, 0xFF0000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moMouse: case moMouseMoved: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shMouse, darkena(col, 0, 0xFF));
queuepoly(VALEGS, cgi.shMouseLegs, darkena(col, 1, 0xFF));
queuepoly(VALEGS, cgi.shMouseEyes, 0xFF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moRunDog: case moHunterDog: case moHunterGuard: case moHunterChanging: case moFallingDog: {
if(!mmspatial && !footphase)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shDogBody, darkena(col, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shDogTorso);
queuepoly(VABODY, cgi.shDogTorso, darkena(col, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moRunDog, m == moFallingDog ? 0xFFFFFFFF : darkena(col, 0, 0xFF), footphase);
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shDogHead, darkena(col, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
{
dynamicval<color_t> dp(poly_outline);
int eyecolor = 0x202020;
bool redeyes = false;
if(m == moHunterDog) eyecolor = 0xFF0000, redeyes = true;
if(m == moHunterGuard) eyecolor = 0xFF6000, redeyes = true;
if(m == moHunterChanging) eyecolor = 0xFFFF00, redeyes = true;
int eyes = darkena(eyecolor, 0, 0xFF);
if(redeyes) poly_outline = eyes;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shWolf1, eyes).flags |= POLY_FORCEWIDE;
queuepoly(VAHEAD, cgi.shWolf2, eyes).flags |= POLY_FORCEWIDE;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shWolf3, darkena(m == moRunDog ? 0x202020 : 0x000000, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moOrangeDog: {
if(!mmspatial && !footphase)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shDogBody, darkena(0xFFFFFF, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shDogTorso);
3D:: dog stripes
2019-06-01 17:50:17 +00:00
if(GDIM == 2) queuepoly(VABODY, cgi.shDogTorso, darkena(0xFFFFFF, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
animallegs(VALEGS, moRunDog, darkena(0xFFFFFF, 0, 0xFF), footphase);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shDogHead, darkena(0xFFFFFF, 0, 0xFF));
3D:: dog stripes
2019-06-01 17:50:17 +00:00
queuepoly(VABODY, cgi.shDogStripes, GDIM == 2 ? darkena(0x303030, 0, 0xFF) : 0xFFFFFFFF);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shWolf1, darkena(0x202020, 0, 0xFF));
queuepoly(VAHEAD, cgi.shWolf2, darkena(0x202020, 0, 0xFF));
queuepoly(VAHEAD, cgi.shWolf3, darkena(0x202020, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
world turtles
2020-03-02 02:06:15 +00:00
case moShark: case moGreaterShark: case moCShark:
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VFISH, cgi.shShark, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
vector graphics of Frogs and Pikes
2020-02-26 00:19:49 +00:00
case moPike:
queuepoly(VFISH, cgi.shPikeBody, darkena(col, 0, 0xFF));
queuepoly(VFISH, cgi.shPikeEye, darkena(col, 2, 0xFF));
queuepoly(VFISH * Mirror, cgi.shPikeEye, darkena(col, 2, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
minor refactor to drawMonster
2019-03-30 12:17:51 +00:00
case moEagle: case moParrot: case moBomberbird: case moAlbatross:
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moTameBomberbird: case moWindCrow: case moTameBomberbirdMoved:
animated 3D birds
2019-04-22 12:41:14 +00:00
case moSandBird: case moAcidBird: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shEagle);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
auto& sh = GDIM == 3 ? cgi.shAnimatedEagle[wingphase(200)] : cgi.shEagle;
if(m == moParrot && GDIM == 3)
animated 3D birds
2019-04-22 12:41:14 +00:00
queuepolyat(VBIRD, sh, darkena(col, 0, 0xFF), PPR::SUPERLINE);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else
animated 3D birds
2019-04-22 12:41:14 +00:00
queuepoly(VBIRD, sh, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
animated 3D birds
2019-04-22 12:41:14 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moSparrowhawk: case moWestHawk: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shHawk);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
auto& sh = GDIM == 3 ? cgi.shAnimatedHawk[wingphase(200)] : cgi.shHawk;
3D:: animation for all birds; fixed a crash on Butterfly drawing
2019-05-16 15:08:12 +00:00
queuepoly(VBIRD, sh, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moButterfly: {
3D:: animation for all birds; fixed a crash on Butterfly drawing
2019-05-16 15:08:12 +00:00
transmatrix Vwing = wingmatrix(100);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V * Vwing, cgi.shButterflyWing);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 2)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBIRD * Vwing, cgi.shButterflyWing, darkena(col, 0, 0xFF));
3D:: animation for all birds; fixed a crash on Butterfly drawing
2019-05-16 15:08:12 +00:00
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBIRD, cgi.shAnimatedButterfly[wingphase(100)], darkena(col, 0, 0xFF));
queuepoly(VBIRD, cgi.shButterflyBody, darkena(col, 2, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moGadfly: {
3D:: animation for all birds; fixed a crash on Butterfly drawing
2019-05-16 15:08:12 +00:00
transmatrix Vwing = wingmatrix(100);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V * Vwing, cgi.shGadflyWing);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepoly(VBIRD * Vwing, GDIM == 2 ? cgi.shGadflyWing : cgi.shAnimatedGadfly[wingphase(100)], darkena(col, 0, 0xFF));
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBIRD, cgi.shGadflyBody, darkena(col, 1, 0xFF));
queuepoly(VBIRD, cgi.shGadflyEye, darkena(col, 2, 0xFF));
queuepoly(VBIRD * Mirror, cgi.shGadflyEye, darkena(col, 2, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moVampire: case moBat: {
// vampires have no shadow and no mirror images
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(m == moBat) ShadowV(V, cgi.shBatWings);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moBat || !inmirrorcount) {
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepoly(VBIRD, GDIM == 2 ? cgi.shBatWings : cgi.shAnimatedBat[wingphase(100)], darkena(0x303030, 0, 0xFF));
queuepoly(VBIRD, GDIM == 2 ? cgi.shBatBody : cgi.shAnimatedBat2[wingphase(100)], darkena(0x606060, 0, 0xFF));
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
}
/* queuepoly(V, cgi.shBatMouth, darkena(0xC00000, 0, 0xFF));
queuepoly(V, cgi.shBatFang, darkena(0xFFC0C0, 0, 0xFF));
queuepoly(V*Mirror, cgi.shBatFang, darkena(0xFFC0C0, 0, 0xFF));
queuepoly(V, cgi.shBatEye, darkena(00000000, 0, 0xFF));
queuepoly(V*Mirror, cgi.shBatEye, darkena(00000000, 0, 0xFF)); */
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moGargoyle: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shGargoyleWings);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepoly(VBIRD, GDIM == 2 ? cgi.shGargoyleWings : cgi.shAnimatedGargoyle[wingphase(300)], darkena(col, 0, 0xD0));
queuepoly(VBIRD, GDIM == 2 ? cgi.shGargoyleBody : cgi.shAnimatedGargoyle2[wingphase(300)], darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moZombie: {
int c = darkena(col, where && where->land == laHalloween ? 1 : 0, 0xFF);
const transmatrix VBS = otherbodyparts(V, c, m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBODY * VBS, cgi.shPBody, c);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moTerraWarrior: {
drawTerraWarrior(V, 7, (where ? where->hitpoints : 7), footphase);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moVariantWarrior: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, darkena(0xFFD500, 0, 0xF0));
if(!peace::on) queuepoly(VBS, cgi.shPSword, 0xFFFF00FF);
queuepoly(VHEAD, cgi.shHood, 0x008000FF);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFFFF00FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moDesertman: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBS, cgi.shPSword, 0xFFFF00FF);
queuepoly(VHEAD, cgi.shHood, 0xD0D000C0 | UNTRANS);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x301800FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moMonk: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shRaiderBody);
queuepoly(VBODY * VBS, cgi.shRaiderBody, darkena(col, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shRaiderShirt, darkena(col, 2, 0xFF));
if(!peace::on) queuepoly(VBODY * VBS, cgi.shPKnife, 0xFFC0C0C0);
queuepoly(VBODY2 * VBS, cgi.shRaiderArmor, darkena(col, 1, 0xFF));
queuepolyat(VBODY3 * VBS, cgi.shRatCape2, darkena(col, 2, 0xFF), PPR::MONSTER_ARMOR0);
queuepoly(VHEAD1, cgi.shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xC0C0A0, 0, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moCrusher: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shRaiderBody);
queuepoly(VBODY * VBS, cgi.shRaiderBody, darkena(col, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shRaiderShirt, darkena(col, 2, 0xFF));
queuepoly(VBODY2 * VBS, cgi.shRaiderArmor, darkena(col, 1, 0xFF));
queuepoly(VBODY * VBS, cgi.shFlailTrunk, darkena(col, 1, 0XFF));
queuepoly(VBODY1 * VBS, cgi.shHammerHead, darkena(col, 0, 0XFF));
queuepoly(VHEAD1, cgi.shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xC0C0A0, 0, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moPair: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shRaiderBody);
queuepoly(VBODY * VBS, cgi.shRaiderBody, darkena(col, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shRaiderShirt, darkena(col, 2, 0xFF));
queuepoly(VBODY2 * VBS, cgi.shRaiderArmor, darkena(col, 1, 0xFF));
queuepoly(VBODY * VBS, cgi.shPickAxe, darkena(0xA0A0A0, 0, 0XFF));
queuepoly(VHEAD1, cgi.shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xC0C0A0, 0, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moAltDemon: case moHexDemon: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shRaiderBody);
queuepoly(VBODY * VBS, cgi.shRaiderBody, darkena(col, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shRaiderShirt, darkena(col, 2, 0xFF));
queuepoly(VBODY2 * VBS, cgi.shRaiderArmor, darkena(col, 1, 0xFF));
if(!peace::on) queuepoly(VBODY * VBS, cgi.shPSword, 0xFFD0D0D0);
queuepoly(VHEAD1, cgi.shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xC0C0A0, 0, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moSkeleton: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(0xFFFFFF, 0, 0xFF), moSkeleton, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shSkeletonBody, darkena(0xFFFFFF, 0, 0xFF));
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 2) queuepoly(VHEAD, cgi.shSkull, darkena(0xFFFFFF, 0, 0xFF));
if(GDIM == 2) queuepoly(VHEAD1, cgi.shSkullEyes, 0x000000FF);
fixed skulls' eyes in 2D
2019-05-13 12:22:20 +00:00
humanoid_eyes(V, 0x000000FF, 0xFFFFFFFF);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shSkeletonBody);
queuepoly(VBS, cgi.shSabre, 0xFFFFFFFF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moPalace: case moFatGuard: case moVizier: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
3d:: added VBODY1, VBODY2, VBODY3 to draw clothing correctly
2019-02-27 18:15:58 +00:00
const transmatrix VBS = otherbodyparts(V, darkena(0xFFD500, 0, 0xFF), m, footphase);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(m == moFatGuard) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shFatBody, darkena(0xC06000, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
col = 0xFFFFFF;
if(!where || where->hitpoints >= 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY1 * VBS, cgi.shKnightCloak, darkena(0xFFC0C0, 1, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY * VBS, cgi.shPBody, darkena(0xFFD500, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shKnightArmor, m == moVizier ? 0xC000C0FF :
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
darkena(0x00C000, 1, 0xFF));
if(where && where->hitpoints >= 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY2 * VBS, cgi.shKnightCloak, m == moVizier ? 0x800080Ff :
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
darkena(0x00FF00, 1, 0xFF));
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, cgi.shTurban1, darkena(col, 1, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!where || where->hitpoints >= 2)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD2, cgi.shTurban2, darkena(col, 0, 0xFF));
queuepoly(VBODY * VBS, cgi.shSabre, 0xFFFFFFFF);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x301800FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moCrystalSage: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, 0xFFFFFFFF, m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, 0xFFFFFFFF);
queuepoly(VHEAD1, cgi.shPHead, 0xFFFFFFFF);
queuepoly(VHEAD, cgi.shPFace, 0xFFFFFFFF);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFFFFFFFF, 0xC0C0C0FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moHedge: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shPBody, darkena(col, 0, 0xFF));
queuepoly(VBS, cgi.shHedgehogBlade, 0xC0C0C0FF);
queuepoly(VHEAD1, cgi.shPHead, 0x804000FF);
queuepoly(VHEAD, cgi.shPFace, 0xF09000FF);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x00D000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moYeti: case moMonkey: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, cgi.shPHead, darkena(col, 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moResearcher: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, darkena(0xFFFF00, 0, 0xC0));
queuepoly(VHEAD, cgi.shAztecHead, darkena(col, 0, 0xFF));
queuepoly(VHEAD1, cgi.shAztecCap, darkena(0xC000C0, 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moFamiliar: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWolfBody);
queuepoly(VABODY, cgi.shWolfBody, darkena(0xA03000, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(mmspatial || footphase)
animallegs(VALEGS, moWolf, darkena(0xC04000, 0, 0xFF), footphase);
else
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VALEGS, cgi.shWolfLegs, darkena(0xC04000, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shFamiliarHead, darkena(0xC04000, 0, 0xFF));
// queuepoly(V, cgi.shCatLegs, darkena(0x902000, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(true) {
Fix UB drawing Familiar's eye
2021-07-12 02:56:29 +00:00
queuepoly(VAHEAD, cgi.shFamiliarEye, darkena(0xFFFF00, 0, 0xFF));
queuepoly(VAHEAD * Mirror, cgi.shFamiliarEye, darkena(0xFFFF00, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
a HUD for square screens; graphical images in HUD
2017-05-28 22:16:17 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moRanger: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBS, cgi.shPSword, darkena(col, 0, 0xFF));
queuepoly(VHEAD, cgi.shArmor, darkena(col, 1, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moNarciss: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shFlowerHand, darkena(col, 0, 0xFF));
queuepoly(VBS, cgi.shPBody, 0xFFE080FF);
if(!peace::on) queuepoly(VBS, cgi.shPKnife, 0xC0C0C0FF);
queuepoly(VHEAD, cgi.shPFace, 0xFFE080FF);
queuepoly(VHEAD1, cgi.shPHead, 0x806A00FF);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moMirrorSpirit: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0x90), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shPBody, darkena(col, 0, 0x90));
if(!peace::on) queuepoly(VBS * Mirror, cgi.shPSword, darkena(col, 0, 0xD0));
queuepoly(VHEAD1, cgi.shPHead, darkena(col, 1, 0x90));
queuepoly(VHEAD2, cgi.shPFace, darkena(col, 1, 0x90));
queuepoly(VHEAD, cgi.shArmor, darkena(col, 0, 0xC0));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFFFFFFFF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moJiangshi: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shJiangShi);
fixed the vertical placement of Jiangshi
2019-06-24 10:59:28 +00:00
auto z2 = WDIM == 3 ? 0 : GDIM == 3 ? -abs(sin(footphase * M_PI * 2)) * cgi.human_height/3 : geom3::lev_to_factor(abs(sin(footphase * M_PI * 2)) * cgi.human_height);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
auto V0 = V;
auto V = mmscale(V0, z2);
otherbodyparts(V, darkena(col, 0, 0xFF), m, m == moJiangshi ? 0 : footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY, cgi.shJiangShi, darkena(col, 0, 0xFF));
queuepoly(VBODY1, cgi.shJiangShiDress, darkena(0x202020, 0, 0xFF));
queuepoly(VHEAD, cgi.shTerraHead, darkena(0x101010, 0, 0xFF));
queuepoly(VHEAD1, cgi.shPFace, darkena(col, 0, 0xFF));
queuepoly(VHEAD2, cgi.shJiangShiCap1, darkena(0x800000, 0, 0xFF));
queuepoly(VHEAD3, cgi.shJiangShiCap2, darkena(0x400000, 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moGhost: case moSeep: case moFriendlyGhost: {
if(m == moFriendlyGhost) col = fghostcolor(where);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepolyat(VGHOST, cgi.shGhost, darkena(col, 0, m == moFriendlyGhost ? 0xC0 : 0x80), GDIM == 3 ? PPR::SUPERLINE : cgi.shGhost.prio);
queuepolyat(VGHOST, cgi.shGhostEyes, 0xFF, GDIM == 3 ? PPR::SUPERLINE : cgi.shEyes.prio);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moVineSpirit: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VGHOST, cgi.shGhost, 0xD0D0D0C0 | UNTRANS);
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepolyat(VGHOST, cgi.shGhostEyes, 0xFF0000FF, GDIM == 3 ? PPR::SUPERLINE : cgi.shGhostEyes.prio);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moFireFairy: {
col = firecolor(0);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shFemaleBody);
queuepoly(VBS, cgi.shFemaleBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, cgi.shWitchHair, darkena(col, 1, 0xFF));
queuepoly(VHEAD1, cgi.shPFace, darkena(col, 0, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, darkena(col, 1, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Rusalka/Topielec graphics
2020-02-26 00:20:33 +00:00
case moRusalka: {
col = watercolor(0);
bool girl = princessgender() == GEN_F;
if(girl) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, col, m, footphase);
Rusalka/Topielec graphics
2020-02-26 00:20:33 +00:00
ShadowV(V, cgi.shFemaleBody);
queuepoly(VBS, cgi.shFemaleBody, watercolor(100));
queuepoly(VHEAD1, cgi.shFemaleHair, watercolor(150));
// queuepoly(VHEAD2, cgi.shFlowerHair, watercolor(50));
// queuepoly(VHEAD, cgi.shWitchHair, watercolor(150));
queuepoly(VHEAD1, cgi.shPFace, watercolor(200));
queuepoly(VHEAD1, cgi.shWightCloak, watercolor(50) & 0xFFFFFF80);
humanoid_eyes(V, col | 0xFF);
}
else {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, col, m, footphase);
Rusalka/Topielec graphics
2020-02-26 00:20:33 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, watercolor(100));
queuepoly(VBS, cgi.shSuspenders, watercolor(150));
queuepoly(VHEAD1, cgi.shPHead, watercolor(50));
queuepoly(VHEAD1, cgi.shPFace, watercolor(200));
queuepoly(VHEAD1, cgi.shWightCloak, watercolor(50) & 0xFFFFFF80);
humanoid_eyes(V, col | 0xFF);
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Rusalka/Topielec graphics
2020-02-26 00:20:33 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moSlime: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VFISH, cgi.shSlime, darkena(col, 0, 0x80));
queuepoly(VSLIMEEYE, cgi.shSlimeEyes, 0xFF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
fixed Slime display
2019-04-05 12:41:21 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
case moKrakenH: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VFISH, cgi.shKrakenHead, darkena(col, 0, 0xD0));
queuepoly(VFISH, cgi.shKrakenEye, 0xFFFFFFC0 | UNTRANS);
queuepoly(VFISH, cgi.shKrakenEye2, 0xC0);
queuepoly(VFISH * Mirror, cgi.shKrakenEye, 0xFFFFFFC0 | UNTRANS);
queuepoly(VFISH * Mirror, cgi.shKrakenEye2, 0xC0);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moKrakenT: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VFISH, cgi.shSeaTentacle, darkena(col, 0, 0xD0));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moCultist: case moPyroCultist: case moCultistLeader: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBS, cgi.shPSword, darkena(col, 2, 0xFF));
queuepoly(VHEAD, cgi.shHood, darkena(col, 1, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x00FF00FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moPirate: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, darkena(0x404040, 0, 0xFF));
queuepoly(VBS, cgi.shPirateHook, darkena(0xD0D0D0, 0, 0xFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xFFFF80, 0, 0xFF));
queuepoly(VHEAD1, cgi.shEyepatch, darkena(0, 0, 0xC0));
queuepoly(VHEAD2, cgi.shPirateHood, darkena(col, 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moRatling: case moRatlingAvenger: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shYeti);
queuepoly(VLEG, cgi.shRatTail, darkena(col, 0, 0xFF));
queuepoly(VBODY * VBS, cgi.shYeti, darkena(col, 1, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
float t = sintick(1000, where ? where->cpdist*M_PI : 0);
int eyecol = t > 0.92 ? 0xFF0000 : 0;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 2) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD, cgi.shRatHead, darkena(col, 0, 0xFF));
queuepoly(VHEAD, cgi.shWolf1, darkena(eyecol, 0, 0xFF));
queuepoly(VHEAD, cgi.shWolf2, darkena(eyecol, 0, 0xFF));
queuepoly(VHEAD, cgi.shWolf3, darkena(0x202020, 0, 0xFF));
if(m == moRatlingAvenger) queuepoly(VHEAD1, cgi.shRatCape1, 0x303030FF);
3d:: redone ratling head
2019-05-12 18:11:17 +00:00
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
3d:: redone ratling head
2019-05-12 18:11:17 +00:00
else {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V1 = V * zpush(cgi.AHEAD - zc(0.4) - zc(0.98) + cgi.HEAD); // * cpush(0, cgi.scalefactor * (-0.1));
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V1, cgi.shRatHead, darkena(col, 0, 0xFF));
3D:: Ratlings improved
2019-05-24 21:49:23 +00:00
/*
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V1, cgi.shFamiliarEye, darkena(eyecol, 0, 0xFF));
queuepoly(V1 * Mirror, cgi.shFamiliarEye, darkena(eyecol, 0, 0xFF));
queuepoly(V1, cgi.shWolfEyes, darkena(col, 3, 0xFF));
3D:: Ratlings improved
2019-05-24 21:49:23 +00:00
*/
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V1, cgi.shRatEye1, darkena(eyecol, 0, 0xFF));
queuepoly(V1, cgi.shRatEye2, darkena(eyecol, 0, 0xFF));
queuepoly(V1, cgi.shRatEye3, darkena(0x202020, 0, 0xFF));
if(m == moRatlingAvenger) queuepoly(V1, cgi.shRatCape1, 0x303030FF);
3d:: redone ratling head
2019-05-12 18:11:17 +00:00
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moRatlingAvenger) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBODY1 * VBS, cgi.shRatCape2, 0x484848FF);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moViking: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBODY * VBS, cgi.shPBody, darkena(0xE00000, 0, 0xFF));
if(!peace::on) queuepoly(VBODY * VBS, cgi.shPSword, darkena(0xD0D0D0, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shKnightCloak, darkena(0x404040, 0, 0xFF));
queuepoly(VHEAD, cgi.shVikingHelmet, darkena(0xC0C0C0, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xFFFF80, 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moOutlaw: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBODY * VBS, cgi.shPBody, darkena(col, 0, 0xFF));
queuepoly(VBODY1 * VBS, cgi.shKnightCloak, darkena(col, 1, 0xFF));
queuepoly(VHEAD1, cgi.shWestHat1, darkena(col, 2, 0XFF));
queuepoly(VHEAD2, cgi.shWestHat2, darkena(col, 1, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xFFFF80, 0, 0xFF));
queuepoly(VBODY * VBS, cgi.shGunInHand, darkena(col, 1, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moNecromancer: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shPBody);
queuepoly(VBS, cgi.shPBody, 0xC00000C0 | UNTRANS);
queuepoly(VHEAD, cgi.shHood, darkena(col, 1, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFF0000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moDraugr: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, 0x483828D0 | UNTRANS, m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shPBody, 0x483828D0 | UNTRANS);
queuepoly(VBS, cgi.shPSword, 0xFFFFD0A0 | UNTRANS);
queuepoly(VHEAD, cgi.shPHead, 0x483828D0 | UNTRANS);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFF0000FF, 0x483828FF);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
// queuepoly(V, cgi.shSkull, 0xC06020D0);
//queuepoly(V, cgi.shSkullEyes, 0x000000D0);
// queuepoly(V, cgi.shWightCloak, 0xC0A080A0);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
int b = where ? where->cpdist : 0;
b--;
if(b < 0) b = 0;
if(b > 6) b = 6;
Fix UB: use unsigned add for draugr's cloak color
2021-07-12 03:02:35 +00:00
queuepoly(VHEAD1, cgi.shWightCloak, color_t(0x605040A0 | UNTRANS) + color_t(0x10101000 * b));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moVoidBeast: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, 0x080808D0 | UNTRANS, m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shPBody, 0x080808D0 | UNTRANS);
queuepoly(VHEAD, cgi.shPHead, 0x080808D0 | UNTRANS);
queuepoly(VHEAD, cgi.shWightCloak, 0xFF0000A0 | UNTRANS);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFF0000FF, 0x080808FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moGoblin: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shYeti);
queuepoly(VBS, cgi.shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD, cgi.shArmor, darkena(col, 1, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x800000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moLancer: case moFlailer: case moMiner: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = V;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moLancer)
V2 = V * spin((where && where->type == 6) ? -M_PI/3 : -M_PI/2 );
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vh = mmscale(V2, cgi.HEAD);
shiftmatrix Vb = mmscale(V2, cgi.BODY);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
Vb = Vb * otherbodyparts(V2, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V2, cgi.shPBody);
queuepoly(Vb, cgi.shPBody, darkena(col, 0, 0xC0));
queuepoly(Vh, m == moFlailer ? cgi.shArmor : cgi.shHood, darkena(col, 1, 0XFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moMiner)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vb, cgi.shPickAxe, darkena(0xC0C0C0, 0, 0XFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moLancer)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vb, cgi.shPike, darkena(col, 0, 0XFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(m == moFlailer) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vb, cgi.shFlailBall, darkena(col, 0, 0XFF));
queuepoly(Vb, cgi.shFlailChain, darkena(col, 1, 0XFF));
queuepoly(Vb, cgi.shFlailTrunk, darkena(col, 0, 0XFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moTroll: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shYeti);
queuepoly(VBS, cgi.shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, cgi.shPHead, darkena(col, 1, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(col, 2, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x004000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moFjordTroll: case moForestTroll: case moStormTroll: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shYeti);
queuepoly(VBS, cgi.shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, cgi.shPHead, darkena(col, 1, 0XFF));
queuepoly(VHEAD, cgi.shPFace, darkena(col, 2, 0XFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x004000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moDarkTroll: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shYeti);
queuepoly(VBS, cgi.shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, cgi.shPHead, darkena(col, 1, 0XFF));
queuepoly(VHEAD, cgi.shPFace, 0xFFFFFF80 | UNTRANS);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moRedTroll: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shYeti);
queuepoly(VBS, cgi.shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, cgi.shPHead, darkena(0xFF8000, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, 0xFFFFFF80 | UNTRANS);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moEarthElemental: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWaterElemental);
queuepoly(VBS, cgi.shWaterElemental, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, cgi.shFemaleHair, darkena(col, 0, 0XFF));
queuepoly(VHEAD, cgi.shPFace, 0xF0000080 | UNTRANS);
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xD0D000FF, darkena(col, 1, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moWaterElemental: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, watercolor(50), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWaterElemental);
queuepoly(VBS, cgi.shWaterElemental, watercolor(0));
queuepoly(VHEAD1, cgi.shFemaleHair, watercolor(100));
queuepoly(VHEAD, cgi.shPFace, watercolor(200));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x0000FFFF, watercolor(150));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moFireElemental: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(firecolor(50), 0, 0xFF), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWaterElemental);
queuepoly(VBS, cgi.shWaterElemental, darkena(firecolor(0), 0, 0xFF));
queuepoly(VHEAD1, cgi.shFemaleHair, darkena(firecolor(100), 0, 0xFF));
queuepoly(VHEAD, cgi.shPFace, darkena(firecolor(200), 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, darkena(firecolor(200), 0, 0xFF), darkena(firecolor(50), 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moAirElemental: {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0x40), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shWaterElemental);
queuepoly(VBS, cgi.shWaterElemental, darkena(col, 0, 0x80));
queuepoly(VHEAD1, cgi.shFemaleHair, darkena(col, 0, 0x80));
queuepoly(VHEAD, cgi.shPFace, darkena(col, 0, 0x80));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFFFFFFFF, darkena(col, 1, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moWorm: case moWormwait: case moHexSnake: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shWormHead, darkena(col, 0, 0xFF));
queuepolyat(V, cgi.shWormEyes, 0xFF, PPR::ONTENTACLE_EYES);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moDragonHead: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shDragonHead, darkena(col, 0, 0xFF));
queuepolyat(V, cgi.shDragonEyes, 0xFF, PPR::ONTENTACLE_EYES);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
int noscolor = 0xFF0000FF;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shDragonNostril, noscolor);
queuepoly(V * Mirror, cgi.shDragonNostril, noscolor);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moDragonTail: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shDragonSegment, darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
case moTentacle: case moTentaclewait: case moTentacleEscaping: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shTentHead, darkena(col, 0, 0xFF));
ShadowV(V, cgi.shTentHead, PPR::GIANTSHADOW);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
Asteroids
2019-03-30 16:51:37 +00:00
case moAsteroid: {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shAsteroid[1], darkena(col, 0, 0xFF));
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return true;
Asteroids
2019-03-30 16:51:37 +00:00
}
first version of the Land of Dice
2021-05-27 11:00:20 +00:00
added some missing CAP_* guards
2021-06-09 02:33:55 +00:00
#if CAP_COMPLEX2
dice:: added Angry Dice
2021-05-29 13:45:37 +00:00
case moAnimatedDie: case moAngryDie: {
first version of the Land of Dice
2021-05-27 11:00:20 +00:00
if(where)
dice::draw_die(where, V, 1, darkena(col, 0, 0xFF));
else
queuepoly(V, cgi.shDodeca, darkena(col, 0, 0xFF));
return true;
}
added some missing CAP_* guards
2021-06-09 02:33:55 +00:00
#endif
first version of the Land of Dice
2021-05-27 11:00:20 +00:00
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
default: ;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(isPrincess(m)) goto princess;
else if(isBull(m)) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shBullBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
int hoofcol = darkena(gradient(0, col, 0, .65, 1), 0, 0xFF);
if(mmspatial || footphase)
animallegs(VALEGS, moRagingBull, hoofcol, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shBullBody, darkena(gradient(0, col, 0, .80, 1), 0, 0xFF));
queuepoly(VAHEAD, cgi.shBullHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, cgi.shBullHorn, darkena(0xFFFFFF, 0, 0xFF));
queuepoly(VAHEAD * Mirror, cgi.shBullHorn, darkena(0xFFFFFF, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else if(isBug(m)) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shBugBody);
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
if(!mmspatial && !footphase)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shBugBody, darkena(col, 0, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else {
animallegs(VALEGS, moBug0, darkena(col, 0, 0xFF), footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shBugAntenna, darkena(col, 1, 0xFF));
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shBugArmor, darkena(col, 1, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
graphics/theming for Jelly/Ruins
2018-01-04 14:46:06 +00:00
else if(isSwitch(m)) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VFISH, cgi.shJelly, darkena(col, 0, 0xD0));
queuepolyat(VBODY, cgi.shJelly, darkena(col, 0, 0xD0), PPR::MONSTER_BODY);
queuepolyat(VHEAD, cgi.shJelly, darkena(col, 0, 0xD0), PPR::MONSTER_HEAD);
queuepolyat(VHEAD, cgi.shSlimeEyes, 0xFF, PPR::MONSTER_HEAD);
graphics/theming for Jelly/Ruins
2018-01-04 14:46:06 +00:00
}
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else if(isDemon(m)) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shPBody, darkena(col, 1, 0xC0));
ShadowV(V, cgi.shPBody);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int acol = col;
if(xch == 'D') acol = 0xD0D0D0;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD, cgi.shDemon, darkena(acol, 0, 0xFF));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0xFF0000FF, 0xC00000FF);
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
Magnetic and Switch V1
2017-12-30 14:12:15 +00:00
else if(isMagneticPole(m)) {
if(m == moNorthPole)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepolyat(VBODY * spin(M_PI), cgi.shTentacle, 0x000000C0, PPR::TENTACLE1);
queuepolyat(VBODY, cgi.shDisk, darkena(col, 0, 0xFF), PPR::MONSTER_BODY);
Magnetic and Switch V1
2017-12-30 14:12:15 +00:00
}
brownian:: more serious work
2018-10-25 00:43:14 +00:00
else if(isMetalBeast(m) || m == moBrownBug) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shTrylobite);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!mmspatial)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shTrylobite, darkena(col, 1, 0xC0));
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
else {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VABODY, cgi.shTrylobiteBody, darkena(col, 1, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
animallegs(VALEGS, moMetalBeast, darkena(col, 1, 0xFF), footphase);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int acol = col;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VAHEAD, cgi.shTrylobiteHead, darkena(acol, 0, 0xFF));
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
monster added: Hag
2021-05-17 12:18:45 +00:00
else if(m == moHexer) {
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, cgi.shFemaleBody);
queuepoly(VBS, cgi.shFemaleBody, darkena(0x800080, 0, 0xFF));
queuepoly(VHEAD1, cgi.shWitchHair, darkena(0xFF00FF, 1, 0xFF));
queuepoly(VHEAD, cgi.shPFace, darkena(0xFFFFFF, 0, 0xFF));
queuepoly(VBS, cgi.shWitchDress, darkena(col, 1, 0XC0));
humanoid_eyes(V, 0xF000F0FF);
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(isWitch(m)) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
const shiftmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int cc = 0xFF;
better system of syncing game animations
2018-09-10 15:49:51 +00:00
if(m == moWitchGhost) cc = 0x85 + 120 * sintick(160);
graphical effects for some curses
2021-05-21 23:26:59 +00:00
if(m == moWitchWinter && where) drawWinter(V, 0, iinf[itOrbWinter].color);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(m == moWitchFlash && where) drawFlash(V);
if(m == moWitchSpeed && where) drawSpeed(V);
if(m == moWitchFire) col = firecolor(0);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(V, cgi.shFemaleBody);
queuepoly(VBS, cgi.shFemaleBody, darkena(col, 0, cc));
// queuepoly(cV2, ct, cgi.shPSword, darkena(col, 0, 0XFF));
// queuepoly(V, cgi.shHood, darkena(col, 0, 0XC0));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(m == moWitchFire) col = firecolor(100);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD1, cgi.shWitchHair, darkena(col, 1, cc));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(m == moWitchFire) col = firecolor(200);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VHEAD, cgi.shPFace, darkena(col, 0, cc));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(m == moWitchFire) col = firecolor(300);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(VBS, cgi.shWitchDress, darkena(col, 1, 0XC0));
3d:: humanoid eyes (except the player)
2019-05-12 18:08:42 +00:00
humanoid_eyes(V, 0x000000FF);
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// just for the HUD glyphs...
drawMonsterType with cases
2019-03-30 12:16:19 +00:00
else if(isAnyIvy(m)) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shILeaf[0], darkena(col, 0, 0xFF));
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
else
draw_ascii(V1, minf[m].glyph, asciicol, 1.5);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
return true;
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
bool drawMonsterTypeDH(eMonster m, cell *where, const shiftmatrix& V, color_t col, bool dh, ld footphase, color_t asciicol) {
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
dynamicval<color_t> p(poly_outline, poly_outline);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(dh) {
poly_outline = OUTLINE_DEAD;
darken++;
}
fixed the monster color in the minimap for Dragons etc
2019-06-24 10:57:00 +00:00
bool b = drawMonsterType(m,where,V,col, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(dh) {
darken--;
}
return b;
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX shiftmatrix playerV;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX bool applyAnimation(cell *c, shiftmatrix& V, double& footphase, int layer) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!animations[layer].count(c)) return false;
animation& a = animations[layer][c];
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int td = ticks - a.ltick;
ld aspd = td / 1000.0 * exp(vid.mspeed);
attack animations
2018-01-25 16:19:50 +00:00
ld R;
again:
slr:: movement animation (not rotation nor attack animation though)
2019-08-27 14:48:50 +00:00
if(sl2) {
a.wherenow = slr::translate(tC0(a.wherenow));
optimized inverses
2020-09-16 03:57:05 +00:00
hyperpoint h = tC0(iso_inverse(a.wherenow));
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
hyperpoint ie = slr::get_inverse_exp(shiftless(h));
slr:: movement animation (not rotation nor attack animation though)
2019-08-27 14:48:50 +00:00
auto R = hypot_d(3, ie);
aspd *= (1+R+(shmup::on?1:0));
if(R < aspd || std::isnan(R) || std::isnan(aspd) || R > 10) {
animations[layer].erase(c);
return false;
}
a.wherenow = nisot::parallel_transport(a.wherenow, tangent_length(h, aspd));
a.footphase += a.attacking == 2 ? -aspd : aspd;
// todo attack animation, rotate correctly
footphase = a.footphase;
V = V * a.wherenow;
a.ltick = ticks;
return true;
}
Princess hug animation
2020-12-26 17:09:09 +00:00
if(among(a.attacking, 1, 3))
attack animations
2018-01-25 16:19:50 +00:00
R = hdist(tC0(a.attackat), tC0(a.wherenow));
else
R = hdist0(tC0(a.wherenow));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
aspd *= (1+R+(shmup::on?1:0));
Princess hug animation
2020-12-26 17:09:09 +00:00
if(a.attacking == 3 && aspd > R) aspd = R;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
Princess hug animation
2020-12-26 17:09:09 +00:00
if((R < aspd || std::isnan(R) || std::isnan(aspd) || R > 10) && a.attacking != 3) {
attack animations
2018-01-25 16:19:50 +00:00
if(a.attacking == 1) { a.attacking = 2; goto again; }
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
animations[layer].erase(c);
return false;
}
else {
product:: animations fixed
2019-08-18 20:27:55 +00:00
hyperpoint wnow;
Princess hug animation
2020-12-26 17:09:09 +00:00
if(a.attacking == 1 || a.attacking == 3)
optimized inverses
2020-09-16 03:57:05 +00:00
wnow = tC0(z_inverse(a.wherenow) * a.attackat);
attack animations
2018-01-25 16:19:50 +00:00
else
optimized inverses
2020-09-16 03:57:05 +00:00
wnow = tC0(z_inverse(a.wherenow));
product:: animations fixed
2019-08-18 20:27:55 +00:00
if(prod) {
auto d = product_decompose(wnow);
ld dist = d.first / R * aspd;
if(abs(dist) > abs(d.first)) dist = -d.first;
a.wherenow = mscale(a.wherenow, dist);
fixed a bug with radarpoints obscuring screen due to NaNs
2019-08-20 22:35:19 +00:00
/* signed_sqrt to prevent precision errors */
aspd *= signed_sqrt(R*R - d.first * d.first) / R;
product:: animations fixed
2019-08-18 20:27:55 +00:00
}
a.wherenow = a.wherenow * rspintox(wnow);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
a.wherenow = a.wherenow * xpush(aspd);
improved discrete animation while affine
2020-05-15 20:52:52 +00:00
if(cgflags & qAFFINE) {
transmatrix T = a.wherenow;
fixmatrix_euclid(T);
a.wherenow = inverse(T) * a.wherenow;
for(int i=0; i<MDIM; i++)
a.wherenow[i] = lerp(a.wherenow[i], Id[i], aspd / R);
a.wherenow = T * a.wherenow;
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
fixmatrix(a.wherenow);
attack animations
2018-01-25 16:19:50 +00:00
a.footphase += a.attacking == 2 ? -aspd : aspd;
Princess hug animation
2020-12-26 17:09:09 +00:00
if(a.attacking == 3 && aspd >= R) {
a.footphase = 0;
hyperpoint h1 = a.wherenow * C0;
a.wherenow = rgpushxto0(h1) * rspintox(h1);
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
footphase = a.footphase;
V = V * a.wherenow;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(a.mirrored) V = V * Mirror;
attack animations
2018-01-25 16:19:50 +00:00
if(a.attacking == 2) V = V * pispin;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
// if(GDIM == 3) V = V * cspin(0, 2, M_PI/2);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
a.ltick = ticks;
return true;
}
}
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
double chainAngle(cell *c, shiftmatrix& V, cell *c2, double dft, const shiftmatrix &Vwhere) {
updated to 10.0c
2017-07-22 23:33:27 +00:00
if(!gmatrix0.count(c2)) return dft;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hyperpoint h = C0;
if(animations[LAYER_BIG].count(c2)) h = animations[LAYER_BIG][c2].wherenow * h;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
h = inverse_shift(V, Vwhere) * calc_relative_matrix(c2, c, C0) * h;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return atan2(h[1], h[0]);
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// equivalent to V = V * spin(-chainAngle(c,V,c2,dft));
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
bool chainAnimation(cell *c, cell *c2, shiftmatrix& V, const shiftmatrix &Vwhere, ld& length) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hyperpoint h = C0;
if(animations[LAYER_BIG].count(c2)) h = animations[LAYER_BIG][c2].wherenow * h;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
h = inverse_shift(V, Vwhere) * h;
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
length = hdist0(h);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
V = V * rspintox(h);
return true;
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// push down the queue after q-th element, `down` absolute units down,
// based on cell c and transmatrix V
// do change the zoom factor? do change the priorities?
Updated to 8.3j
2016-08-26 09:58:03 +00:00
further cleanup
2019-08-09 21:39:36 +00:00
EX int cellcolor(cell *c) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(isPlayerOn(c) || isFriendly(c)) return OUTLINE_FRIEND;
if(noHighlight(c->monst)) return OUTLINE_NONE;
if(c->monst) return OUTLINE_ENEMY;
if(c->wall == waMirror) return c->land == laMirror ? OUTLINE_TREASURE : OUTLINE_ORB;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
ASCII/3D mode, also reacts to neon settings
2020-01-30 16:45:05 +00:00
if(c->item && !itemHiddenFromSight(c)) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int k = itemclass(c->item);
if(k == IC_TREASURE)
return OUTLINE_TREASURE;
else if(k == IC_ORB)
return OUTLINE_ORB;
else
return OUTLINE_OTHER;
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return OUTLINE_NONE;
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
int taildist(cell *c) {
int s = 0;
while(s < 1000 && c->mondir != NODIR && isWorm(c->monst)) {
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
s++; c = c->move(c->mondir);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
}
return s;
}
int last_wormsegment = -1;
Fix some minor std::function-related bugs. Lambdas to be stored in `function<void()>` should not return `bool`. Two uses of `std::function` could be just `function`, like everywhere else in the codebase.
2019-01-06 01:40:45 +00:00
vector<vector< function<void()> > > wormsegments;
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
Fix some minor std::function-related bugs. Lambdas to be stored in `function<void()>` should not return `bool`. Two uses of `std::function` could be just `function`, like everywhere else in the codebase.
2019-01-06 01:40:45 +00:00
void add_segment(int d, const function<void()>& s) {
renamed the size function to isize
2018-06-22 12:47:24 +00:00
if(isize(wormsegments) <= d) wormsegments.resize(d+1);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
last_wormsegment = max(last_wormsegment, d);
wormsegments[d].push_back(s);
}
void drawWormSegments() {
for(int i=0; i<=last_wormsegment; i++) {
for(auto& f: wormsegments[i]) f();
wormsegments[i].clear();
}
last_wormsegment = -1;
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool dont_face_pc = false;
dont_face_pc commandline option
2018-01-30 23:10:44 +00:00
first version of the Land of Dice
2021-05-27 11:00:20 +00:00
EX shiftmatrix die_target;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX bool drawMonster(const shiftmatrix& Vparam, int ct, cell *c, color_t col, color_t asciicol) {
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
bool darkhistory = history::includeHistory && history::inkillhistory.count(c);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(doHighlight())
poly_outline =
(isPlayerOn(c) || isFriendly(c)) ? OUTLINE_FRIEND :
noHighlight(c->monst) ? OUTLINE_NONE :
OUTLINE_ENEMY;
added faraway monster highlight as in @still-flow's pull request
2021-04-30 17:44:54 +00:00
// highlight faraway enemies if that's needed
if (vid.faraway_highlight && c->cpdist >= 6 && vid.faraway_highlight <= get_threat_level(c)) {
// basic red-green oscillation
color_t r = ceil(255*abs(sintick(1000, 0.25)));
color_t g = ceil(255*abs(sintick(1000, 0.00)));
color_t hlc = (r<<16) + (g<<8);
hlc = gradient(col, hlc, 0, vid.faraway_highlight_color, 100);
if(c->cpdist == 6)
hlc = gradient(0, hlc, 0, 1, 1.5);
addauraspecial(tC0(Vparam), hlc, 0);
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool nospins = false, nospinb = false;
double footphaseb = 0, footphase = 0;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vs = Vparam; nospins = applyAnimation(c, Vs, footphase, LAYER_SMALL);
shiftmatrix Vb = Vparam; nospinb = applyAnimation(c, Vb, footphaseb, LAYER_BIG);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// nospin = true;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
eMonster m = c->monst;
refactored hasFacing
2019-03-30 12:35:03 +00:00
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
bool half_elliptic = elliptic && GDIM == 3 && WDIM == 2;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
bool mirrored = det(Vparam.T) > 0;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
bool res = m;
refactored hasFacing
2019-03-30 12:35:03 +00:00
if(!m) ;
2D3D:: in elliptic, draw only the correct orientation
2019-05-15 10:41:02 +00:00
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
else if(half_elliptic && mirrored != c->monmirror && !isMimic(m)) ;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
refactored hasFacing
2019-03-30 12:35:03 +00:00
else if(isAnyIvy(c) || isWorm(c)) {
3d:: more things shown as walls, worms also use wall graphics
2019-02-27 13:43:42 +00:00
Rock Snakes from the Snake Nest now keep their colors in other lands
2018-06-17 10:15:46 +00:00
if((m == moHexSnake || m == moHexSnakeTail) && c->hitpoints == 2) {
fixed snake butt graphics in the Snake Nest
2018-01-05 14:49:50 +00:00
int d = c->mondir;
if(d == NODIR)
forCellIdEx(c2, i, c)
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(among(c2->monst, moHexSnakeTail, moHexSnake) && c2->mondir == c->c.spin(i))
fixed snake butt graphics in the Snake Nest
2018-01-05 14:49:50 +00:00
d = i;
fixed some bugs with Snake Nest generation
2018-01-06 22:39:10 +00:00
if(d == NODIR) { d = hrand(c->type); createMov(c, d); }
Snakes Nest v1
2017-12-05 18:43:45 +00:00
int c1 = nestcolors[pattern_threecolor(c)];
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
int c2 = nestcolors[pattern_threecolor(c->move(d))];
Snakes Nest v1
2017-12-05 18:43:45 +00:00
col = (c1 + c2); // sum works because they are dark and should be brightened
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(isDragon(c->monst) && c->stuntime == 0) col = 0xFF6000;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3)
fixed the monster color in the minimap for Dragons etc
2019-06-24 10:57:00 +00:00
addradar(Vparam, minf[m].glyph, asciicol, isFriendly(m) ? 0x00FF00FF : 0xFF0000FF);
3d:: using models not walls for worms
2019-05-11 13:20:34 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vb0 = Vb;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(c->mondir != NODIR && GDIM == 3 && isAnyIvy(c)) {
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
queueline(tC0(Vparam), Vparam * tC0(currentmap->adj(c, c->mondir)), (col << 8) + 0xFF, 0);
3d:: Ivy graphics
2019-02-26 21:08:33 +00:00
}
else if(c->mondir != NODIR) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(mmmon) {
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
ld length;
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
cell *c2 = c->move(c->mondir);
if(nospinb) {
chainAnimation(c, c2, Vb, Vparam * currentmap->adj(c, c->mondir), length);
}
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
else {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
Vb = Vb * ddspin(c, c->mondir);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
length = cellgfxdist(c, c->mondir);
}
Fixed mapediting floorshapes. Also works nicely for all geometries now. Enum used for shapegroups.
2018-08-27 17:27:35 +00:00
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
fixed a crash when drawing inventory items while drawcell is also NULL; priority functions now use PPR_DEFAULT not -1; priority is passed as PPR not int
2018-08-28 11:45:11 +00:00
if(mapeditor::drawUserShape(Vb, mapeditor::sgMonster, c->monst, (col << 8) + 0xFF, c))
Fixed mapediting floorshapes. Also works nicely for all geometries now. Enum used for shapegroups.
2018-08-27 17:27:35 +00:00
return false;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(isIvy(c) || isMutantIvy(c) || c->monst == moFriendlyIvy)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vb, cgi.shIBranch, (col << 8) + 0xFF);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
/* else if(c->monst < moTentacle && wormstyle == 0) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(Vb, cgi.shTentacleX, PPR::GIANTSHADOW);
queuepoly(mmscale(Vb, cgi.ABODY), cgi.shTentacleX, 0xFF);
queuepoly(mmscale(Vb, cgi.ABODY), cgi.shTentacle, (col << 8) + 0xFF);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
} */
// else if(c->monst < moTentacle) {
// }
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(c->monst == moDragonHead || c->monst == moDragonTail) {
char part = dragon::bodypart(c, dragon::findhead(c));
if(part != '2') {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(mmscale(Vb, cgi.ABODY), cgi.shDragonSegment, darkena(col, 0, 0xFF));
ShadowV(Vb, cgi.shDragonSegment, PPR::GIANTSHADOW);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
else {
if(c->monst == moTentacleGhost) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
hyperpoint V0 = history::on ? unshift(tC0(Vs)) : inverse_shift(cwtV, tC0(Vs));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hyperpoint V1 = spintox(V0) * V0;
Vs = cwtV * rspintox(V0) * rpushxto0(V1) * pispin;
fixed weird coloring of ghost-on-tentacle
2019-06-24 10:57:55 +00:00
drawMonsterType(moGhost, c, Vs, col, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
col = minf[moTentacletail].color;
}
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
/*
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(mmscale(Vb, cgi.ABODY), cgi.shTentacleX, 0xFFFFFFFF);
queuepoly(mmscale(Vb, cgi.ABODY), cgi.shTentacle, (col << 8) + 0xFF);
ShadowV(Vb, cgi.shTentacleX, PPR::GIANTSHADOW);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
*/
bool hexsnake = c->monst == moHexSnake || c->monst == moHexSnakeTail;
bool thead = c->monst == moTentacle || c->monst == moTentaclewait || c->monst == moTentacleEscaping;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
hpcshape& sh = hexsnake ? cgi.shWormSegment : cgi.shSmallWormSegment;
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
ld wav = hexsnake ? 0 :
c->monst < moTentacle ? 1/1.5 :
1;
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col0 = col;
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
if(c->monst == moWorm || c->monst == moWormwait)
col0 = minf[moWormtail].color;
else if(thead)
col0 = minf[moTentacletail].color;
add_segment(taildist(c), [=] () {
for(int i=11; i>=0; i--) {
if(i < 3 && (c->monst == moTentacle || c->monst == moTentaclewait)) continue;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbx = Vb;
3d:: using models not walls for worms
2019-05-11 13:20:34 +00:00
if(WDIM == 2) Vbx = Vbx * spin(sin(M_PI * i / 6.) * wav / (i+.1));
Vbx = Vbx * xpush(length * (i) / 12.0);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
// shiftmatrix Vbx2 = Vnext * xpush(length2 * i / 6.0);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
// Vbx = Vbx * rspintox(inverse(Vbx) * Vbx2 * C0) * pispin;
enum class used for PPR
2018-08-28 12:27:23 +00:00
ShadowV(Vbx, sh, PPR::GIANTSHADOW);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(mmscale(Vbx, cgi.ABODY), sh, (col0 << 8) + 0xFF);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
}
});
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix T = Vparam * ddspin(c, c->mondir);
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = darkena(0x606020, 0, 0xFF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int u=-1; u<=1; u++)
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
queueline(T*xspinpush0(M_PI/2, u*cgi.crossf/5), T*xspinpush(0, cgi.crossf)*xspinpush0(M_PI/2, u*cgi.crossf/5), col, 2 + vid.linequality);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(mmmon) {
refactored hasFacing
2019-03-30 12:35:03 +00:00
if(isAnyIvy(c)) {
sl2:: 3d-models
2019-08-24 12:49:49 +00:00
if(hybri) {
product:: nice ivies
2019-08-19 08:33:07 +00:00
queuepoly(Vb, cgi.shILeaf[ctof(c)], darkena(col, 0, 0xFF));
for(int a=0; a<c->type-2; a++)
queuepoly(Vb * spin(a * 2 * M_PI / (c->type-2)), cgi.shILeaf[2], darkena(col, 0, 0xFF));
}
else if(GDIM == 3) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
queuepoly(face_the_player(Vb), cgi.shILeaf[1], darkena(col, 0, 0xFF));
3d:: Ivy graphics
2019-02-26 21:08:33 +00:00
}
else {
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(mmscale(Vb, cgi.ABODY), cgi.shILeaf[ctof(c)], darkena(col, 0, 0xFF));
ShadowV(Vb, cgi.shILeaf[ctof(c)], PPR::GIANTSHADOW);
3d:: Ivy graphics
2019-02-26 21:08:33 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(m == moWorm || m == moWormwait || m == moHexSnake) {
Vb = Vb * pispin;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbh = mmscale(Vb, cgi.AHEAD);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vbh, cgi.shWormHead, darkena(col, 0, 0xFF));
queuepolyat(Vbh, cgi.shWormEyes, 0xFF, PPR::ONTENTACLE_EYES);
ShadowV(Vb, cgi.shWormHead, PPR::GIANTSHADOW);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(m == moDragonHead) {
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbh = mmscale(Vb, cgi.AHEAD);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ShadowV(Vb, cgi.shDragonHead, PPR::GIANTSHADOW);
queuepoly(Vbh, cgi.shDragonHead, darkena(col, c->hitpoints?0:1, 0xFF));
queuepolyat(Vbh/* * pispin */, cgi.shDragonEyes, 0xFF, PPR::ONTENTACLE_EYES);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int noscolor = (c->hitpoints == 1 && c->stuntime ==1) ? 0xFF0000FF : 0xFF;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vbh, cgi.shDragonNostril, noscolor);
queuepoly(Vbh * Mirror, cgi.shDragonNostril, noscolor);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(m == moTentacle || m == moTentaclewait || m == moTentacleEscaping) {
Vb = Vb * pispin;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbh = mmscale(Vb, cgi.AHEAD);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vbh, cgi.shTentHead, darkena(col, 0, 0xFF));
ShadowV(Vb, cgi.shTentHead, PPR::GIANTSHADOW);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(m == moDragonTail) {
cell *c2 = NULL;
for(int i=0; i<c->type; i++)
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(c->move(i) && isDragon(c->move(i)->monst) && c->move(i)->mondir == c->c.spin(i))
c2 = c->move(i);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int nd = neighborId(c, c2);
char part = dragon::bodypart(c, dragon::findhead(c));
if(part == 't') {
if(nospinb) {
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
ld length;
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
chainAnimation(c, c2, Vb, Vparam * currentmap->adj(c, nd), length);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
Vb = Vb * pispin;
}
else {
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
Vb = Vb0 * ddspin(c, nd, M_PI);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbb = mmscale(Vb, cgi.ABODY);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vbb, cgi.shDragonTail, darkena(col, c->hitpoints?0:1, 0xFF));
ShadowV(Vb, cgi.shDragonTail, PPR::GIANTSHADOW);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(true) {
if(nospinb) {
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
ld length;
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
chainAnimation(c, c2, Vb, Vparam * currentmap->adj(c, nd), length);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
Vb = Vb * pispin;
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
double ang = chainAngle(c, Vb, c->move(c->mondir), currentmap->spin_angle(c, c->mondir) - currentmap->spin_angle(c, nd), Vparam);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
ang /= 2;
Vb = Vb * spin(M_PI-ang);
}
else {
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
/* todo what if no spin_angle */
ld hdir0 = currentmap->spin_angle(c, nd) + M_PI;
ld hdir1 = currentmap->spin_angle(c, c->mondir);
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
while(hdir1 > hdir0 + M_PI) hdir1 -= 2*M_PI;
while(hdir1 < hdir0 - M_PI) hdir1 += 2*M_PI;
Vb = Vb0 * spin((hdir0 + hdir1)/2 + M_PI);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbb = mmscale(Vb, cgi.ABODY);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(part == 'l' || part == '2') {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vbb, cgi.shDragonLegs, darkena(col, c->hitpoints?0:1, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Vbb, cgi.shDragonWings, darkena(col, c->hitpoints?0:1, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
Snakes Nest v1
2017-12-05 18:43:45 +00:00
else {
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
if(c->monst == moTentacletail && c->mondir == NODIR) {
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
queuepoly(GDIM == 3 ? mmscale(Vb, cgi.ABODY) : Vb, cgi.shWormSegment, darkena(col, 0, 0xFF));
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
}
else if(c->mondir == NODIR) {
bool hexsnake = c->monst == moHexSnake || c->monst == moHexSnakeTail;
cell *c2 = NULL;
for(int i=0; i<c->type; i++)
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(c->move(i) && isWorm(c->move(i)->monst) && c->move(i)->mondir == c->c.spin(i))
c2 = c->move(i);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
int nd = neighborId(c, c2);
if(nospinb) {
ld length;
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
chainAnimation(c, c2, Vb, Vparam * currentmap->adj(c, nd), length);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
Vb = Vb * pispin;
}
else {
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
Vb = Vb0 * ddspin(c, nd, M_PI);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
}
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vbb = mmscale(Vb, cgi.ABODY) * pispin;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
hpcshape& sh = hexsnake ? cgi.shWormTail : cgi.shSmallWormTail;
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
queuepoly(Vbb, sh, darkena(col, 0, 0xFF));
enum class used for PPR
2018-08-28 12:27:23 +00:00
ShadowV(Vb, sh, PPR::GIANTSHADOW);
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
}
Snakes Nest v1
2017-12-05 18:43:45 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
improved ASCII: fixed viies
2021-04-15 15:55:46 +00:00
else res = res && drawMonsterType(c->monst, c, Vb, col, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(isMimic(c)) {
updated to 10.0c
2017-07-22 23:33:27 +00:00
int xdir = 0, copies = 1;
if(c->wall == waMirrorWall) {
xdir = mirror::mirrordir(c);
copies = 2;
if(xdir == -1) copies = 6, xdir = 0;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
for(auto& m: mirror::mirrors) if(c == m.second.at)
updated to 10.0c
2017-07-22 23:33:27 +00:00
for(int d=0; d<copies; d++) {
multi::cpid = m.first;
auto cw = m.second;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(d&1) cw = cw.mirrorat(xdir);
more elegant cellwalkers
2018-03-24 11:59:01 +00:00
if(d>=2) cw += 2;
if(d>=4) cw += 2;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Vs = Vparam;
updated to 10.0c
2017-07-22 23:33:27 +00:00
bool mirr = cw.mirrored;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(mirrored != mirr && half_elliptic) continue;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix T = shiftless(Id);
improved mirrors in various geometries
2018-08-21 13:37:59 +00:00
nospins = applyAnimation(cwt.at, T, footphase, LAYER_SMALL);
if(nospins)
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
Vs = Vs * ddspin(c, cw.spin, 0) * iddspin(cwt.at, cwt.spin, 0) * unshift(T);
improved mirrors in various geometries
2018-08-21 13:37:59 +00:00
else
Vs = Vs * ddspin(c, cw.spin, 0);
updated to 10.0c
2017-07-22 23:33:27 +00:00
if(mirr) Vs = Vs * Mirror;
if(inmirrorcount&1) mirr = !mirr;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
col = mirrorcolor(geometry == gElliptic ? det(Vs.T) < 0 : mirr);
2d3d:: no more mirror markers
2019-05-11 13:21:48 +00:00
if(!mouseout() && !nospins && GDIM == 2) {
fixed errors with mirrors walls: monsters face the player correctly; mimics in mirrors display their X-signs correctly; player in mirror displays their X sign while previously they did not
2020-09-16 17:48:25 +00:00
shiftpoint P2 = Vs * inverse_shift(inmirrorcount ? ocwtV : cwtV, mouseh);
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(P2, 10, "x", 0xFF00);
improved mirrors in various geometries
2018-08-21 13:37:59 +00:00
}
updated to 10.0c
2017-07-22 23:33:27 +00:00
if(!nospins && flipplayer) Vs = Vs * pispin;
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
res = res && drawMonsterType(moMimic, c, Vs, col, footphase, asciicol);
drawPlayerEffects(Vs, c, false);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
// illusions face randomly
else if(c->monst == moIllusion) {
multi::cpid = 0;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vs = Vs * Mirror;
fixed the monster color in the minimap for Dragons etc
2019-06-24 10:57:00 +00:00
drawMonsterType(c->monst, c, Vs, col, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawPlayerEffects(Vs, c, false);
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// wolves face the heat
else if(c->monst == moWolf && c->cpdist > 1) {
if(!nospins) {
int d = 0;
double bheat = -999;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
for(int i=0; i<c->type; i++) if(c->move(i) && HEAT(c->move(i)) > bheat) {
bheat = HEAT(c->move(i));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
d = i;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
3d:: make monster facing correct, based on FACEUP/FACESIDE
2019-04-20 23:08:27 +00:00
Vs = Vs * ddspin(c, d, 0);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vs = Vs * Mirror;
fixed the monster color in the minimap for Dragons etc
2019-06-24 10:57:00 +00:00
return drawMonsterTypeDH(m, c, Vs, col, darkhistory, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(c->monst == moKrakenT) {
if(c->hitpoints == 0) col = 0x404040;
if(nospinb) {
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
ld length;
refactored map functions: ddspin, iddspin, spacedist, spin_angle, virtualRebase[simple], adj
2019-11-14 15:51:50 +00:00
chainAnimation(c, c->move(c->mondir), Vb, Vparam * currentmap->adj(c, c->mondir), length);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
Vb = Vb * pispin;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
Vb = Vb * xpush(cgi.tentacle_length - cellgfxdist(c, c->mondir));
improved the Kraken graphics in various geometries
2018-05-04 00:47:33 +00:00
}
instead of nonbitrunc, gp::on and irr::on, there is one variable, variation
2018-08-28 15:17:34 +00:00
else if(NONSTDVAR) {
removed calc_relative_matrix with direction hint; used adj in more places
2019-11-22 13:34:56 +00:00
transmatrix T = currentmap->adj(c, c->mondir);
optimized inverses
2020-09-16 03:57:05 +00:00
Vb = Vb * T * rspintox(tC0(iso_inverse(T))) * xpush(cgi.tentacle_length);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
whirl
2018-04-03 21:39:18 +00:00
else {
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
Vb = Vb * ddspin(c, c->mondir, M_PI);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
Vb = Vb * xpush(cgi.tentacle_length - cellgfxdist(c, c->mondir));
whirl
2018-04-03 21:39:18 +00:00
}
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vb = Vb * Mirror;
improved the Kraken graphics in various geometries
2018-05-04 00:47:33 +00:00
removed 'stdeuclid' and using 'masterless' since it was too similar to 'stdeuc'
2018-08-18 15:35:39 +00:00
// if(ctof(c) && !masterless) Vb = Vb * xpush(hexhexdist - hcrossf);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
// return (!BITRUNCATED) ? tessf * gp::scale : (c->type == 6 && (i&1)) ? hexhexdist : cgi.crossf;
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
res = res && drawMonsterTypeDH(m, c, Vb, col, darkhistory, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
monsters no longer inconsistently try to look at the player in quotient geometries
2018-01-05 13:18:14 +00:00
// golems, knights, and hyperbugs don't face the player (mondir-controlled)
// also whatever in the lineview mode, and whatever in the quotient geometry
refactored to use isDie if applicable
2021-05-30 11:48:24 +00:00
else if(isDie(c->monst)) {
first version of the Land of Dice
2021-05-27 11:00:20 +00:00
transmatrix U = inverse_shift(Vparam, Vs);
U = rgpushxto0(tC0(U));
die_target = Vparam;
res = res && drawMonsterTypeDH(m, c, Vparam * U, col, darkhistory, footphase, asciicol);
}
rewritten the Euclidean geometry
2019-11-27 00:01:20 +00:00
else if((hasFacing(c) && c->mondir != NODIR) || history::on || quotient || dont_face_pc) {
monsters no longer inconsistently try to look at the player in quotient geometries
2018-01-05 13:18:14 +00:00
if(c->monst == moKrakenH) Vs = Vb, nospins = nospinb;
fixed a crash when ddspin called with NODIR
2019-03-12 01:41:44 +00:00
if(!nospins && c->mondir < c->type) Vs = Vs * ddspin(c, c->mondir, M_PI);
monsters no longer inconsistently try to look at the player in quotient geometries
2018-01-05 13:18:14 +00:00
if(c->monst == moPair) Vs = Vs * xpush(-.12);
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vs = Vs * Mirror;
monsters no longer inconsistently try to look at the player in quotient geometries
2018-01-05 13:18:14 +00:00
if(isFriendly(c)) drawPlayerEffects(Vs, c, false);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
res = res && drawMonsterTypeDH(m, c, Vs, col, darkhistory, footphase, asciicol);
monsters no longer inconsistently try to look at the player in quotient geometries
2018-01-05 13:18:14 +00:00
}
refactored hasFacing
2019-03-30 12:35:03 +00:00
else {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// other monsters face the player
monster facing in product
2019-08-20 17:29:03 +00:00
if(!nospins) {
Mirror Spirits now face the original player
2020-09-16 17:52:21 +00:00
shiftmatrix& where = (c->monst == moMirrorSpirit && inmirrorcount) ? ocwtV : cwtV;
monster facing in product
2019-08-20 17:29:03 +00:00
if(WDIM == 2 || prod) {
Mirror Spirits now face the original player
2020-09-16 17:52:21 +00:00
hyperpoint V0 = inverse_shift(Vs, tC0(where));
monster facing in product
2019-08-20 17:29:03 +00:00
ld z = 0;
if(prod) {
auto d = product_decompose(V0);
z = d.first;
V0 = d.second;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
if(hypot_d(2, tC0(unshift(Vs))) > 1e-3) {
'monster face the player: changed the code to simpler and better
2020-07-27 16:53:51 +00:00
Vs = Vs * rspintox(V0);
monster facing in product
2019-08-20 17:29:03 +00:00
if(prod) Vs = mscale(Vs, z);
}
3D:: fixed monster facings in noshmup
2019-02-26 20:11:50 +00:00
}
sl2:: 3d-models
2019-08-24 12:49:49 +00:00
else if(!sl2) {
Mirror Spirits now face the original player
2020-09-16 17:52:21 +00:00
hyperpoint V0 = inverse_shift(Vs, tC0(where));
'monster face the player: changed the code to simpler and better
2020-07-27 16:53:51 +00:00
Vs = Vs * rspintox(V0);
3D:: fixed monster facings in noshmup
2019-02-26 20:11:50 +00:00
// cwtV * rgpushxto0(inverse(cwtV) * tC0(Vs));
}
Changed the hunting patterns.
2017-10-15 22:15:54 +00:00
if(c->monst == moHunterChanging)
sl2:: 3d-models
2019-08-24 12:49:49 +00:00
Vs = Vs * (hybri ? spin(M_PI) : cspin(WDIM-2, WDIM-1, M_PI));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(c->monmirror) Vs = Vs * Mirror;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(c->monst == moShadow)
multi::cpid = c->hitpoints;
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
res = res && drawMonsterTypeDH(m, c, Vs, col, darkhistory, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
10.0g
2017-08-06 12:50:16 +00:00
for(int i=0; i<numplayers(); i++) if(c == playerpos(i) && !shmup::on && mapeditor::drawplayer &&
!(hardcore && !canmove)) {
2D3D:: in elliptic, draw only the correct orientation
2019-05-15 10:41:02 +00:00
bool mirr = multi::players > 1 ? multi::player[i].mirrored : cwt.mirrored;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
if(half_elliptic && mirr != mirrored) continue;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!nospins) {
Vs = playerV;
if(multi::players > 1 ? multi::flipped[i] : flipplayer) Vs = Vs * pispin;
}
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
else {
if(mirr) Vs = Vs * Mirror;
}
changed some shmup:: to multi::
2019-09-06 06:17:38 +00:00
multi::cpid = i;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
asciicol = getcs().uicolor >> 8;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawPlayerEffects(Vs, c, true);
fixed errors with mirrors walls: monsters face the player correctly; mimics in mirrors display their X-signs correctly; player in mirror displays their X sign while previously they did not
2020-09-16 17:48:25 +00:00
if(inmirrorcount && !mouseout() && !nospins && GDIM == 2) {
hyperpoint h = inverse_shift(ocwtV, mouseh);
if(flipplayer) h = pispin * h;
shiftpoint P2 = Vs * h;
queuestr(P2, 10, "x", 0xFF00);
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
3d:: refactored the hide_player function
2019-03-09 14:31:02 +00:00
if(hide_player()) {
refactored first_cell_to_draw so that it is changed in one place
2019-05-11 17:42:30 +00:00
first_cell_to_draw = false;
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
if(WDIM == 2 && GDIM == 3) {
shadow of the player character is always shown
2019-06-24 11:46:27 +00:00
drawPlayer(moPlayer, c, Vs, col, footphase, true);
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
res = true;
}
3D:: do not draw the player in turn-based either
2019-02-26 11:25:54 +00:00
}
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
else if(isWorm(c->monst)) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ld depth = geom3::factor_to_lev(wormhead(c) == c ? cgi.AHEAD : cgi.ABODY);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
footphase = 0;
fixed some warnings and errors with ll to int assignment
2020-04-06 06:39:31 +00:00
int q = isize(ptds);
improved ASCII: fixed domination
2021-04-15 15:55:58 +00:00
res = res | drawMonsterType(moPlayer, c, Vs, col, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
pushdown(c, q, Vs, -depth, true, false);
}
improved ASCII: fixed domination
2021-04-15 15:55:58 +00:00
else res = res | drawMonsterType(moPlayer, c, Vs, col, footphase, asciicol);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
improvements to ASCII items & monsters: PC movement animated on radar; movement is animated; available in 3D graphical modes
2021-04-15 13:26:32 +00:00
return res;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
#define AURA 180
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
array<array<int,4>,AURA+1> aurac;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
int haveaura_cached;
/** 0 = no aura, 1 = standard aura, 2 = Joukowsky aura */
EX int haveaura() {
if(!(vid.aurastr>0 && !svg::in && (auraNOGL || vid.usingGL))) return 0;
disable aura in vr
2020-12-30 13:52:58 +00:00
if(vrhr::active()) return 0;
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
if(sphere && mdAzimuthalEqui()) return 0;
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
if(among(pmodel, mdJoukowsky, mdJoukowskyInverted) && hyperbolic && pconf.model_transition < 1)
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
return 2;
if(pmodel == mdFisheye) return 1;
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
return pmodel == mdDisk && (!sphere || pconf.alpha > 10) && !euclid;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
10.0g
2017-08-06 12:50:16 +00:00
vector<pair<int, int> > auraspecials;
int auramemo;
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
EX void clearaura() {
haveaura_cached = haveaura();
if(!haveaura_cached) return;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int a=0; a<AURA; a++) for(int b=0; b<4; b++)
aurac[a][b] = 0;
10.0g
2017-08-06 12:50:16 +00:00
auraspecials.clear();
auramemo = 128 * 128 / vid.aurastr;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
void apply_joukowsky_aura(shiftpoint& h) {
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
if(haveaura_cached == 2) {
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
hyperpoint ret;
applymodel(h, ret);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
h.h = ret;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
}
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
if(nonisotropic) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
h.h = lp_apply(inverse_exp(h, pfNO_DISTANCE));
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
}
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void addauraspecial(shiftpoint h, color_t col, int dir) {
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
if(!haveaura_cached) return;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
apply_joukowsky_aura(h);
fixed aura specials
2018-12-22 21:39:33 +00:00
int r = int(2*AURA + dir + atan2(h[1], h[0]) * AURA / 2 / M_PI) % AURA;
10.0g
2017-08-06 12:50:16 +00:00
auraspecials.emplace_back(r, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void addaura(shiftpoint h, color_t col, int fd) {
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
if(!haveaura_cached) return;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
apply_joukowsky_aura(h);
int r = int(2*AURA + atan2(h[1], h[0]) * AURA / 2 / M_PI) % AURA;
10.0g
2017-08-06 12:50:16 +00:00
aurac[r][3] += auramemo << fd;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
col = darkened(col);
aurac[r][0] += (col>>16)&255;
aurac[r][1] += (col>>8)&255;
aurac[r][2] += (col>>0)&255;
}
void sumaura(int v) {
int auc[AURA];
for(int t=0; t<AURA; t++) auc[t] = aurac[t][v];
int val = 0;
if(vid.aurasmoothen < 1) vid.aurasmoothen = 1;
if(vid.aurasmoothen > AURA) vid.aurasmoothen = AURA;
int SMO = vid.aurasmoothen;
for(int t=0; t<SMO; t++) val += auc[t];
for(int t=0; t<AURA; t++) {
int tt = (t + SMO/2) % AURA;
aurac[tt][v] = val;
val -= auc[t];
val += auc[(t+SMO) % AURA];
}
aurac[AURA][v] = aurac[0][v];
}
Works online now!
2018-02-11 18:08:17 +00:00
fixed some guards (in progress)
2020-07-03 12:42:33 +00:00
#if CAP_GL
Works online now!
2018-02-11 18:08:17 +00:00
vector<glhr::colored_vertex> auravertices;
fixed some guards (in progress)
2020-07-03 12:42:33 +00:00
#endif
more shader cleanup
2018-02-10 17:21:19 +00:00
fixed some guards (in progress)
2020-07-03 12:42:33 +00:00
EX void drawaura() {
added some more debug lines to DF_GRAPH
2020-04-17 13:03:05 +00:00
DEBBI(DF_GRAPH, ("draw aura"));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!haveaura()) return;
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
if(vid.stereo_mode) return;
double rad = current_display->radius;
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
if(sphere && !mdAzimuthalEqui()) rad /= sqrt(pconf.alpha*pconf.alpha - 1);
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
if(hyperbolic && pmodel == mdFisheye) {
ld h = 1;
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
h /= pconf.fisheye_param;
aura in the fisheye projection, also minor optimization
2019-10-05 10:33:00 +00:00
ld nrad = h / sqrt(2 + h*h);
rad *= nrad;
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int v=0; v<4; v++) sumaura(v);
10.0g
2017-08-06 12:50:16 +00:00
for(auto& p: auraspecials) {
int r = p.first;
aurac[r][3] = auramemo;
Fixed the meaningo of color parameter in addauraspecial
2018-12-23 13:30:09 +00:00
for(int k=0; k<3; k++) aurac[r][k] = (p.second >> (16-8*k)) & 255;
10.0g
2017-08-06 12:50:16 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_SDL || CAP_GL
replaced some instances of double to ld, so that everything compiles when ld is redefined to float
2019-05-04 16:28:03 +00:00
ld bak[3];
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bak[0] = ((backcolor>>16)&255)/255.;
bak[1] = ((backcolor>>8)&255)/255.;
bak[2] = ((backcolor>>0)&255)/255.;
updated to 10.0c
2017-07-22 23:33:27 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_SDL
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!vid.usingGL) {
SDL_LockSurface(s);
for(int y=0; y<vid.yres; y++)
for(int x=0; x<vid.xres; x++) {
expansion, ctrl+E cheat, fix with distance calculation
2017-04-04 09:13:15 +00:00
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
ld hx = (x * 1. - current_display->xcenter) / rad;
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
ld hy = (y * 1. - current_display->ycenter) / rad / pconf.stretch;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
if(pconf.camera_angle) camrotate(hx, hy);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
ld fac = sqrt(hx*hx+hy*hy);
if(fac < 1) continue;
ld dd = log((fac - .99999) / .00001);
ld cmul = 1 - dd/10.;
if(cmul>1) cmul=1;
if(cmul<0) cmul=0;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
ld alpha = AURA * atan2(hx,hy) / (2 * M_PI);
if(alpha<0) alpha += AURA;
if(alpha >= AURA) alpha -= AURA;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int rm = int(alpha);
replaced some instances of double to ld, so that everything compiles when ld is redefined to float
2019-05-04 16:28:03 +00:00
ld fr = alpha-rm;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(rm<0 || rm >= AURA) continue;
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t& p = qpixel(s, x, y);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int c=0; c<3; c++) {
replaced some instances of double to ld, so that everything compiles when ld is redefined to float
2019-05-04 16:28:03 +00:00
ld c1 = aurac[rm][2-c] / (aurac[rm][3]+.1);
ld c2 = aurac[rm+1][2-c] / (aurac[rm+1][3]+.1);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
const ld one = 1;
part(p, c) = int(255 * min(one, bak[2-c] + cmul * ((c1 + fr * (c2-c1) - bak[2-c]))));
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
SDL_UnlockSurface(s);
return;
}
#endif
Updated to 8.3j
2016-08-26 09:58:03 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_GL
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
float cx[AURA+1][11][5];
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
double facs[11] = {1, 1.01, 1.02, 1.04, 1.08, 1.70, 1.95, 1.5, 2, 6, 10};
double cmul[11] = {1, .8, .7, .6, .5, .16, .12, .08, .07, .06, 0};
double d2[11] = {0, 2, 4, 6.5, 7, 7.5, 8, 8.5, 9, 9.5, 10};
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int d=0; d<11; d++) {
double dd = d2[d];
cmul[d] = (1- dd/10.);
facs[d] = .99999 + .00001 * exp(dd);
}
facs[10] = 10;
started work on shaders.cpp
2018-02-08 23:29:20 +00:00
cmul[1] = cmul[0];
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
bool inversion = pconf.alpha <= -1 || pmodel == mdJoukowsky;
bool joukowsky = among(pmodel, mdJoukowskyInverted, mdJoukowsky) && hyperbolic && pconf.model_transition < 1;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int r=0; r<=AURA; r++) for(int z=0; z<11; z++) {
float rr = (M_PI * 2 * r) / AURA;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
float rad0 = inversion ? rad / facs[z] : rad * facs[z];
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int rm = r % AURA;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
ld c = cos(rr);
ld s = sin(rr);
if(joukowsky) {
ld c1 = c, s1 = s;
fixed Joukowsky aura
2018-10-28 01:12:04 +00:00
if(inversion)
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
models::apply_orientation(s1, c1);
fixed Joukowsky aura
2018-10-28 01:12:04 +00:00
else
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
models::apply_orientation(c1, s1);
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
ld& mt = pconf.model_transition;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
ld mt2 = 1 - mt;
ld m = sqrt(c1*c1 + s1*s1 / mt2 / mt2);
m *= 2;
if(inversion) rad0 /= m;
else rad0 *= m;
}
fixed the aura when camera angle changed
2020-11-05 15:26:50 +00:00
ld x = rad0 * c;
fixed camera-rotated aura for stretch
2020-11-05 17:26:37 +00:00
ld y = rad0 * s;
fixed the aura when camera angle changed
2020-11-05 15:26:50 +00:00
if(pconf.camera_angle) {
ld z = rad0;
ld cam = pconf.camera_angle * degree;
GLfloat cc = cos(cam);
GLfloat ss = sin(cam);
tie(y, z) = make_pair(y * cc - z * ss, z * cc + y * ss);
x *= rad0 / z;
y *= rad0 / z;
}
cx[r][z][0] = x;
fixed camera-rotated aura for stretch
2020-11-05 17:26:37 +00:00
cx[r][z][1] = y * pconf.stretch;
implemented auras for Joukowsky projections in transition
2018-10-26 19:05:35 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int u=0; u<3; u++)
cx[r][z][u+2] = bak[u] + (aurac[rm][u] / (aurac[rm][3]+.1) - bak[u]) * cmul[z];
}
Works online now!
2018-02-11 18:08:17 +00:00
auravertices.clear();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int r=0; r<AURA; r++) for(int z=0;z<10;z++) {
Works online now!
2018-02-11 18:08:17 +00:00
for(int c=0; c<6; c++) {
int br = (c == 1 || c == 3 || c == 5) ? r+1 : r;
int bz = (c == 2 || c == 4 || c == 5) ? z+1 : z;
auravertices.emplace_back(
cx[br][bz][0], cx[br][bz][1], cx[br][bz][2], cx[br][bz][3], cx[br][bz][4]
);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
faster graphics with MINIMIZE_GL_CALLS
2018-09-04 21:27:27 +00:00
glflush();
redesigned shader system
2019-10-21 20:34:20 +00:00
current_display->next_shader_flags = GF_VARCOLOR;
dynamicval<eModel> m(pmodel, mdPixel);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
current_display->set_all(0, 0);
glhr::id is now a constant; streamlined applymatrix
2018-02-20 10:30:39 +00:00
glhr::id_modelview();
Works online now!
2018-02-11 18:08:17 +00:00
glhr::prepare(auravertices);
improved the quality of 3D models from conformal menu
2018-03-24 14:15:30 +00:00
glhr::set_depthtest(false);
renamed the size function to isize
2018-06-22 12:47:24 +00:00
glDrawArrays(GL_TRIANGLES, 0, isize(auravertices));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
#endif
}
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// int fnt[100][7];
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool bugsNearby(cell *c, int dist = 2) {
if(!(havewhat&HF_BUG)) return false;
if(isBug(c)) return true;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(dist) for(int t=0; t<c->type; t++) if(c->move(t) && bugsNearby(c->move(t), dist-1)) return true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return false;
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX colortable minecolors = {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
0xFFFFFF, 0xF0, 0xF060, 0xF00000,
fixed mines when more than 7 adjacent mines
2019-04-08 12:56:46 +00:00
0x60, 0x600000, 0x00C0C0, 0x000000, 0x808080, 0xFFD500
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
};
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX colortable distcolors = {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
0xFFFFFF, 0xF0, 0xF060, 0xF00000,
0xA0A000, 0xA000A0, 0x00A0A0, 0xFFD500
};
Updated to 8.3j
2016-08-26 09:58:03 +00:00
more XLAT refactoring, and preparation for gentrans.cpp
2021-05-23 13:47:45 +00:00
EX const char* minetexts[8] = {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
"No mines next to you.",
"A mine is next to you!",
"Two mines next to you!",
"Three mines next to you!",
"Four mines next to you!",
"Five mines next to you!",
"Six mines next to you!",
"Seven mines next to you!"
};
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX int countMinesAround(cell *c) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int mines = 0;
mine adjacency rule can be changed (in 2D for now)
2019-04-08 12:58:54 +00:00
for(cell *c2: adj_minefield_cells(c))
if(c2->wall == waMineMine)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
mines++;
return mines;
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more header cleanup
2019-08-09 21:08:42 +00:00
EX transmatrix applyPatterndir(cell *c, const patterns::patterninfo& si) {
renamed binary:: to bt:: and binarytiling to bt::in()
2019-12-14 11:05:01 +00:00
if(NONSTDVAR || bt::in()) return Id;
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
transmatrix V = ddspin(c, si.dir, M_PI);
fixed some rotation bugs
2018-08-20 00:03:43 +00:00
if(si.reflect) V = V * Mirror;
rewritten the Euclidean geometry
2019-11-27 00:01:20 +00:00
if(euclid) return V;
fixed some rotation bugs
2018-08-20 00:03:43 +00:00
return V * iddspin(c, 0, M_PI);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX transmatrix applyDowndir(cell *c, const cellfunction& cf) {
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
return ddspin(c, patterns::downdir(c, cf), M_PI);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
movement arrows drawn correctly only in the target direction even if multiple
2019-11-22 18:00:11 +00:00
void draw_movement_arrows(cell *c, const transmatrix& V, int df) {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(viewdists) return;
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
string keylist = "";
const ld keysize = .6;
color_t col = getcs().uicolor;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int d=0; d<8; d++) {
refactored all the operations on View
2019-08-24 16:14:38 +00:00
movedir md = vectodir(spin(-d * M_PI/4) * smalltangent());
movement arrows drawn correctly only in the target direction even if multiple
2019-11-22 18:00:11 +00:00
cellwalker xc = cwt + md.d;
if(xc.spin != df) continue;
xc += wstep;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(xc.at == c) {
improved keyboard control in orthogonal projection of the sphere
2018-07-23 14:07:27 +00:00
transmatrix fixrot = sphereflip * rgpushxto0(sphereflip * tC0(V));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// make it more transparent
col -= (col & 0xFF) >> 1;
poly_outline = OUTLINE_DEFAULT;
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
char key = 0;
if(vid.axes >= 5)
key = (vid.axes == 5 ? keys_wasd : keys_vi)[d];
if(vid.axes >= 5) keylist += key;
else
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
queuepoly(shiftless(fixrot * spin(-d * M_PI/4)), cgi.shArrow, col);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
variant:: first version
2018-12-16 23:04:59 +00:00
if((c->type & 1) && (isStunnable(c->monst) || isPushable(c->wall))) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
transmatrix Centered = rgpushxto0(unshift(tC0(cwtV)));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int sd = md.subdir;
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
optimized inverses
2020-09-16 03:57:05 +00:00
transmatrix T = iso_inverse(Centered) * rgpushxto0(Centered * tC0(V)) * rspintox(Centered*tC0(V)) * spin(-sd * M_PI/S7) * xpush(0.2);
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
if(vid.axes >= 5)
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
queuestr(shiftless(T), keysize, s0 + key, col >> 8, 1);
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
else
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
queuepoly(shiftless(T), cgi.shArrow, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
else if(!confusingGeometry()) break;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
if(keylist != "") queuestr(shiftless(V), keysize, keylist, col >> 8, 1);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int celldistAltPlus(cell *c) { return 1000000 + celldistAlt(c); }
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool drawstaratvec(double dx, double dy) {
return dx*dx+dy*dy > .05;
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX color_t reptilecolor(cell *c) {
fixed some lands in Archimedean dual
2018-08-30 14:08:05 +00:00
int i;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
replaced 'archimedean' with 'arcm::in()'
2019-12-14 10:42:16 +00:00
if(arcm::in())
fixed some lands in Archimedean dual
2018-08-30 14:08:05 +00:00
i = c->master->rval0 & 3;
else {
fixed a crash bug when displaying Reptiles
2018-08-31 02:18:58 +00:00
i = zebra40(c);
fixed some lands in Archimedean dual
2018-08-30 14:08:05 +00:00
rewritten the Euclidean geometry
2019-11-27 00:01:20 +00:00
if(!euclid) {
fixed some lands in Archimedean dual
2018-08-30 14:08:05 +00:00
if(i >= 4 && i < 16) i = 0;
else if(i >= 16 && i < 28) i = 1;
else if(i >= 28 && i < 40) i = 2;
else i = 3;
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
color_t reptilecolors[4] = {0xe3bb97, 0xc2d1b0, 0xebe5cb, 0xA0A0A0};
return reptilecolors[i];
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
ld wavefun(ld x) {
return sin(x);
/* x /= (2*M_PI);
x -= (int) x;
if(x > .5) return (x-.5) * 2;
else return 0; */
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
further cleanup
2019-08-10 08:57:14 +00:00
EX colortable nestcolors = { 0x800000, 0x008000, 0x000080, 0x404040, 0x700070, 0x007070, 0x707000, 0x606060 };
Snakes Nest v1
2017-12-05 18:43:45 +00:00
customizable colors for game objects
2018-11-08 20:56:06 +00:00
color_t floorcolors[landtypes];
removed init.cpp
2019-09-05 07:01:47 +00:00
EX void init_floorcolors() {
customizable colors for game objects
2018-11-08 20:56:06 +00:00
for(int i=0; i<landtypes; i++)
floorcolors[i] = linf[i].color;
floorcolors[laDesert] = 0xEDC9AF;
floorcolors[laKraken] = 0x20A020;
floorcolors[laDocks] = 0x202020;
floorcolors[laCA] = 0x404040;
floorcolors[laMotion] = 0xF0F000;
floorcolors[laGraveyard] = 0x107010;
floorcolors[laWineyard] = 0x006000;
floorcolors[laLivefjord] = 0x306030;
floorcolors[laMinefield] = 0x80A080;
floorcolors[laCaribbean] = 0x006000;
floorcolors[laAlchemist] = 0x202020;
floorcolors[laRlyeh] = 0x004080;
floorcolors[laHell] = 0xC00000;
floorcolors[laCrossroads] = 0xFF0000;
floorcolors[laJungle] = 0x008000;
floorcolors[laZebra] = 0xE0E0E0;
floorcolors[laCaves] = 0x202020;
floorcolors[laEmerald] = 0x202020;
floorcolors[laDeadCaves] = 0x202020;
floorcolors[laPalace] = 0x806020;
floorcolors[laHunting] = 0x40E0D0 / 2;
floorcolors[laBlizzard] = 0x5050C0;
floorcolors[laCocytus] = 0x80C0FF;
floorcolors[laIce] = 0x8080FF;
floorcolors[laCamelot] = 0xA0A0A0;
floorcolors[laOvergrown] = 0x00C020;
floorcolors[laClearing] = 0x60E080;
floorcolors[laHaunted] = 0x609F60;
floor color for laCursed
2021-05-23 13:53:52 +00:00
floorcolors[laCursed] = 0x481848;
brought back the color for laDice
2021-05-29 18:08:25 +00:00
floorcolors[laDice] = 0xC0C0FF;
customizable colors for game objects
2018-11-08 20:56:06 +00:00
floor color for laCursed
2021-05-23 13:53:52 +00:00
floorcolors[laMirror] = floorcolors[laMirrorWall] = floorcolors[laMirrorOld] = 0x808080;
customizable colors for game objects
2018-11-08 20:56:06 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX color_t magma_color(int id) {
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
if(id == 95/4-1) return 0x200000;
else if(id == 95/4) return 0x100000;
else if(id < 48/4) return gradient(0xF0F000, 0xF00000, 0, id, 48/4);
else if(id < 96/4) return gradient(0xF00000, 0x400000, 48/4, id, 95/4-2);
else return winf[waMagma].color;
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool noAdjacentChasms(cell *c) {
forCellEx(c2, c) if(c2->wall == waChasm) return false;
return true;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
whirl:: Crystal World and Caves tiling work
2018-04-04 10:46:40 +00:00
// does the current geometry allow nice duals
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool has_nice_dual() {
geometry flags part 1
2019-02-17 17:28:20 +00:00
#if CAP_IRR
instead of nonbitrunc, gp::on and irr::on, there is one variable, variation
2018-08-28 15:17:34 +00:00
if(IRREGULAR) return irr::bitruncations_performed > 0;
geometry flags part 1
2019-02-17 17:28:20 +00:00
#endif
#if CAP_ARCM
replaced 'archimedean' with 'arcm::in()'
2019-12-14 10:42:16 +00:00
if(arcm::in()) return geosupport_football() >= 2;
geometry flags part 1
2019-02-17 17:28:20 +00:00
#endif
renamed binary:: to bt:: and binarytiling to bt::in()
2019-12-14 11:05:01 +00:00
if(bt::in()) return false;
instead of nonbitrunc, gp::on and irr::on, there is one variable, variation
2018-08-28 15:17:34 +00:00
if(BITRUNCATED) return true;
gp:: Warped Coast and Crystal World do not work in a4
2018-07-10 19:55:54 +00:00
if(a4) return false;
instead of nonbitrunc, gp::on and irr::on, there is one variable, variation
2018-08-28 15:17:34 +00:00
if((S7 & 1) == 0) return true;
if(PURE) return false;
geometry flags part 1
2019-02-17 17:28:20 +00:00
#if CAP_GP
renamed whirl to goldberg
2018-04-09 15:40:12 +00:00
return (gp::param.first + gp::param.second * 2) % 3 == 0;
geometry flags part 1
2019-02-17 17:28:20 +00:00
#else
return false;
#endif
whirl:: Crystal World and Caves tiling work
2018-04-04 10:46:40 +00:00
}
// does the current geometry allow nice duals
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool is_nice_dual(cell *c) {
whirl:: Crystal World and Caves tiling work
2018-04-04 10:46:40 +00:00
return c->land == laDual && has_nice_dual();
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool use_swapped_duals() {
rewritten the Euclidean geometry
2019-11-27 00:01:20 +00:00
return (euclid && !a4) || GOLDBERG;
whirl:: Crystal World and Caves tiling work
2018-04-04 10:46:40 +00:00
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void floorShadow(cell *c, const shiftmatrix& V, color_t col) {
shadows are now drawn or not correctly -- depending on model_needs_depth()
2019-02-22 20:27:42 +00:00
if(model_needs_depth() || noshadow)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return; // shadows break the depth testing
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
dynamicval<color_t> p(poly_outline, OUTLINE_TRANS);
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
if(qfi.shape) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepolyat(V * qfi.spin * cgi.shadowmulmatrix, *qfi.shape, col, PPR::WALLSHADOW);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Fixed mapediting floorshapes. Also works nicely for all geometries now. Enum used for shapegroups.
2018-08-27 17:27:35 +00:00
else if(qfi.usershape >= 0)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
mapeditor::drawUserShape(V * qfi.spin * cgi.shadowmulmatrix, mapeditor::sgFloor, qfi.usershape, col, c, PPR::WALLSHADOW);
shadows are actually fixed now
2018-08-18 16:01:41 +00:00
else
enum class used for PPR
2018-08-28 12:27:23 +00:00
draw_shapevec(c, V, qfi.fshape->shadow, col, PPR::WALLSHADOW);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX bool use_warp_graphics() {
in randomwalk/total chaos modes, special graphics are no longer used for Warped Coast
2019-10-05 16:46:58 +00:00
if(shmup::on) return false;
if(geosupport_football() != 2) return false;
choice of the land structure
2021-04-11 20:15:40 +00:00
if(ls::chaoticity() >= 75) return false;
in randomwalk/total chaos modes, special graphics are no longer used for Warped Coast
2019-10-05 16:46:58 +00:00
return true;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void escherSidewall(cell *c, int sidepar, const shiftmatrix& V, color_t col) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(sidepar >= SIDE_SLEV && sidepar <= SIDE_SLEV+2) {
int sl = sidepar - SIDE_SLEV;
for(int z=1; z<=4; z++) if(z == 1 || (z == 4 && detaillevel == 2))
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
draw_qfi(c, mscale(V, zgrad0(cgi.slev * sl, cgi.slev * (sl+1), z, 4)), col, PPR::REDWALL-4+z+4*sl);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(sidepar == SIDE_WALL) {
const int layers = 2 << detaillevel;
for(int z=1; z<layers; z++)
enum class used for PPR
2018-08-28 12:27:23 +00:00
draw_qfi(c, mscale(V, zgrad0(0, geom3::actual_wall_height(), z, layers)), col, PPR::WALL3+z-layers);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(sidepar == SIDE_LAKE) {
const int layers = 1 << (detaillevel-1);
if(detaillevel) for(int z=0; z<layers; z++)
moved the parameters from geom3:: to videopar
2019-05-29 14:27:24 +00:00
draw_qfi(c, mscale(V, zgrad0(-vid.lake_top, 0, z, layers)), col, PPR::FLOOR+z-layers);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(sidepar == SIDE_LTOB) {
const int layers = 1 << (detaillevel-1);
if(detaillevel) for(int z=0; z<layers; z++)
moved the parameters from geom3:: to videopar
2019-05-29 14:27:24 +00:00
draw_qfi(c, mscale(V, zgrad0(-vid.lake_bottom, -vid.lake_top, z, layers)), col, PPR::INLAKEWALL+z-layers);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(sidepar == SIDE_BTOI) {
const int layers = 1 << detaillevel;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
draw_qfi(c, mscale(V, cgi.INFDEEP), col, PPR::MINUSINF);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int z=1; z<layers; z++)
moved the parameters from geom3:: to videopar
2019-05-29 14:27:24 +00:00
draw_qfi(c, mscale(V, zgrad0(-vid.lake_bottom, -vid.lake_top, -z, 1)), col, PPR::LAKEBOTTOM+z-layers);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX bool placeSidewall(cell *c, int i, int sidepar, const shiftmatrix& V, color_t col) {
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(!qfi.fshape || !qfi.fshape->is_plain || !cgi.validsidepar[sidepar] || qfi.usershape >= 0) if(GDIM == 2) {
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
escherSidewall(c, sidepar, V, col);
return true;
started working on the 'Dual Land'
2017-10-29 22:54:26 +00:00
}
2d3d:: no sidewalls if no qfi.fshape
2019-05-10 00:52:04 +00:00
if(!qfi.fshape) return true;
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(qfi.fshape == &cgi.shBigTriangle && pseudohept(c->move(i))) return false;
if(qfi.fshape == &cgi.shTriheptaFloor && !pseudohept(c) && !pseudohept(c->move(i))) return false;
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
fixed a crash when drawing inventory items while drawcell is also NULL; priority functions now use PPR_DEFAULT not -1; priority is passed as PPR not int
2018-08-28 11:45:11 +00:00
PPR prio;
enum class used for PPR
2018-08-28 12:27:23 +00:00
/* if(mirr) prio = PPR::GLASS - 2;
else */ if(sidepar == SIDE_WALL) prio = PPR::WALL3 - 2;
else if(sidepar == SIDE_WTS3) prio = PPR::WALL3 - 2;
else if(sidepar == SIDE_LAKE) prio = PPR::LAKEWALL;
else if(sidepar == SIDE_LTOB) prio = PPR::INLAKEWALL;
else if(sidepar == SIDE_BTOI) prio = PPR::BELOWBOTTOM;
shallow water graphics and mechanics
2020-02-26 00:15:30 +00:00
else if(sidepar == SIDE_ASHA) prio = PPR::ASHALLOW;
else if(sidepar == SIDE_BSHA) prio = PPR::BSHALLOW;
enum class used for PPR
2018-08-28 12:27:23 +00:00
else prio = PPR::REDWALL-2+4*(sidepar-SIDE_SLEV);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
kite-and-dart tiling
2019-07-25 10:24:02 +00:00
dynamicval<bool> ncor(approx_nearcorner, true);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = V * ddspin_side(c, i);
kite:: sidewalls were not arranged correctly
2020-03-21 08:28:16 +00:00
remplace euclid6, euclid4, 'euclid && \!archimedean && \!penrose' with standard_tiling(), euc::in(dimension, s7)
2019-12-14 10:26:03 +00:00
if(NONSTDVAR || !standard_tiling()) {
geometry flags part 1
2019-02-17 17:28:20 +00:00
#if CAP_ARCM
replaced 'archimedean' with 'arcm::in()'
2019-12-14 10:42:16 +00:00
if(arcm::in() && !PURE)
removed the MAX_EDGE limit
2020-01-18 15:03:32 +00:00
i = gmod(i + arcm::parent_index_of(c->master)/DUALMUL, c->type);
geometry flags part 1
2019-02-17 17:28:20 +00:00
#endif
introduced rulegen.cpp which generates strict_tree_rules for arb
2021-07-29 12:07:30 +00:00
if(currentmap->strict_tree_rules()) {
i = rulegen::get_arb_dir(c, i);
}
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
draw_shapevec(c, V2, qfi.fshape->gpside[sidepar][i], col, prio);
return false;
}
started working on the 'Dual Land'
2017-10-29 22:54:26 +00:00
standard binary tiling, also improved the looks of variant binary tiling, and optimized shvid for pure
2019-07-22 09:21:27 +00:00
queuepolyat(V2, qfi.fshape->side[sidepar][shvid(c)], col, prio);
MAJOR REWRITE of floor patterns
2018-05-07 18:13:56 +00:00
return false;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool openorsafe(cell *c) {
extra guards
2020-10-15 14:33:52 +00:00
#if CAP_COMPLEX2
subdivided game.cpp; split movepcto into separate functions
2019-12-08 18:17:28 +00:00
return c->wall == waMineOpen || mine::marked_safe(c);
extra guards
2020-10-15 14:33:52 +00:00
#else
return false;
#endif
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
#define Dark(x) darkena(x,0,0xFF)
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
further cleanup
2019-08-09 21:39:36 +00:00
EX color_t stdgridcolor = 0x202020FF;
grid color is now configurable (stdgridcolor)
2019-03-08 21:40:34 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int gridcolor(cell *c1, cell *c2) {
more drawing tool improvements; no crash drawing tool; restart editors will ask for confirmation
2020-04-17 18:34:49 +00:00
if(cmode & sm::DRAW && !mapeditor::drawing_tool) return Dark(forecolor);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!c2)
return 0x202020 >> darken;
int rd1 = rosedist(c1), rd2 = rosedist(c2);
if(rd1 != rd2) {
int r = rd1+rd2;
if(r == 1) return Dark(0x802020);
if(r == 3) return Dark(0xC02020);
if(r == 2) return Dark(0xF02020);
other changes in 9.4n
2017-06-18 16:51:46 +00:00
}
racing: in SpaceRocks
2019-05-21 23:13:54 +00:00
if(chasmgraph(c1) != chasmgraph(c2) && c1->land != laAsteroids && c2->land != laAsteroids)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return Dark(0x808080);
fixed grid markers for Alchemists when items appear
2017-12-21 14:14:54 +00:00
if(c1->land == laAlchemist && c2->land == laAlchemist && c1->wall != c2->wall && !c1->item && !c2->item)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return Dark(0xC020C0);
if((c1->land == laWhirlpool || c2->land == laWhirlpool) && (celldistAlt(c1) != celldistAlt(c2)))
return Dark(0x2020A0);
if(c1->land == laMinefield && c2->land == laMinefield && (openorsafe(c1) != openorsafe(c2)))
return Dark(0xA0A0A0);
grid color is now configurable (stdgridcolor)
2019-03-08 21:40:34 +00:00
if(!darken) return stdgridcolor;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
return Dark(0x202020);
other changes in 9.4n
2017-06-18 16:51:46 +00:00
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void pushdown(cell *c, int& q, const shiftmatrix &V, double down, bool rezoom, bool repriority) {
fixed pushdown
2019-05-08 18:40:41 +00:00
2d3d:: missing guards
2019-05-10 01:16:40 +00:00
#if MAXMDIM >= 4
fixed pushdown
2019-05-08 18:40:41 +00:00
if(GDIM == 3) {
for(int i=q; i<isize(ptds); i++) {
auto pp = dynamic_cast<dqi_poly*> (&*ptds[q++]);
if(!pp) continue;
auto& ptd = *pp;
2D3D: switch without changing the display
2019-05-08 23:39:32 +00:00
ptd.V = ptd.V * zpush(+down);
fixed pushdown
2019-05-08 18:40:41 +00:00
}
return;
}
2d3d:: missing guards
2019-05-10 01:16:40 +00:00
#endif
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// since we might be changing priorities, we have to make sure that we are sorting correctly
if(down > 0 && repriority) {
int qq = q+1;
renamed the size function to isize
2018-06-22 12:47:24 +00:00
while(qq < isize(ptds))
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
if(qq > q && ptds[qq]->prio < ptds[qq-1]->prio) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
swap(ptds[qq], ptds[qq-1]);
qq--;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else qq++;
other changes in 9.4n
2017-06-18 16:51:46 +00:00
}
renamed the size function to isize
2018-06-22 12:47:24 +00:00
while(q < isize(ptds)) {
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
auto pp = dynamic_cast<dqi_poly*> (&*ptds[q++]);
if(!pp) continue;
auto& ptd = *pp;
double z2;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
double z = zlevel(tC0(ptd.V.T));
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
double lev = geom3::factor_to_lev(z);
double nlev = lev - down;
double xyscale = rezoom ? geom3::scale_at_lev(lev) / geom3::scale_at_lev(nlev) : 1;
z2 = geom3::lev_to_factor(nlev);
double zscale = z2 / z;
// xyscale = xyscale + (zscale-xyscale) * (1+sin(ticks / 1000.0)) / 2;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
ptd.V.T = xyzscale( V.T, xyscale*zscale, zscale)
optimized inverses
2020-09-16 03:57:05 +00:00
* z_inverse(V.T) * unshift(ptd.V, V.shift);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
if(!repriority) ;
moved the parameters from geom3:: to videopar
2019-05-29 14:27:24 +00:00
else if(nlev < -vid.lake_bottom-1e-3) {
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
ptd.prio = PPR::BELOWBOTTOM_FALLANIM;
if(c->wall != waChasm)
ptd.color = 0; // disappear!
}
moved the parameters from geom3:: to videopar
2019-05-29 14:27:24 +00:00
else if(nlev < -vid.lake_top-1e-3)
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
ptd.prio = PPR::INLAKEWALL_FALLANIM;
else if(nlev < 0)
ptd.prio = PPR::LAKEWALL_FALLANIM;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// 1 : (floor, water); 2 : (water, bottom); 4 : (bottom, inf)
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int shallow(cell *c) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(cellUnstable(c)) return 0;
else if(
c->wall == waReptile) return 1;
else if(c->wall == waReptileBridge ||
c->wall == waGargoyleFloor ||
c->wall == waGargoyleBridge ||
c->wall == waTempFloor ||
c->wall == waTempBridge ||
Orb of Stone over water produces bridges now. You can use Orb of Matter over temporary bridge again to create a wall. Fixed some ways of producing permanent land in the Whirlpool.
2017-09-03 10:01:31 +00:00
c->wall == waPetrifiedBridge ||
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
c->wall == waFrozenLake)
return 5;
return 7;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool allemptynear(cell *c) {
if(c->wall) return false;
forCellEx(c2, c) if(c2->wall) return false;
return true;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool bright;
'-bright' option
2018-03-25 16:33:21 +00:00
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
// how much to darken
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int getfd(cell *c) {
'-bright' option
2018-03-25 16:33:21 +00:00
if(bright) return 0;
Eclectic in 3D
2020-02-26 00:40:40 +00:00
if(among(c->land, laAlchemist, laHell, laVariant, laEclectic) && WDIM == 2 && GDIM == 3) return 0;
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
switch(c->land) {
case laRedRock:
case laReptile:
case laCanvas:
return 0;
Snakes Nest v1
2017-12-05 18:43:45 +00:00
case laSnakeNest:
return realred(c->wall) ? 0 : 1;
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
case laTerracotta:
case laMercuryRiver:
improved mercury rivers in 2D mode
2017-10-17 18:41:17 +00:00
return (c->wall == waMercury && wmspatial) ? 0 : 1;
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
case laKraken:
new land: Docks
2017-12-29 00:10:47 +00:00
case laDocks:
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
case laBurial:
case laIvoryTower:
case laDungeon:
case laMountain:
case laEndorian:
case laCaribbean:
case laWhirlwind:
case laRose:
case laWarpSea:
case laTortoise:
case laDragon:
case laHalloween:
case laHunting:
case laOcean:
case laLivefjord:
case laWhirlpool:
case laAlchemist:
case laIce:
case laGraveyard:
case laBlizzard:
case laRlyeh:
case laTemple:
case laWineyard:
case laDeadCaves:
case laPalace:
case laCA:
more work on the Crystal World
2017-10-30 08:05:16 +00:00
case laDual:
brownian:: more serious work
2018-10-25 00:43:14 +00:00
case laBrownian:
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
return 1;
Cherenkov radiation
2019-01-11 01:25:54 +00:00
case laVariant:
if(isWateryOrBoat(c)) return 1;
return 2;
nicer bridges over mercury
2017-10-17 10:54:59 +00:00
case laTrollheim:
default:
return 2;
}
}
Snakes Nest v1
2017-12-05 18:43:45 +00:00
further cleanup
2019-08-10 08:57:14 +00:00
EX bool just_gmatrix;
whirl:: Crystal World and Caves tiling work
2018-04-04 10:46:40 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int colorhash(color_t i) {
subcodes can be (de)selected in the pattern selection
2018-08-30 17:14:04 +00:00
return (i * 0x471211 + i*i*0x124159 + i*i*i*0x982165) & 0xFFFFFF;
}
further cleanup
2019-08-10 08:57:14 +00:00
EX bool isWall3(cell *c, color_t& wcol) {
3d:: more things shown as walls, worms also use wall graphics
2019-02-27 13:43:42 +00:00
if(isWall(c)) return true;
3d:: out-of-memory chasms are displayed as hard walls (faster racing)
2019-02-27 17:37:26 +00:00
if(c->wall == waChasm && c->land == laMemory) { wcol = 0x606000; return true; }
3d:: more things shown as walls, worms also use wall graphics
2019-02-27 13:43:42 +00:00
if(c->wall == waInvisibleFloor) return false;
3d:: weird walls now display as rings (passable) or sawrings (impassable)
2019-02-27 15:36:56 +00:00
// if(chasmgraph(c)) return true;
3d:: minefield displays correctly
2019-03-02 00:19:52 +00:00
if(among(c->wall, waMirror, waCloud, waMineUnknown, waMineMine)) return true;
3d:: more things shown as walls, worms also use wall graphics
2019-02-27 13:43:42 +00:00
return false;
}
wall optimization option (-wallopt): do not draw things behind walls
2019-10-12 09:21:00 +00:00
EX bool isWall3(cell *c) { color_t dummy; return isWall3(c, dummy); }
refactored celldraw
2019-10-25 10:44:41 +00:00
EX bool isSulphuric(eWall w) { return among(w, waSulphur, waSulphurC); }
3d:: water etc are now drawn as transparent walls
2019-03-04 17:01:48 +00:00
3d:: improved transwall coloring
2019-03-10 17:38:55 +00:00
// 'land color', but a bit twisted for Alchemist Lab
color_t lcolor(cell *c) {
if(isAlch(c->wall) && !c->item) return winf[c->wall].color;
return floorcolors[c->land];
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX color_t transcolor(cell *c, cell *c2, color_t wcol) {
3d:: improved transwall coloring
2019-03-10 17:38:55 +00:00
color_t dummy;
if(isWall3(c2, dummy)) return 0;
3d:: the option to restrict generation no longer produces weird elements
2019-04-13 11:30:09 +00:00
if(c->land != c2->land && c->land != laNone && c2->land != laNone) {
3d:: improved transwall coloring
2019-03-10 17:38:55 +00:00
if(c>c2) return 0;
3d: fixed transparent walls between lands
2019-05-11 15:21:17 +00:00
if(c->land == laBarrier) return darkena3(lcolor(c2), 0, 0x40);
if(c2->land == laBarrier) return darkena3(lcolor(c), 0, 0x40);
return darkena3(gradient(lcolor(c), lcolor(c2), 0, 1, 2), 0, 0x40);
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
}
solv:: Vineyard
2019-07-30 11:01:41 +00:00
if(sol && c->land == laWineyard && c2->master->distance < c->master->distance)
return 0x00800040;
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
if(isAlch(c) && !c->item && (c2->item || !isAlch(c2))) return darkena3(winf[c->wall].color, 0, 0x40);
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
if(c->wall == c2->wall) return 0;
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
if(isFire(c) && !isFire(c2)) return darkena3(wcol, 0, 0x30);
if(c->wall == waLadder) return darkena3(wcol, 0, 0x30);
better display of trapdoors in Zebra 3D
2020-01-28 12:01:42 +00:00
if(c->land == laZebra && c2->land == laZebra && c2->wall == waTrapdoor) return 0x202020A0;
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
3d:: improved transwall coloring
2019-03-10 17:38:55 +00:00
if(c->wall == waChasm && c2->wall != waChasm) return 0x606060A0;
if(isWateryOrBoat(c) && !isWateryOrBoat(c2)) return 0x0000C060;
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
if(isSulphuric(c->wall) && !isSulphuric(c2->wall)) return darkena3(winf[c->wall].color, 0, 0x40);
3d:: Yendorian Forest
2019-03-23 21:25:35 +00:00
if(among(c->wall, waCanopy, waSolidBranch, waWeakBranch) && !among(c2->wall, waCanopy, waSolidBranch, waWeakBranch)) return 0x00C00060;
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
if(c->wall == waFloorA && c2->wall == waFloorB && !c->item && !c2->item) return darkena3(0xFF00FF, 0, 0x80);
improved Red Rock and other heights display in 3D
2019-08-07 22:20:02 +00:00
if(realred(c->wall) || realred(c2->wall)) {
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
int l = snakelevel(c) - snakelevel(c2);
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
if(l > 0) return darkena3(floorcolors[laRedRock], 0, 0x30 * l);
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
}
improved Red Rock and other heights display in 3D
2019-08-07 22:20:02 +00:00
if(among(c->wall, waRubble, waDeadfloor2) && !snakelevel(c2)) return darkena3(winf[c->wall].color, 0, 0x40);
removed transparency from monsters in 3D
2019-04-20 23:06:37 +00:00
if(c->wall == waMagma && c2->wall != waMagma) return darkena3(magma_color(lavatide(c, -1)/4), 0, 0x80);
3d:: transparent-wall coloring now more precise, and takes land barriers into account
2019-03-09 22:55:03 +00:00
return 0;
3d:: water etc are now drawn as transparent walls
2019-03-04 17:01:48 +00:00
}
3d:: miniwalls used for weird stuff
2019-02-27 15:29:30 +00:00
// how much should be the d-th wall darkened in 3D
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int get_darkval(cell *c, int d) {
hybrid:: refactored the common parts of prod and sl2, also used them when applicable
2019-08-24 12:07:46 +00:00
if(hybri) {
product:: darkval
2019-08-18 19:30:52 +00:00
return d >= c->type - 2 ? 4 : 0;
}
3d:: all the regular honeycombs
2019-03-02 23:43:31 +00:00
const int darkval_hbt[9] = {0,2,2,0,6,6,8,8,0};
const int darkval_s12[12] = {0,1,2,3,4,5,0,1,2,3,4,5};
two more Euclidean honeycombs; also split buildpolys into subfunctions
2019-03-01 17:53:20 +00:00
const int darkval_e6[6] = {0,4,6,0,4,6};
const int darkval_e12[12] = {0,4,6,0,4,6,0,4,6,0,4,6};
const int darkval_e14[14] = {0,0,0,4,6,4,6,0,0,0,6,4,6,4};
3d:: horohex geometry
2019-03-13 12:12:49 +00:00
const int darkval_hh[14] = {0,0,0,1,1,1,2,2,2,3,3,3,1,0};
const int darkval_hrec[7] = {0,0,2,4,2,4,0};
fixed transwall coloring inconsistencies
2019-07-25 21:08:04 +00:00
const int darkval_sol[8] = {0,2,4,4,0,2,4,4};
asonov:: changed direct checking of gArnoldCat to asonov::in()
2019-11-08 14:34:51 +00:00
const int darkval_arnold[12] = {0,2,0,2,4,5,0,2,0,2,4,5};
renamed penrose.cpp to kite.cpp and 'penrose' to 'kite::in()'
2019-12-14 11:12:24 +00:00
const int darkval_kite[12] = {0, 2, 0, 2, 4, 4, 6, 6, 6, 6, 6, 6};
nilv:: darkval
2019-08-06 19:01:37 +00:00
const int darkval_nil[8] = {6,6,0,3,6,6,0,3};
non-isotropic hyperbolic space
2019-10-01 03:03:46 +00:00
const int darkval_nih[11] = {0,2,0,2,4,6,6,6,6,6,6};
reg3:: new variation, bch_oct
2021-07-13 13:12:03 +00:00
if(among(variation, eVariation::dual_subcubes, eVariation::bch, eVariation::bch_oct)) {
renamed get_face_vertices to get_face_vertex_count, and added new get_face_vertices
2021-07-07 21:32:22 +00:00
int v = reg3::get_face_vertex_count(c, d);
basic darkval for subcubes
2021-07-07 16:26:14 +00:00
return v-3;
}
3d:: all the regular honeycombs
2019-03-02 23:43:31 +00:00
if(sphere) return darkval_s12[d];
two more Euclidean honeycombs; also split buildpolys into subfunctions
2019-03-01 17:53:20 +00:00
if(euclid && S7 == 6) return darkval_e6[d];
if(euclid && S7 == 12) return darkval_e12[d];
if(euclid && S7 == 14) return darkval_e14[d];
3d:: horohex geometry
2019-03-13 12:12:49 +00:00
if(geometry == gHoroHex) return darkval_hh[d];
if(geometry == gHoroRec) return darkval_hrec[d];
renamed penrose.cpp to kite.cpp and 'penrose' to 'kite::in()'
2019-12-14 11:12:24 +00:00
if(kite::in()) return darkval_kite[d];
asonov:: added a geometry flag to recognize Arnold's cat
2021-03-25 09:57:48 +00:00
if(asonov::in()) return darkval_arnold[d];
fixed transwall coloring inconsistencies
2019-07-25 21:08:04 +00:00
if(sol) return darkval_sol[d];
non-isotropic hyperbolic space
2019-10-01 03:03:46 +00:00
if(nih) return darkval_nih[d];
renamed binary:: to bt:: and binarytiling to bt::in()
2019-12-14 11:05:01 +00:00
if(bt::in()) return darkval_hbt[d];
3d:: all the regular honeycombs
2019-03-02 23:43:31 +00:00
if(hyperbolic && S7 == 6) return darkval_e6[d];
if(hyperbolic && S7 == 12) return darkval_s12[d];
nilv:: darkval
2019-08-06 19:01:37 +00:00
if(nil) return darkval_nil[d];
3d:: all the regular honeycombs
2019-03-02 23:43:31 +00:00
return 0;
3d:: miniwalls used for weird stuff
2019-02-27 15:29:30 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX ld mousedist(shiftmatrix T) {
if(GDIM == 2) return hdist(mouseh, tC0(T));
shiftpoint T1 = tC0(mscale(T, cgi.FLOOR));
if(mouseaim_sensitivity) return sqhypot_d(2, T1.h) + (point_behind(T1) ? 1e10 : 0);
2d3d:: mouse reading
2019-05-09 15:02:50 +00:00
hyperpoint h1;
applymodel(T1, h1);
h1 = h1 - hpxy((mousex - current_display->xcenter) / current_display->radius, (mousey - current_display->ycenter) / current_display->radius);
cleaned up invis_point -> point_behind and invalid_point(transmatrix), also implemented for Solv
2019-07-31 14:14:01 +00:00
return sqhypot_d(2, h1) + (point_behind(T1) ? 1e10 : 0);
2d3d:: mouse reading
2019-05-09 15:02:50 +00:00
}
frustum culling in VR
2021-03-09 15:04:53 +00:00
vector<vector<hyperpoint>> clipping_plane_sets;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX int noclipped;
3d:: do not draw cells outside of view
2019-05-11 13:06:48 +00:00
frustum_culling can now be disabled
2020-05-25 00:27:23 +00:00
EX bool frustum_culling = true;
frustum culling in VR
2021-03-09 15:04:53 +00:00
EX ld threshold, xyz_threshold;
EX bool clip_checked = false;
3d:: do not draw cells outside of view
2019-05-11 13:06:48 +00:00
void make_clipping_planes() {
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
frustum culling in VR
2021-03-09 15:04:53 +00:00
clip_checked = false;
fixed incorrect clipping in H2xE
2021-04-07 19:04:25 +00:00
if(!frustum_culling || PIU(sphere) || experimental || vid.stereo_mode == sODS || panini_alpha || stereo_alpha || prod) return;
initial implementation of VR
2020-11-19 17:20:06 +00:00
frustum culling in VR
2021-03-09 15:04:53 +00:00
if(WDIM == 3 && pmodel == mdPerspective && !nonisotropic && !in_s2xe())
threshold = sin_auto(cgi.corner_bonus), xyz_threshold = 0, clip_checked = true;
else if(pmodel == mdGeodesic && sn::in())
threshold = .6, xyz_threshold = 3, clip_checked = true;
else if(pmodel == mdGeodesic && nil)
threshold = 2, xyz_threshold = 3, clip_checked = true;
else return;
CLI option -uqf
2021-07-07 16:26:40 +00:00
frustum culling in VR
2021-03-09 15:04:53 +00:00
clipping_plane_sets.clear();
auto add_clipping_plane_txy = [] (transmatrix T, const transmatrix& nlp, ld x1, ld y1, ld x2, ld y2) {
3d:: do not draw cells outside of view
2019-05-11 13:06:48 +00:00
ld z1 = 1, z2 = 1;
hyperpoint sx = point3(y1 * z2 - y2 * z1, z1 * x2 - z2 * x1, x1 * y2 - x2 * y1);
sx /= hypot_d(3, sx);
sx[3] = 0;
frustum culling in VR
2021-03-09 15:04:53 +00:00
sx = T * sx;
if(nisot::local_perspective_used()) sx = ortho_inverse(nlp) * sx;
clipping_plane_sets.back().push_back(sx);
};
another missing CAP_VR guard
2021-03-09 15:22:22 +00:00
#if CAP_VR
frustum culling in VR
2021-03-09 15:04:53 +00:00
auto add_clipping_plane_proj = [&] (transmatrix T, const transmatrix& nlp, const transmatrix& iproj, ld x1, ld y1, ld x2, ld y2) {
hyperpoint h1 = iproj * point31(x1, y1, .5);
hyperpoint h2 = iproj * point31(x2, y2, .5);
h1 /= h1[2]; h2 /= h2[2];
add_clipping_plane_txy(T, nlp, h1[0], h1[1], h2[0], h2[1]);
};
another missing CAP_VR guard
2021-03-09 15:22:22 +00:00
#endif
frustum culling in VR
2021-03-09 15:04:53 +00:00
auto clipping_planes_screen = [&] (const transmatrix& T, const transmatrix& nlp) {
ld tx = current_display->tanfov;
ld ty = tx * current_display->ysize / current_display->xsize;
clipping_plane_sets.push_back({});
add_clipping_plane_txy(T, nlp, +tx, +ty, -tx, +ty);
add_clipping_plane_txy(T, nlp, -tx, +ty, -tx, -ty);
add_clipping_plane_txy(T, nlp, -tx, -ty, +tx, -ty);
add_clipping_plane_txy(T, nlp, +tx, -ty, +tx, +ty);
3d:: do not draw cells outside of view
2019-05-11 13:06:48 +00:00
};
frustum culling in VR
2021-03-09 15:04:53 +00:00
bool stdview = true;
#if CAP_VR
if(vrhr::active()) {
for(auto p: vrhr::frusta) {
if(p.screen)
clipping_planes_screen(inverse(p.pre), p.nlp);
else {
auto iproj = inverse(p.proj);
auto ipre = inverse(p.pre);
clipping_plane_sets.push_back({});
add_clipping_plane_proj(ipre, p.nlp, iproj, 1, 1, 0, 1);
add_clipping_plane_proj(ipre, p.nlp, iproj, 0, 1, 0, 0);
add_clipping_plane_proj(ipre, p.nlp, iproj, 0, 0, 1, 0);
add_clipping_plane_proj(ipre, p.nlp, iproj, 1, 0, 1, 1);
}
stdview = false;
}
}
#endif
if(stdview) clipping_planes_screen(Id, NLP);
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
3d:: do not draw cells outside of view
2019-05-11 13:06:48 +00:00
}
frustum culling in VR
2021-03-09 15:04:53 +00:00
bool clipped_by(const hyperpoint& H, const vector<hyperpoint>& v) {
for(auto& cpoint: v) if((H|cpoint) < -threshold) return true;
return false;
}
bool clipped_by(const hyperpoint& H, const vector<vector<hyperpoint>>& vv) {
for(auto& cps: vv) if(!clipped_by(H, cps)) return false;
return true;
}
refactored celldraw
2019-10-25 10:44:41 +00:00
bool celldrawer::cell_clipped() {
frustum culling in VR
2021-03-09 15:04:53 +00:00
if(!clip_checked) return false;
hyperpoint H = unshift(tC0(V));
if(xyz_threshold && abs(H[0]) <= xyz_threshold && abs(H[1]) <= xyz_threshold && abs(H[2]) <= xyz_threshold) {
refactored celldraw
2019-10-25 10:44:41 +00:00
noclipped++;
frustum culling in VR
2021-03-09 15:04:53 +00:00
return false;
refactored celldraw
2019-10-25 10:44:41 +00:00
}
frustum culling in VR
2021-03-09 15:04:53 +00:00
if(clipped_by(H, clipping_plane_sets)) {
drawcell_in_radar();
return true;
refactored celldraw
2019-10-25 10:44:41 +00:00
}
frustum culling in VR
2021-03-09 15:04:53 +00:00
noclipped++;
refactored celldraw
2019-10-25 10:44:41 +00:00
return false;
}
precise_width for nicer long lines
2020-01-02 15:51:32 +00:00
EX ld precise_width = .5;
fixed a freeze when drawing offscreen grid lines
2020-01-19 10:49:35 +00:00
int grid_depth = 0;
fat edges in linepatterns in 3D
2020-01-25 23:48:56 +00:00
EX bool fat_edges = false;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void gridline(const shiftmatrix& V1, const hyperpoint h1, const shiftmatrix& V2, const hyperpoint h2, color_t col, int prec) {
transmatrix U2 = unshift(V2, V1.shift);
ld d = hdist(V1.T*h1, U2*h2);
fat edges in linepatterns in 3D
2020-01-25 23:48:56 +00:00
added MAXMDIM guards
2020-01-29 17:18:51 +00:00
#if MAXMDIM >= 4
fat edges in linepatterns in 3D
2020-01-25 23:48:56 +00:00
if(WDIM == 3 && fat_edges) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix T = V1 * rgpushxto0(h1);
transmatrix S = rspintox(inverse_shift(T, V2) * h2);
fat edges are now printable
2020-04-15 14:21:30 +00:00
auto& p = queuepoly(T * S, cgi.generate_pipe(d, vid.linewidth), col);
p.intester = xpush0(d/2);
fat edges in linepatterns in 3D
2020-01-25 23:48:56 +00:00
return;
}
added MAXMDIM guards
2020-01-29 17:18:51 +00:00
#endif
fat edges in linepatterns in 3D
2020-01-25 23:48:56 +00:00
fixed a freeze when drawing offscreen grid lines
2020-01-19 10:49:35 +00:00
while(d > precise_width && d < 100 && grid_depth < 10) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
if(V1.shift != V2.shift || !eqmatrix(V1.T, V2.T, 1e-6)) { gridline(V1, h1, V1, inverse_shift(V1, V2) * h2, col, prec); return; }
precise_width for nicer long lines
2020-01-02 15:51:32 +00:00
hyperpoint h = midz(h1, h2);
fixed a freeze when drawing offscreen grid lines
2020-01-19 10:49:35 +00:00
grid_depth++;
precise_width for nicer long lines
2020-01-02 15:51:32 +00:00
gridline(V1, h1, V1, h, col, prec);
gridline(V1, h, V1, h2, col, prec);
fixed a freeze when drawing offscreen grid lines
2020-01-19 10:49:35 +00:00
grid_depth--;
precise_width for nicer long lines
2020-01-02 15:51:32 +00:00
return;
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
refactored grid, and made it display nicely in 2d3d
2019-05-11 17:43:46 +00:00
if(WDIM == 2 && GDIM == 3) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
ld eps = cgi.human_height/100;
queueline(V1*orthogonal_move(h1,cgi.FLOOR+eps), V2*orthogonal_move(h2,cgi.FLOOR+eps), col, prec);
queueline(V1*orthogonal_move(h1,cgi.WALL-eps), V2*orthogonal_move(h2,cgi.WALL-eps), col, prec);
refactored grid, and made it display nicely in 2d3d
2019-05-11 17:43:46 +00:00
}
else
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
2D3D:: fixed grids
2019-05-21 23:13:02 +00:00
queueline(V1*h1, V2*h2, col, prec);
2d3d:: gridline used by linepatterns
2019-05-11 21:53:16 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void gridline(const shiftmatrix& V, const hyperpoint h1, const hyperpoint h2, color_t col, int prec) {
2D3D:: fixed grids
2019-05-21 23:13:02 +00:00
gridline(V, h1, V, h2, col, prec);
refactored grid, and made it display nicely in 2d3d
2019-05-11 17:43:46 +00:00
}
full cellshape computed in hybrid geometries
2021-07-12 18:54:16 +00:00
EX subcellshape& generate_subcellshape_if_needed(cell *c, int id) {
if(isize(cgi.subshapes) <= id) cgi.subshapes.resize(id+1);
auto& ss = cgi.subshapes[id];
if(!ss.faces.empty()) return ss;
cell *c1 = hybri ? hybrid::get_where(c).first : c;
if(prod || WDIM == 2) for(int i=0; i<c1->type; i++) {
hyperpoint w;
auto f = [&] {
/* mirror image of C0 in the axis h1-h2 */
hyperpoint h1 = get_corner_position(c1, i);
hyperpoint h2 = get_corner_position(c1, i+1);
transmatrix T = gpushxto0(h1);
T = spintox(T * h2) * T;
w = T * C0;
w[1] = -w[1];
w = iso_inverse(T) * w;
};
if(prod) PIU(f());
else f();
ss.walltester.push_back(w);
}
for(int i=0; i<c1->type; i++)
ss.faces.push_back({hybrid::get_corner(c1, i, 0, -1), hybrid::get_corner(c1, i, 0, +1), hybrid::get_corner(c1, i, 1, +1), hybrid::get_corner(c1, i, 1, -1)});
for(int a: {0,1}) {
vector<hyperpoint> l;
int z = a ? 1 : -1;
hyperpoint ctr = zpush0(z * cgi.plevel/2);
for(int i=0; i<c1->type; i++)
if(prod || WDIM == 2)
l.push_back(hybrid::get_corner(c1, i, 0, z));
else {
l.push_back(ctr);
l.push_back(hybrid::get_corner(c1, i, 0, z));
l.push_back(hybrid::get_corner(c1, i+1, 1, z));
l.push_back(ctr);
l.push_back(hybrid::get_corner(c1, i, 1, z));
l.push_back(hybrid::get_corner(c1, i, 0, z));
}
if(a == 0) std::reverse(l.begin()+1, l.end());
ss.faces.push_back(l);
}
ss.compute_hept();
return ss;
}
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
int hrmap::wall_offset(cell *c) {
int id = currentmap->full_shvid(c);
fixed Nil and Sol
2021-07-09 15:09:04 +00:00
if(WDIM == 3 && !hybri && !reg3::in()) return 0;
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
if(isize(cgi.walloffsets) <= id) cgi.walloffsets.resize(id+1, {-1, nullptr});
auto &wop = cgi.walloffsets[id];
int &wo = wop.first;
if(!wop.second) wop.second = c;
if(wo == -1) {
full cellshape computed in hybrid geometries
2021-07-12 18:54:16 +00:00
auto& ss = generate_subcellshape_if_needed(c, id);
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
wo = isize(cgi.shWall3D);
full cellshape computed in hybrid geometries
2021-07-12 18:54:16 +00:00
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
if(!cgi.wallstart.empty()) cgi.wallstart.pop_back();
full cellshape computed in hybrid geometries
2021-07-12 18:54:16 +00:00
cgi.reserve_wall3d(wo + isize(ss.faces));
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
full cellshape computed in hybrid geometries
2021-07-12 18:54:16 +00:00
for(int i=0; i<isize(ss.faces); i++) {
cgi.make_wall(wo + i, ss.faces[i]);
cgi.walltester[wo + i] = ss.walltester[i];
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
}
full cellshape computed in hybrid geometries
2021-07-12 18:54:16 +00:00
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
cgi.wallstart.push_back(isize(cgi.raywall));
cgi.compute_cornerbonus();
cgi.extra_vertices();
}
return wo;
3D:: support for drawing walls on multiple types of cells
2019-07-25 10:19:52 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void queue_transparent_wall(const shiftmatrix& V, hpcshape& sh, color_t color) {
3D:: improvements to transparency: works correctly (e.g. in 2D HoM), including models
2019-05-13 11:18:55 +00:00
auto& poly = queuepolyat(V, sh, color, PPR::TRANSPARENT_WALL);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftpoint h = V * sh.intester;
geodesics in Sol
2019-07-28 09:07:21 +00:00
if(in_perspective())
3D:: improvements to transparency: works correctly (e.g. in 2D HoM), including models
2019-05-13 11:18:55 +00:00
poly.subprio = int(hdist0(h) * 100000);
else {
hyperpoint h2;
applymodel(h, h2);
poly.subprio = int(h2[2] * 100000);
}
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
refactored celldraw
2019-10-25 10:44:41 +00:00
EX int ceiling_category(cell *c) {
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
switch(c->land) {
case laNone:
case laMemory:
case laMirrorWall2:
case laMirrored:
case laMirrored2:
case landtypes:
return 0;
/* starry levels */
case laIce:
case laCrossroads:
case laCrossroads2:
case laCrossroads3:
case laCrossroads4:
case laCrossroads5:
case laJungle:
case laGraveyard:
case laMotion:
case laRedRock:
case laZebra:
case laHunting:
case laEAir:
case laStorms:
case laMountain:
case laHaunted:
case laHauntedWall:
case laHauntedBorder:
case laWhirlwind:
case laBurial:
case laHalloween:
case laReptile:
case laVolcano:
case laBlizzard:
case laDual:
case laWestWall:
case laAsteroids:
return 1;
red power aura in Land of Power
2019-06-01 17:26:02 +00:00
case laPower:
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
case laWineyard:
case laDesert:
case laAlchemist:
case laDryForest:
case laCaribbean:
case laMinefield:
case laOcean:
case laWhirlpool:
case laLivefjord:
case laEWater:
case laOceanWall:
case laWildWest:
case laOvergrown:
case laClearing:
case laRose:
case laWarpCoast:
case laWarpSea:
case laEndorian:
case laTortoise:
case laPrairie:
better sky, sky color variation
2019-06-01 15:01:04 +00:00
case laDragon:
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
case laSnakeNest:
case laDocks:
case laKraken:
case laBrownian:
better sky, sky color variation
2019-06-01 15:01:04 +00:00
case laHell:
better sky in Irradiated
2019-06-13 15:25:11 +00:00
case laVariant:
fixed skies in the new lands
2020-05-15 23:06:47 +00:00
case laFrog:
case laWet:
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
return 2;
case laBarrier:
case laCaves:
case laMirror:
case laMirrorOld:
case laCocytus:
case laEmerald:
case laDeadCaves:
case laHive:
case laCamelot:
case laIvoryTower:
case laEFire:
case laEEarth:
case laElementalWall:
case laTrollheim:
case laDungeon:
case laBull:
case laCA:
case laMirrorWall:
case laTerracotta:
case laMercuryRiver:
case laMagnetic:
case laSwitch:
fixed skies in the new lands
2020-05-15 23:06:47 +00:00
case laEclectic:
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
return 3;
in canvas 2.5D, no ceiling if canvas_default_wall == waInvisibleFloor
2021-03-31 12:35:43 +00:00
case laCanvas:
if(canvas_default_wall == waInvisibleFloor) return 0;
return 3;
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
2D3D:: higher ceilings in the Palace
2019-05-24 23:36:49 +00:00
case laPalace:
R'Lyeh windows
2019-05-25 01:37:27 +00:00
case laPrincessQuest:
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
default:
return 4;
better sky for R'Lyeh, Temple, and Ruined City
2019-06-17 17:36:29 +00:00
case laRuins:
return 6;
case laTemple:
case laRlyeh:
return 7;
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
}
}
fixed MAXMDIM guards
2019-11-03 13:19:11 +00:00
#endif
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void set_detail_level(const shiftmatrix& V) {
refactored celldraw
2019-10-25 10:44:41 +00:00
ld dist0 = hdist0(tC0(V)) - 1e-6;
if(vid.use_smart_range) detaillevel = 2;
else if(dist0 < vid.highdetail) detaillevel = 2;
else if(dist0 < vid.middetail) detaillevel = 1;
else detaillevel = 0;
further cleanup
2019-08-09 23:56:00 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
if((cmode & sm::NUMBER) && (dialog::editingDetail())) {
color_t col =
dist0 < vid.highdetail ? 0xFF80FF80 :
dist0 >= vid.middetail ? 0xFFFF8080 :
0XFFFFFF80;
queuepoly(V, cgi.shHeptaMarker, darkena(col & 0xFFFFFF, 0, 0xFF));
better sky, sky color variation
2019-06-01 15:01:04 +00:00
}
}
refactored celldraw
2019-10-25 10:44:41 +00:00
struct flashdata {
int t;
int size;
cell *where;
double angle;
double angle2;
int spd; // 0 for flashes, >0 for particles
color_t color;
text bubbles
2019-12-25 21:01:57 +00:00
string text;
refactored celldraw
2019-10-25 10:44:41 +00:00
flashdata(int _t, int _s, cell *_w, color_t col, int sped) {
t=_t; size=_s; where=_w; color = col;
angle = rand() % 1000; spd = sped;
if(GDIM == 3) angle2 = acos((rand() % 1000 - 499.5) / 500);
better sky, sky color variation
2019-06-01 15:01:04 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
};
better sky, sky color variation
2019-06-01 15:01:04 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
vector<flashdata> flashes;
2D3D:: Euclidean skies
2019-05-28 23:06:01 +00:00
text bubbles
2019-12-25 21:01:57 +00:00
EX void drawBubble(cell *c, color_t col, string s, ld size) {
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( drawBubble(c, col, s, size); )
fixed a bug in drawBubble
2019-12-26 08:40:28 +00:00
auto fd = flashdata(ticks, 1000, c, col, 0);
text bubbles
2019-12-25 21:01:57 +00:00
fd.text = s;
fd.angle = size;
flashes.push_back(fd);
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX void drawFlash(cell *c) {
flashes.push_back(flashdata(ticks, 1000, c, iinf[itOrbFlash].color, 0));
better sky for R'Lyeh, Temple, and Ruined City
2019-06-17 17:36:29 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX void drawBigFlash(cell *c) {
flashes.push_back(flashdata(ticks, 2000, c, 0xC0FF00, 0));
2D3D:: skies and ceilings
2019-05-20 11:40:56 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX void drawParticleSpeed(cell *c, color_t col, int speed) {
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( drawParticleSpeed(c, col, speed); )
refactored celldraw
2019-10-25 10:44:41 +00:00
if(vid.particles && !confusingGeometry())
flashes.push_back(flashdata(ticks, rand() % 16, c, col, speed));
}
EX void drawParticle(cell *c, color_t col, int maxspeed IS(100)) {
drawParticleSpeed(c, col, 1 + rand() % maxspeed);
}
Orb of Plague improved
2020-02-29 19:20:08 +00:00
EX void drawDirectionalParticle(cell *c, int dir, color_t col, int maxspeed IS(100)) {
LATE( drawDirectionalParticle(c, dir, col, maxspeed); )
if(vid.particles && !confusingGeometry()) {
int speed = 1 + rand() % maxspeed;
auto fd = flashdata(ticks, rand() % 16, c, col, speed);
fd.angle = -atan2(tC0(currentmap->adj(c, dir)));
fd.angle += 2 * M_PI * (rand() % 100 - rand() % 100) / 100 / c->type;
flashes.push_back(fd);
}
}
refactored celldraw
2019-10-25 10:44:41 +00:00
EX void drawParticles(cell *c, color_t col, int qty, int maxspeed IS(100)) {
if(vid.particles)
while(qty--) drawParticle(c,col, maxspeed);
}
EX void drawFireParticles(cell *c, int qty, int maxspeed IS(100)) {
if(vid.particles)
for(int i=0; i<qty; i++)
drawParticle(c, firegradient(i / (qty-1.)), maxspeed);
}
EX void fallingFloorAnimation(cell *c, eWall w IS(waNone), eMonster m IS(moNone)) {
if(!wmspatial) return;
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( fallingFloorAnimation(c, w, m); )
refactored celldraw
2019-10-25 10:44:41 +00:00
fallanim& fa = fallanims[c];
fa.t_floor = ticks;
fa.walltype = w; fa.m = m;
// drawParticles(c, darkenedby(linf[c->land].color, 1), 4, 50);
}
EX void fallingMonsterAnimation(cell *c, eMonster m, int id IS(multi::cpid)) {
if(!mmspatial) return;
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( fallingMonsterAnimation(c, m, id); )
refactored celldraw
2019-10-25 10:44:41 +00:00
fallanim& fa = fallanims[c];
fa.t_mon = ticks;
fa.m = m;
fa.pid = id;
// drawParticles(c, darkenedby(linf[c->land].color, 1), 4, 50);
drawcell_in_radar factored out
2019-05-16 15:41:37 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
refactored celldraw
2019-10-25 10:44:41 +00:00
void celldrawer::draw_fallanims() {
removed outlines from falling stuff
2019-11-03 13:19:56 +00:00
poly_outline = OUTLINE_NONE;
refactored celldraw
2019-10-25 10:44:41 +00:00
if(fallanims.count(c)) {
int q = isize(ptds);
int maxtime = euclid || sphere ? 20000 : 1500;
fallanim& fa = fallanims[c];
bool erase = true;
if(fa.t_floor) {
int t = (ticks - fa.t_floor);
if(t <= maxtime) {
erase = false;
if(GDIM == 3)
draw_shapevec(c, V, qfi.fshape->levels[0], darkena(fcol, fd, 0xFF), PPR::WALL);
else if(fa.walltype == waNone) {
draw_qfi(c, V, darkena(fcol, fd, 0xFF), PPR::FLOOR);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
else {
celldrawer ddalt;
eWall w = c->wall; int p = c->wparam;
c->wall = fa.walltype; c->wparam = fa.m;
drawcell parameter is now cell, not cellwalker (need to check half-elliptic)
2019-11-25 19:05:52 +00:00
ddalt.c = c;
refactored celldraw
2019-10-25 10:44:41 +00:00
ddalt.setcolors();
int starcol = c->wall == waVinePlant ? 0x60C000 : ddalt.wcol;
c->wall = w; c->wparam = p;
draw_qfi(c, mscale(V, cgi.WALL), darkena(starcol, fd, 0xFF), PPR::WALL3);
queuepolyat(mscale(V, cgi.WALL), cgi.shWall[ct6], darkena(ddalt.wcol, 0, 0xFF), PPR::WALL3A);
forCellIdEx(c2, i, c)
if(placeSidewall(c, i, SIDE_WALL, V, darkena(ddalt.wcol, 1, 0xFF))) break;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
refactored celldraw
2019-10-25 10:44:41 +00:00
pushdown(c, q, V, t*t / 1000000. + t / 1000., true, true);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
refactored celldraw
2019-10-25 10:44:41 +00:00
if(fa.t_mon) {
dynamicval<int> d(multi::cpid, fa.pid);
int t = (ticks - fa.t_mon);
if(t <= maxtime) {
erase = false;
c->stuntime = 0;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V2 = V;
refactored celldraw
2019-10-25 10:44:41 +00:00
double footphase = t / 200.0;
applyAnimation(c, V2, footphase, LAYER_SMALL);
drawMonsterType(fa.m, c, V2, minf[fa.m].color, footphase, NOCOLOR);
pushdown(c, q, V2, t*t / 1000000. + t / 1000., true, true);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
refactored celldraw
2019-10-25 10:44:41 +00:00
if(erase) fallanims.erase(c);
}
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void queuecircleat1(cell *c, const shiftmatrix& V, double rad, color_t col) {
3D graphics in 2D (first commit)
2019-05-08 16:33:08 +00:00
if(WDIM == 3) {
3D:: movement in non-shmup
2019-02-26 10:57:50 +00:00
dynamicval<color_t> p(poly_outline, col);
refactored shvid_full and wall_offset as virtual functions
2021-07-09 08:09:31 +00:00
int ofs = currentmap->wall_offset(c);
3d:: do not draw 'catwalk' cursor in binary
2019-02-26 21:20:51 +00:00
for(int i=0; i<c->type; i++) {
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
queuepolyat(V, cgi.shWireframe3D[ofs + i], 0, PPR::SUPERLINE);
3d:: do not draw 'catwalk' cursor in binary
2019-02-26 21:20:51 +00:00
}
3D:: movement in non-shmup
2019-02-26 10:57:50 +00:00
return;
}
better cell-cursors; bad cell-cursors removed
2019-05-09 15:03:28 +00:00
if(spatial_graphics || GDIM == 3) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
vector<shiftmatrix> corners(c->type+1);
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
for(int i=0; i<c->type; i++) corners[i] = V * rgpushxto0(get_corner_position(c, i, 3 / rad));
better cell-cursors; bad cell-cursors removed
2019-05-09 15:03:28 +00:00
corners[c->type] = corners[0];
for(int i=0; i<c->type; i++) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queueline(mscale(corners[i], cgi.FLOOR) * C0, mscale(corners[i+1], cgi.FLOOR) * C0, col, 2, PPR::SUPERLINE);
queueline(mscale(corners[i], cgi.WALL) * C0, mscale(corners[i+1], cgi.WALL) * C0, col, 2, PPR::SUPERLINE);
queueline(mscale(corners[i], cgi.FLOOR) * C0, mscale(corners[i], cgi.WALL) * C0, col, 2, PPR::SUPERLINE);
better cell-cursors; bad cell-cursors removed
2019-05-09 15:03:28 +00:00
}
return;
}
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
if(vid.stereo_mode || sphere) {
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
dynamicval<color_t> p(poly_outline, col);
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
queuepolyat(V * spintick(100), cgi.shGem[1], 0, PPR::LINE);
queuecircleat now draws stars instead if stereo::mode or in spherical geometry
2018-07-23 12:04:32 +00:00
return;
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
queuecircle(V, rad, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!wmspatial) return;
if(highwall(c))
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
queuecircle(mscale(V, cgi.WALL), rad, col);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int sl;
if((sl = snakelevel(c))) {
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
queuecircle(mscale(V, cgi.SLEV[sl]), rad, col);
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(chasmgraph(c))
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
queuecircle(mscale(V, cgi.LAKE), rad, col);
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
EX void queuecircleat(cell *c, double rad, color_t col) {
if(!c) return;
Finish replacing macro ADC with plain old code.
2021-07-18 21:37:56 +00:00
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, c))
queuecircleat1(c, V, rad, col);
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
}
#endif
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Move all defaulting-of-`CAP_FOO` to sysconfig.h. - The phrase `#ifdef CAP_` should never appear anywhere. - The phrase `#ifndef CAP_` should appear only in sysconfig.h. - The phrases `#if CAP_` and `#if !CAP_` may appear wherever, as long as "sysconfig.h" is included first. The rules for `CAP_FOO` equally apply to `ISFOO`. There are many one-off macros still tested with `#ifdef`, including `HAVE_ACHIEVEMENTS`, `PRINT_ACHIEVEMENTS`, `FAKEWEB`, `FAKE_SDL`, `EASY`, and `WHATEVER`. I don't have much grasp on what these are used for or how they're configured, so I'm leaving them alone.
2020-05-03 18:56:41 +00:00
#if ISMOBILE
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
#define MOBON (clicked)
#else
#define MOBON true
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
#endif
more header cleanup
2019-08-09 20:07:03 +00:00
EX cell *forwardcell() {
initial implementation of VR
2020-11-19 17:20:06 +00:00
#if CAP_VR
replace vrhr::state checking with nicer functions
2020-12-30 13:20:30 +00:00
if(vrhr::active()) {
initial implementation of VR
2020-11-19 17:20:06 +00:00
return vrhr::forward_cell;
}
#endif
3D:: mouseover set correctly
2019-02-26 11:28:54 +00:00
movedir md = vectodir(move_destination_vec(6));
cellwalker xc = cwt + md.d + wstep;
return xc.at;
}
an option to disable drawing centerover
2020-09-15 17:13:51 +00:00
EX bool draw_centerover = true;
moved mouse-line from rug to drawMarkers
2020-12-30 02:26:01 +00:00
EX bool should_draw_mouse_cursor() {
if(!mousing || inHighQual) return false;
if(outofmap(mouseh.h)) return false;
if(rug::rugged && !rug::renderonce) return true;
return false;
}
more header cleanup
2019-08-09 20:07:03 +00:00
EX void drawMarkers() {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
highlight mode (Alt) no longer clears the marker
2017-10-15 22:43:23 +00:00
if(!(cmode & sm::NORMAL)) return;
moved mouse-line from rug to drawMarkers
2020-12-30 02:26:01 +00:00
if(should_draw_mouse_cursor()) {
more fixes to multiplayer
2021-03-06 10:46:13 +00:00
for(int i: player_indices()) {
moved mouse-line from rug to drawMarkers
2020-12-30 02:26:01 +00:00
queueline(ggmatrix(playerpos(i)) * (WDIM == 2 && GDIM == 3 ? zpush0(cgi.WALL) : C0), mouseh, 0xFF00FF, grid_prec() + 1);
}
}
Invinc monsters implemented
2018-01-02 10:15:42 +00:00
hooks in drawmarkers
2018-09-06 20:34:35 +00:00
callhooks(hooks_markers);
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
improved floorshape debugger
2018-08-18 15:38:07 +00:00
viewmat();
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
improved floorshape debugger
2018-08-18 15:38:07 +00:00
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
Invinc monsters implemented
2018-01-02 10:15:42 +00:00
for(cell *c1: crush_now)
queuecircleat(c1, .8, darkena(minf[moCrusher].color, 0, 0xFF));
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!inHighQual) {
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
bool ok = !ISPANDORA || mousepressed;
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
ignore(ok);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
Finish replacing macro ADC with plain old code.
2021-07-18 21:37:56 +00:00
if(haveMount())
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, dragon::target)) {
queuestr(V, 1, "X",
gradient(0, iinf[itOrbDomination].color, -1, sintick(dragon::whichturn == turncount ? 75 : 150), 1));
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
/* for(int i=0; i<12; i++) if(c->type == 5 && c->master == &dodecahedron[i])
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(xc, yc, sc, 4*vid.fsize, s0+('A'+i), iinf[itOrbDomination].color); */
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
if(1) {
using namespace yendor;
if(yii < isize(yi) && !yi[yii].found) {
cell *keycell = NULL;
int i;
for(i=0; i<YDIST; i++)
if(yi[yii].path[i]->cpdist <= get_sightrange_ambush()) {
keycell = yi[yii].path[i];
}
if(keycell) {
for(; i<YDIST; i++) {
cell *c = yi[yii].path[i];
if(inscreenrange(c))
keycell = c;
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftpoint H = tC0(ggmatrix(keycell));
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(H, 2*vid.fsize, "X", 0x10101 * int(128 + 100 * sintick(150)));
Yendor marker displays an approximate if celldistance returns DISTANCE_UNKNOWN
2019-08-02 20:09:45 +00:00
int cd = celldistance(yi[yii].key(), cwt.at);
if(cd == DISTANCE_UNKNOWN) for(int i2 = 0; i2<YDIST; i2++) {
int cd2 = celldistance(cwt.at, yi[yii].path[i2]);
if(cd2 != DISTANCE_UNKNOWN) {
cd = cd2 + (YDIST-1-i2);
println(hlog, "i2 = ", i2, " cd = ", celldistance(cwt.at, keycell));
}
}
queuestr(H, vid.fsize, its(cd), 0x10101 * int(128 - 100 * sintick(150)));
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
addauraspecial(H, iinf[itOrbYendor].color, 0);
10.0g
2017-08-06 12:50:16 +00:00
}
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
racing:: first commit
2018-11-17 18:30:50 +00:00
#if CAP_RACING
racing:: remembering ghost, track selection (with times), completion percentage shown
2018-11-24 14:35:02 +00:00
racing::markers();
racing:: first commit
2018-11-17 18:30:50 +00:00
#endif
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
3D graphics in 2D (first commit)
2019-05-08 16:33:08 +00:00
if(lmouseover && vid.drawmousecircle && ok && DEFAULTCONTROL && MOBON && WDIM == 2) {
pointing in 2D modes
2020-12-29 03:42:09 +00:00
cell *at = lmouseover;
#if CAP_VR
replace vrhr::state checking with nicer functions
2020-12-30 13:20:30 +00:00
if(vrhr::active() && vrhr::forward_cell)
pointing in 2D modes
2020-12-29 03:42:09 +00:00
at = vrhr::forward_cell;
#endif
queuecircleat(at, .8, darkena(lmouseover->cpdist > 1 ? 0x00FFFF : 0xFF0000, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
fixed turn-based multiplayer
2019-12-26 09:29:41 +00:00
if(global_pushto && vid.drawmousecircle && ok && DEFAULTCONTROL && MOBON && WDIM == 2) {
queuecircleat(global_pushto, .6, darkena(0xFFD500, 0, 0xFF));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_SDLJOY && CAP_QUEUE
3D graphics in 2D (first commit)
2019-05-08 16:33:08 +00:00
if(joydir.d >= 0 && WDIM == 2)
better system of syncing game animations
2018-09-10 15:49:51 +00:00
queuecircleat(cwt.at->modmove(joydir.d+cwt.spin), .78 - .02 * sintick(199),
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
darkena(0x00FF00, 0, 0xFF));
updated to 10.0c
2017-07-22 23:33:27 +00:00
#endif
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
bool m = true;
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
ignore(m);
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_MODEL
m = netgen::mode == 0;
#endif
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
an option to disable drawing centerover
2020-09-15 17:13:51 +00:00
if(centerover && !playermoved && m && !anims::any_animation() && WDIM == 2 && draw_centerover)
viewctr is no more... major reduction of redundancy/complexity
2019-11-13 23:26:50 +00:00
queuecircleat(centerover, .70 - .06 * sintick(200),
animation menu
2018-09-10 15:58:36 +00:00
darkena(int(175 + 25 * sintick(200)), 0, 0xFF));
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(multi::players > 1 || multi::alwaysuse) for(int i=0; i<numplayers(); i++) {
multi::cpid = i;
if(multi::players == 1) multi::player[i] = cwt;
cell *ctgt = multi::multiPlayerTarget(i);
better system of syncing game animations
2018-09-10 15:49:51 +00:00
queuecircleat(ctgt, .40 - .06 * sintick(200, i / numplayers()), getcs().uicolor);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// process mouse
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
if((vid.axes >= 4 || (vid.axes == 1 && !mousing)) && !shmup::on && GDIM == 2) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(multi::players == 1) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
forCellIdAll(c2, d, cwt.at) if(gmatrix.count(cwt.at)) draw_movement_arrows(c2, unshift(gmatrix[cwt.at]) * currentmap->adj(cwt.at, d), d);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
else if(multi::players > 1) for(int p=0; p<multi::players; p++) {
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
if(multi::playerActive(p) && (vid.axes >= 4 || !drawstaratvec(multi::mdx[p], multi::mdy[p])))
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
forCellIdAll(c2, d, multi::player[p].at) if(gmatrix.count(cwt.at)) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
multi::cpid = p;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
dynamicval<shiftmatrix> ttm(cwtV, multi::whereis[p]);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
dynamicval<cellwalker> tcw(cwt, multi::player[p]);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
draw_movement_arrows(c2, unshift(gmatrix[cwt.at]) * currentmap->adj(cwt.at, d), d);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
}
3D:: movement in non-shmup
2019-02-26 10:57:50 +00:00
added a separate option axes3 for highlighting forward, and in different location
2019-06-25 08:30:31 +00:00
if(GDIM == 3 && !inHighQual && !shmup::on && vid.axes3 && playermoved) {
3d:: mapeditor works
2019-02-26 13:56:07 +00:00
cell *c = forwardcell();
initial implementation of VR
2020-11-19 17:20:06 +00:00
if(c) queuecircleat(c, .8, getcs().uicolor);
3D:: movement in non-shmup
2019-02-26 10:57:50 +00:00
}
3d:: improved which 'circles' are drawn
2019-03-10 17:38:30 +00:00
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
hybrid:: refactored the common parts of prod and sl2, also used them when applicable
2019-08-24 12:07:46 +00:00
if(hybri && !shmup::on) {
product: Orb of the Sword
2019-08-19 08:55:02 +00:00
using namespace sword;
int& ang = sword::dir[multi::cpid].angle;
ang %= sword_angles;
int adj = 1 - ((sword_angles/cwt.at->type)&1);
Finish replacing macro ADC with plain old code.
2021-07-18 21:37:56 +00:00
if(items[itOrbSword])
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, cwt.at))
queuestr(V * spin(M_PI+(-adj-2*ang)*M_PI/sword_angles) * xpush0(cgi.sword_size), vid.fsize*2, "+", iinf[itOrbSword].color);
if(items[itOrbSword2])
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, cwt.at))
queuestr(V * spin((-adj-2*ang)*M_PI/sword_angles) * xpush0(-cgi.sword_size), vid.fsize*2, "+", iinf[itOrbSword2].color);
product: Orb of the Sword
2019-08-19 08:55:02 +00:00
}
if(SWORDDIM == 3 && !shmup::on) {
Finish replacing macro ADC with plain old code.
2021-07-18 21:37:56 +00:00
if(items[itOrbSword])
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, cwt.at))
queuestr(V * sword::dir[multi::cpid].T * xpush0(cgi.sword_size), vid.fsize*2, "+", iinf[itOrbSword].color);
if(items[itOrbSword2])
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, cwt.at))
queuestr(V * sword::dir[multi::cpid].T * xpush0(-cgi.sword_size), vid.fsize*2, "+", iinf[itOrbSword2].color);
Orb of the Sword in non-shmup 3D geometries
2019-06-24 20:28:20 +00:00
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
monsterToSummon = moNone;
orbToTarget = itNone;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
better mode handling
2017-07-12 17:50:39 +00:00
if(mouseover && targetclick) {
changed some shmup:: to multi::
2019-09-06 06:17:38 +00:00
multi::cpid = 0;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
orbToTarget = targetRangedOrb(mouseover, roCheck);
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(orbToTarget == itOrbSummon) {
monsterToSummon = summonedAt(mouseover);
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(mousex, mousey, 0, vid.fsize, s0+minf[monsterToSummon].glyph, minf[monsterToSummon].color);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
queuecircleat(mouseover, 0.6, darkena(minf[monsterToSummon].color, 0, 0xFF));
}
else if(orbToTarget) {
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(mousex, mousey, 0, vid.fsize, "@", iinf[orbToTarget].color);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
queuecircleat(mouseover, 0.6, darkena(iinf[orbToTarget].color, 0, 0xFF));
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(orbToTarget && rand() % 200 < ticks - lastt) {
if(orbToTarget == itOrbDragon)
drawFireParticles(mouseover, 2);
else if(orbToTarget == itOrbSummon) {
drawParticles(mouseover, iinf[orbToTarget].color, 1);
drawParticles(mouseover, minf[monsterToSummon].color, 1);
}
else {
drawParticles(mouseover, iinf[orbToTarget].color, 2);
}
}
graphical display of the paths for Orb of Air
2019-01-03 02:20:20 +00:00
if(items[itOrbAir] && mouseover->cpdist > 1) {
cell *c1 = mouseover;
for(int it=0; it<10; it++) {
int di;
more movei
2019-11-22 17:48:51 +00:00
auto mib = blowoff_destination(c1, di);
if(!mib.proper()) break;
auto& c2 = mib.t;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix T1 = ggmatrix(c1);
shiftmatrix T2 = ggmatrix(c2);
shiftmatrix T = T1 * rspintox(inverse_shift(T1,T2*C0)) * xpush(hdist(T1*C0, T2*C0) * fractick(50, 0));
graphical display of the paths for Orb of Air
2019-01-03 02:20:20 +00:00
color_t aircol = (orbToTarget == itOrbAir ? 0x8080FF40 : 0x8080FF20);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(T, cgi.shDisk, aircol);
graphical display of the paths for Orb of Air
2019-01-03 02:20:20 +00:00
c1 = c2;
}
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
void drawFlashes() {
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_QUEUE
renamed the size function to isize
2018-06-22 12:47:24 +00:00
for(int k=0; k<isize(flashes); k++) {
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
bool kill = true;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
flashdata& f = flashes[k];
fixed hunting flashes
2019-12-08 18:33:17 +00:00
bool copies = false;
Finish replacing macro ADC with plain old code.
2021-07-18 21:37:56 +00:00
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, f.where)) {
fixed hunting flashes
2019-12-08 18:33:17 +00:00
copies = true;
Finish replacing macro ADC with plain old code.
2021-07-18 21:37:56 +00:00
draw_flash(f, V, kill);
}
forCellIdEx(c2, id, f.where) {
if(!copies) {
for (const shiftmatrix& V : hr::span_at(current_display->all_drawn_copies, c2)) {
draw_flash(f, V * currentmap->iadj(f.where, id), kill);
copies = true;
}
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
fixed flashes disappearing
2020-04-06 07:48:34 +00:00
if(f.t > ticks - 800 && !copies) {
kill = false;
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(kill) {
renamed the size function to isize
2018-06-22 12:47:24 +00:00
f = flashes[isize(flashes)-1];
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
flashes.pop_back(); k--;
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
fixed hunting flashes
2019-12-08 18:33:17 +00:00
#if CAP_QUEUE
static_bubbles (always false)
2020-01-02 15:54:28 +00:00
always_false static_bubbles;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX void draw_flash(struct flashdata& f, const shiftmatrix& V, bool& kill) {
fixed hunting flashes
2019-12-08 18:33:17 +00:00
int tim = ticks - f.t;
static_bubbles (always false)
2020-01-02 15:54:28 +00:00
fixed hunting flashes
2019-12-08 18:33:17 +00:00
if(tim <= f.size && !f.spd) kill = false;
text bubbles
2019-12-25 21:01:57 +00:00
if(f.text != "") {
static_bubbles (always false)
2020-01-02 15:54:28 +00:00
if(static_bubbles) {
tim = 0; kill = false;
}
bubbles react to neon
2019-12-26 22:32:27 +00:00
color_t col = f.color;
dynamicval<color_t> p(poly_outline, poly_outline);
int r = 2;
apply_neon(col, r);
better bubbles
2019-12-25 22:10:36 +00:00
if(GDIM == 3 || sphere)
bubbles react to neon
2019-12-26 22:32:27 +00:00
queuestr(V, (1 - tim * 1. / f.size) * f.angle, f.text, col, r);
better bubbles
2019-12-25 22:10:36 +00:00
else if(!kill) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftpoint h = tC0(V);
better bubbles
2019-12-25 22:10:36 +00:00
if(hdist0(h) > .1) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
transmatrix V2 = rspintox(h.h) * xpush(hdist0(h.h) * (1 / (1 - tim * 1. / f.size)));
queuestr(shiftless(V2, h.shift), f.angle, f.text, col, r);
better bubbles
2019-12-25 22:10:36 +00:00
}
}
static_bubbles (always false)
2020-01-02 15:54:28 +00:00
if(static_bubbles) {
ld rad[25];
for(int a=0; a<24; a++) rad[a] = (0.5 + randd() * .3 + 0.5 * (a&1)) / (2.8 + celldistance(f.where, cwt.at) * .2);
rad[24] = rad[0];
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
for(int a=0; a<24; a++) curvepoint(xspinpush0(15 * degree * a, rad[a]));
queuecurve(V, 0xFF, 0xFF0000FF, PPR::SUPERLINE);
static_bubbles (always false)
2020-01-02 15:54:28 +00:00
}
text bubbles
2019-12-25 21:01:57 +00:00
}
else if(f.spd) {
fixed hunting flashes
2019-12-08 18:33:17 +00:00
#if CAP_SHAPES
if(tim <= 300) kill = false;
int partcol = darkena(f.color, 0, GDIM == 3 ? 255 : max(255 - tim*255/300, 0));
poly_outline = OUTLINE_DEFAULT;
ld t = f.spd * tim * cgi.scalefactor / 50000.;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix T =
fixed hunting flashes
2019-12-08 18:33:17 +00:00
GDIM == 2 ? V * spin(f.angle) * xpush(t) :
V * cspin(0, 1, f.angle) * cspin(0, 2, f.angle2) * cpush(2, t);
queuepoly(T, cgi.shParticle[f.size], partcol);
#endif
}
else if(f.size == 1000) {
for(int u=0; u<=tim; u++) {
if((u-tim)%50) continue;
if(u < tim-150) continue;
ld rad = u * 3 / 1000.;
rad = rad * (5-rad) / 2;
rad *= cgi.hexf;
int flashcol = f.color;
if(u > 500) flashcol = gradient(flashcol, 0, 500, u, 1100);
flashcol = darkena(flashcol, 0, 0xFF);
#if MAXMDIM >= 4
if(GDIM == 3)
queueball(V * zpush(cgi.GROIN1), rad, flashcol, itDiamond);
else
#endif
{
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
PRING(a) curvepoint(xspinpush0(a * M_PI / cgi.S42, rad));
queuecurve(V, flashcol, 0x8080808, PPR::LINE);
fixed hunting flashes
2019-12-08 18:33:17 +00:00
}
}
}
else if(f.size == 2000) {
for(int u=0; u<=tim; u++) {
if((u-tim)%50) continue;
if(u < tim-250) continue;
ld rad = u * 3 / 2000.;
rad = rad * (5-rad) * 1.25;
rad *= cgi.hexf;
int flashcol = f.color;
if(u > 1000) flashcol = gradient(flashcol, 0, 1000, u, 2200);
flashcol = darkena(flashcol, 0, 0xFF);
#if MAXMDIM >= 4
if(GDIM == 3)
queueball(V * zpush(cgi.GROIN1), rad, flashcol, itRuby);
else
#endif
{
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
PRING(a) curvepoint(xspinpush0(a * M_PI / cgi.S42, rad));
queuecurve(V, flashcol, 0x8080808, PPR::LINE);
fixed hunting flashes
2019-12-08 18:33:17 +00:00
}
}
}
}
#endif
more header cleanup
2019-08-09 20:07:03 +00:00
EX bool allowIncreasedSight() {
autocheat allows increased sight
2018-04-18 18:53:52 +00:00
if(cheater || autocheat) return true;
Sight range increase is now allowed in some of the special modes (not only the cheat mode)
2017-08-18 00:58:55 +00:00
if(peace::on) return true;
#if CAP_TOUR
if(tour::on) return true;
#endif
if(randomPatternsMode) return true;
racing:: increase range allowed
2019-01-11 14:01:36 +00:00
if(racing::on) return true;
sight range changing no longer considered cheating in arb
2020-03-22 11:02:58 +00:00
if(quotient || !hyperbolic || arcm::in() || arb::in()) return true;
3D graphics in 2D (first commit)
2019-05-08 16:33:08 +00:00
if(WDIM == 3) return true;
allowIncreasedSight now returns true after gameover
2020-04-02 10:56:26 +00:00
if(!canmove) return true;
Sight range increase is now allowed in some of the special modes (not only the cheat mode)
2017-08-18 00:58:55 +00:00
return false;
}
more header cleanup
2019-08-09 20:07:03 +00:00
EX bool allowChangeRange() {
... but only increased
2018-04-11 13:49:49 +00:00
if(cheater || peace::on || randomPatternsMode) return true;
#if CAP_TOUR
if(tour::on) return true;
#endif
racing:: increase range allowed
2019-01-11 14:01:36 +00:00
if(racing::on) return true;
sight range changing no longer considered cheating in arb
2020-03-22 11:02:58 +00:00
if(arcm::in() || arb::in()) return true;
3D graphics in 2D (first commit)
2019-05-08 16:33:08 +00:00
if(WDIM == 3) return true;
... but only increased
2018-04-11 13:49:49 +00:00
return false;
}
more header cleanup
2019-08-09 20:07:03 +00:00
EX purehookset hooks_drawmap;
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
more header cleanup
2019-08-09 20:07:03 +00:00
EX transmatrix actual_view_transform;
3d:: wallradar
2019-04-29 01:34:21 +00:00
product:: wallradar and TPP
2019-08-20 16:02:03 +00:00
EX ld wall_radar(cell *c, transmatrix T, transmatrix LPe, ld max) {
get_shiftview_of used gpush instead of rgpush; fixed wallradar
2019-08-25 18:45:27 +00:00
if(!in_perspective() || !vid.use_wall_radar) return max;
shmup for product: player movement
2019-08-26 07:06:39 +00:00
transmatrix ori;
optimized inverses
2020-09-16 03:57:05 +00:00
if(prod) ori = ortho_inverse(LPe);
centering/TPP/camera cleanup
2019-05-11 21:52:18 +00:00
ld step = max / 20;
3d:: wallradar
2019-04-29 01:34:21 +00:00
ld fixed_yshift = 0;
for(int i=0; i<20; i++) {
shmup for product: player movement
2019-08-26 07:06:39 +00:00
T = parallel_transport(T, ori, ztangent(-step));
removed the tohex parameter
2019-11-14 18:33:55 +00:00
virtualRebase(c, T);
3d:: wallradar
2019-04-29 01:34:21 +00:00
color_t col;
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
if(isWall3(c, col) || (WDIM == 2 && GDIM == 3 && tC0(T)[2] > cgi.FLOOR)) {
shmup for product: player movement
2019-08-26 07:06:39 +00:00
T = parallel_transport(T, ori, ztangent(step));
3d:: wallradar
2019-04-29 01:34:21 +00:00
step /= 2; i = 17;
if(step < 1e-3) break;
}
else fixed_yshift += step;
}
return fixed_yshift;
}
more header cleanup
2019-08-09 20:07:03 +00:00
EX void make_actual_view() {
magic adjustment of textures
2017-12-16 08:03:50 +00:00
sphereflip = Id;
product:: preliminary version (no turning)
2019-08-17 21:28:41 +00:00
if(sphereflipped()) sphereflip[LDIM][LDIM] = -1;
centering/TPP/camera cleanup
2019-05-11 21:52:18 +00:00
actual_view_transform = sphereflip;
if(vid.yshift && WDIM == 2) actual_view_transform = ypush(vid.yshift) * actual_view_transform;
2d3d:: missing guards
2019-05-10 01:16:40 +00:00
#if MAXMDIM >= 4
centering/TPP/camera cleanup
2019-05-11 21:52:18 +00:00
if(GDIM == 3) {
moved the parameters from geom3:: to videopar
2019-05-29 14:27:24 +00:00
ld max = WDIM == 2 ? vid.camera : vid.yshift;
product:: wallradar and TPP
2019-08-20 16:02:03 +00:00
if(max) {
optimized inverses
2020-09-16 03:57:05 +00:00
transmatrix Start = view_inverse(actual_view_transform * View);
nisot::local_perspective moved to display_data
2019-11-14 16:20:55 +00:00
ld d = wall_radar(centerover, Start, NLP, max);
optimized inverses
2020-09-16 03:57:05 +00:00
actual_view_transform = get_shift_view_of(ztangent(d), actual_view_transform * View) * view_inverse(View);
product:: wallradar and TPP
2019-08-20 16:02:03 +00:00
}
optimized inverses
2020-09-16 03:57:05 +00:00
camera_level = asin_auto(tC0(view_inverse(actual_view_transform * View))[2]);
centering/TPP/camera cleanup
2019-05-11 21:52:18 +00:00
}
nilv:: preliminary implementation
2019-08-06 10:00:46 +00:00
if(nonisotropic) {
solv:: third person perspective works now
2019-08-03 09:36:38 +00:00
transmatrix T = actual_view_transform * View;
optimized inverses
2020-09-16 03:57:05 +00:00
transmatrix T2 = eupush( tC0(view_inverse(T)) );
nisot::local_perspective moved to display_data
2019-11-14 16:20:55 +00:00
NLP = T * T2;
optimized inverses
2020-09-16 03:57:05 +00:00
actual_view_transform = ortho_inverse(NLP) * actual_view_transform;
solv:: third person perspective works now
2019-08-03 09:36:38 +00:00
}
2d3d:: missing guards
2019-05-10 01:16:40 +00:00
#endif
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#if MAXMDIM >= 4
mini-map correct in all circumstances, including vertical movement or y/z rotation
2019-05-24 19:42:30 +00:00
if(GDIM == 3 && WDIM == 2) {
transmatrix T = actual_view_transform * View;
optimized inverses
2020-09-16 03:57:05 +00:00
transmatrix U = view_inverse(T);
mini-map correct in all circumstances, including vertical movement or y/z rotation
2019-05-24 19:42:30 +00:00
if(T[0][2])
T = spin(-atan2(T[0][2], T[1][2])) * T;
if(T[1][2] && T[2][2])
T = cspin(1, 2, -atan2(T[1][2], T[2][2])) * T;
optimized inverses
2020-09-16 03:57:05 +00:00
ld z = -asin_auto(tC0(view_inverse(T)) [2]);
mini-map correct in all circumstances, including vertical movement or y/z rotation
2019-05-24 19:42:30 +00:00
T = zpush(-z) * T;
radar_transform = T * U;
}
added some missing CAP_* guards
2019-06-01 14:59:04 +00:00
#endif
fixed an issue in optimizeview for crystal334
2019-10-12 11:14:38 +00:00
Viewbase = View;
cview() called outside of draw -- this way it works with product
2019-08-20 14:09:16 +00:00
}
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
EX shiftmatrix cview(ld base_shift IS(0)) {
return shiftless(actual_view_transform * View, base_shift);
magic adjustment of textures
2017-12-16 08:03:50 +00:00
}
more header cleanup
2019-08-09 20:07:03 +00:00
EX void precise_mouseover() {
2d3d:: mouse reading
2019-05-09 15:02:50 +00:00
if(WDIM == 3) {
viewctr is no more... major reduction of redundancy/complexity
2019-11-13 23:26:50 +00:00
mouseover2 = mouseover = centerover;
3d:: mapeditor works
2019-02-26 13:56:07 +00:00
ld best = HUGE_VAL;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftpoint h = shiftless(direct_exp(lp_iapply(ztangent(0.01))));
hybrid::fixed precise_mouseover
2019-09-09 17:22:43 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix cov = ggmatrix(mouseover2);
fixed precise_mouseover for hybrid (something weird there?) and confusing spaces
2019-12-06 12:05:54 +00:00
forCellIdEx(c1, i, mouseover2) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftpoint h1 = tC0(cov * currentmap->adj(mouseover2, i));
ld dist = geo_dist(h, h1) - geo_dist(shiftless(C0), h1);
3d:: mapeditor works
2019-02-26 13:56:07 +00:00
if(dist < best) mouseover = c1, best = dist;
}
return;
}
precise mouseover computation
2018-08-19 20:53:51 +00:00
if(!mouseover) return;
2d3d:: mouse reading
2019-05-09 15:02:50 +00:00
if(GDIM == 3) return;
precise mouseover computation
2018-08-19 20:53:51 +00:00
cell *omouseover = mouseover;
for(int loop = 0; loop < 10; loop++) {
bool found = false;
if(!gmatrix.count(mouseover)) return;
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
hyperpoint r_mouseh = inverse_shift(gmatrix[mouseover], mouseh);
precise mouseover computation
2018-08-19 20:53:51 +00:00
for(int i=0; i<mouseover->type; i++) {
fixed precise_mouseover on sphere
2020-09-21 10:00:25 +00:00
hyperpoint h1 = get_corner_position(mouseover, gmod(i-1, mouseover->type));
precise mouseover computation
2018-08-19 20:53:51 +00:00
hyperpoint h2 = get_corner_position(mouseover, i);
fixed precise_mouseover on sphere
2020-09-21 10:00:25 +00:00
if(det3(build_matrix(h1, h2, C0, C0)) * det3(build_matrix(h1, h2, r_mouseh, C0)) < 0) {
precise mouseover computation
2018-08-19 20:53:51 +00:00
mouseover2 = mouseover;
mouseover = mouseover->move(i);
found = true;
break;
}
}
if(!found) return;
}
// probably some error... just return the original
mouseover = omouseover;
}
fixed an issue in optimizeview for crystal334
2019-10-12 11:14:38 +00:00
EX transmatrix Viewbase;
raycasting::: ray_comparison_mode
2019-10-23 21:10:50 +00:00
EX bool no_wall_rendering;
basic raycaster implementation
2019-10-21 22:37:57 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void drawthemap() {
cgi set in other places
2019-05-27 05:19:04 +00:00
check_cgi();
cgi.require_shapes();
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_GRAPH, ("draw the map"));
show borders on fires; limit particles if there are too many fires
2019-03-13 13:04:06 +00:00
last_firelimit = firelimit;
firelimit = 0;
work in progress for 10.0
2017-07-04 13:38:33 +00:00
fixed clipping planes affecting 2D geometries
2021-04-07 18:25:27 +00:00
make_clipping_planes();
3d:: radar feature
2019-02-28 15:24:46 +00:00
radarpoints.clear();
gridlines in radar
2019-05-30 08:43:17 +00:00
radarlines.clear();
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
callhooks(hooks_drawmap);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
frameid++;
smart display range
2018-11-01 17:59:25 +00:00
cells_drawn = 0;
fixed some issues with 'cells_generated_limit'
2019-05-15 13:49:09 +00:00
cells_generated = 0;
3d:: do not draw cells outside of view
2019-05-11 13:06:48 +00:00
noclipped = 0;
refactored first_cell_to_draw so that it is changed in one place
2019-05-11 17:42:30 +00:00
first_cell_to_draw = true;
10.0m, and some unfinished features for 10.1 ;)
2017-09-03 19:12:44 +00:00
split sight/game/generation range; bonuses instead of absolute values
2018-04-03 21:34:47 +00:00
if(sightrange_bonus > 0 && !allowIncreasedSight())
sightrange_bonus = 0;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
swap(gmatrix0, gmatrix);
gmatrix.clear();
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
current_display->all_drawn_copies.clear();
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
wmspatial = vid.wallmode == 4 || vid.wallmode == 5;
wmescher = vid.wallmode == 3 || vid.wallmode == 5;
wmplain = vid.wallmode == 2 || vid.wallmode == 4;
ASCII/3D mode, also reacts to neon settings
2020-01-30 16:45:05 +00:00
wmascii = vid.wallmode == 0 || vid.wallmode == 6;
wmascii3 = vid.wallmode == 6;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
wmblack = vid.wallmode == 1;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
mmitem = vid.monmode >= 1;
mmmon = vid.monmode >= 2;
separated highlight
2020-09-15 18:39:15 +00:00
mmspatial = vid.monmode >= 3;
mmhigh = vid.highlightmode >= 1;
if(hiliteclick) mmhigh = !mmhigh;
surface 3D graphics are now automatically disabled in rug (won't work correctly with quotient rugs anyway) and in pmodels which do not support it
2018-12-05 18:57:35 +00:00
spatial_graphics = wmspatial || mmspatial;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
spatial_graphics = spatial_graphics && GDIM == 2;
added some missing CAP_RUG flags
2019-02-17 17:45:42 +00:00
#if CAP_RUG
surface 3D graphics are now automatically disabled in rug (won't work correctly with quotient rugs anyway) and in pmodels which do not support it
2018-12-05 18:57:35 +00:00
if(rug::rugged && !rug::spatial_rug) spatial_graphics = false;
added some missing CAP_RUG flags
2019-02-17 17:45:42 +00:00
#endif
surface 3D graphics are now automatically disabled in rug (won't work correctly with quotient rugs anyway) and in pmodels which do not support it
2018-12-05 18:57:35 +00:00
if(non_spatial_model())
spatial_graphics = false;
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
if(pmodel == mdDisk && abs(pconf.alpha) < 1e-6) spatial_graphics = false;
surface 3D graphics are now automatically disabled in rug (won't work correctly with quotient rugs anyway) and in pmodels which do not support it
2018-12-05 18:57:35 +00:00
if(!spatial_graphics) wmspatial = mmspatial = false;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) wmspatial = mmspatial = true;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int m=0; m<motypes; m++) if(isPrincess(eMonster(m)))
minf[m].name = princessgender() ? "Princess" : "Prince";
basic raycaster implementation
2019-10-21 22:37:57 +00:00
fixed CAP_RAY guards
2020-03-21 18:05:17 +00:00
#if CAP_RAY
ray:: namespace and basic configurator
2019-10-25 12:50:48 +00:00
ray::in_use = ray::requested();
fixed MAXMDIM guards
2019-11-03 13:19:11 +00:00
#endif
ray:: namespace and basic configurator
2019-10-25 12:50:48 +00:00
no_wall_rendering = ray::in_use;
// ray::comparison_mode = true;
if(ray::comparison_mode) no_wall_rendering = false;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
iinf[itSavedPrincess].name = minf[moPrincess].name;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int i=0; i<NUM_GS; i++) {
genderswitch_t& g = genderswitch[i];
if(g.gender != princessgender()) continue;
minf[g.m].help = g.desc;
minf[g.m].name = g.name;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(mapeditor::autochoose) mapeditor::ew = mapeditor::ewsearch;
mapeditor::ewsearch.dist = 1e30;
modist = 1e20; mouseover = NULL;
modist2 = 1e20; mouseover2 = NULL;
further work for 10.0
2017-07-12 16:03:53 +00:00
cleaner sightrange
2018-04-11 11:16:40 +00:00
compute_graphical_distance();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int i=0; i<multi::players; i++) {
multi::ccdist[i] = 1e20; multi::ccat[i] = NULL;
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
downseek works in Euclidean now
2019-12-27 10:14:25 +00:00
downseek.reset();
10.0g
2017-08-06 12:50:16 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if ISMOBILE
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
mouseovers = XLAT("No info about this...");
#endif
2d3d:: mouse reading
2019-05-09 15:02:50 +00:00
if(mouseout() && !mousepan)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
modist = -5;
playerfound = false;
// playerfoundL = false;
// playerfoundR = false;
more work into Terracotta Army
2017-10-04 19:26:26 +00:00
arrowtraps.clear();
Updated to 8.3j
2016-08-26 09:58:03 +00:00
cview() called outside of draw -- this way it works with product
2019-08-20 14:09:16 +00:00
make_actual_view();
redone hrmap::draw() function to keep DRY
2020-07-27 17:36:19 +00:00
currentmap->draw_all();
improved Worm/Tentacle/Snake graphics
2018-01-11 22:18:02 +00:00
drawWormSegments();
new lands for 10.1 -- initial commit
2017-09-30 09:46:41 +00:00
drawBlizzards();
more work into Terracotta Army
2017-10-04 19:26:26 +00:00
drawArrowTraps();
precise mouseover computation
2018-08-19 20:53:51 +00:00
precise_mouseover();
10.0
2017-07-16 21:00:55 +00:00
ivoryz = false;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
linepatterns::drawAll();
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
callhooks(hooks_frame);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawMarkers();
drawFlashes();
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
drawing tool
2020-04-17 18:04:33 +00:00
mapeditor::draw_dtshapes();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(multi::players > 1 && !shmup::on) {
changed some shmup:: to multi::
2019-09-06 06:17:38 +00:00
if(multi::centerplayer != -1)
cwtV = multi::whereis[multi::centerplayer];
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else {
hyperpoint h;
for(int i=0; i<3; i++) h[i] = 0;
for(int p=0; p<multi::players; p++) if(multi::playerActive(p)) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
hyperpoint h1 = unshift(tC0(multi::whereis[p]));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int i=0; i<3; i++) h[i] += h1[i];
}
h = mid(h, h);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
cwtV = shiftless(rgpushxto0(h));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated to 8.3j
2016-08-26 09:58:03 +00:00
}
expansion, ctrl+E cheat, fix with distance calculation
2017-04-04 09:13:15 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(shmup::on) {
changed some shmup:: to multi::
2019-09-06 06:17:38 +00:00
if(multi::players == 1)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
cwtV = shmup::pc[0]->pat;
changed some shmup:: to multi::
2019-09-06 06:17:38 +00:00
else if(multi::centerplayer != -1)
cwtV = shmup::pc[multi::centerplayer]->pat;
expansion, ctrl+E cheat, fix with distance calculation
2017-04-04 09:13:15 +00:00
else {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
hyperpoint h;
for(int i=0; i<3; i++) h[i] = 0;
for(int p=0; p<multi::players; p++) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
hyperpoint h1 = unshift(tC0(shmup::pc[p]->pat));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int i=0; i<3; i++) h[i] += h1[i];
}
h = mid(h, h);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
cwtV = shiftless(rgpushxto0(h));
expansion, ctrl+E cheat, fix with distance calculation
2017-04-04 09:13:15 +00:00
}
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_SDL
HyperRogue ported to SDL2 (in mymake do -sdl2)
2021-03-06 13:53:25 +00:00
const Uint8 *keystate = SDL12_GetKeyState(NULL);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
lmouseover = mouseover;
added lmouseover_distant
2021-05-27 10:59:21 +00:00
lmouseover_distant = lmouseover;
HyperRogue ported to SDL2 (in mymake do -sdl2)
2021-03-06 13:53:25 +00:00
bool useRangedOrb = (!(vid.shifttarget & 1) && haveRangedOrb() && lmouseover && lmouseover->cpdist > 1) || (keystate[SDL12(SDLK_RSHIFT, SDL_SCANCODE_RSHIFT)] | keystate[SDL12(SDLK_LSHIFT, SDL_SCANCODE_LSHIFT)]);
fixed lmouseover computation destroying dual geometry
2020-01-29 17:21:12 +00:00
if(!useRangedOrb && !(cmode & sm::MAP) && !(cmode & sm::DRAW) && DEFAULTCONTROL && !mouseout() && !dual::state) {
newlands:: implemented new Orbs: Gravity, Intensity, Choice
2018-12-23 02:14:48 +00:00
dynamicval<eGravity> gs(gravity_state, gravity_state);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
void calcMousedest();
calcMousedest();
cellwalker cw = cwt; bool f = flipplayer;
items[itWarning]+=2;
bool recorduse[ittypes];
for(int i=0; i<ittypes; i++) recorduse[i] = orbused[i];
movepcto(mousedest.d, mousedest.subdir, true);
for(int i=0; i<ittypes; i++) orbused[i] = recorduse[i];
items[itWarning] -= 2;
updated to 10.0c
2017-07-22 23:33:27 +00:00
if(cw.spin != cwt.spin) mirror::act(-mousedest.d, mirror::SPINSINGLE);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
cwt = cw; flipplayer = f;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
lmouseover = mousedest.d >= 0 ? cwt.at->modmove(cwt.spin + mousedest.d) : cwt.at;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
#endif
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void drawmovestar(double dx, double dy) {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_GRAPH, ("draw movestar"));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(viewdists) return;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3) return;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!playerfound) return;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(shmup::on) return;
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_RUG
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(rug::rugged && multi::players == 1 && !multi::alwaysuse) return;
#endif
Updated to 8.3j
2016-08-26 09:58:03 +00:00
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftpoint H = tC0(cwtV);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
ld R = sqrt(H[0] * H[0] + H[1] * H[1]);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix Centered;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
rewritten the Euclidean geometry
2019-11-27 00:01:20 +00:00
if(euclid)
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
Centered = shiftless(eupush(H.h));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(R > 1e-9) Centered = rgpushxto0(H);
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
else Centered = shiftless(Id);
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
adjusting for 3D part II
2019-02-22 19:58:40 +00:00
Centered = Centered * rgpushxto0(hpxy(dx*5, dy*5));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(multi::cpid >= 0) multi::crosscenter[multi::cpid] = Centered;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int rax = vid.axes;
if(rax == 1) rax = drawstaratvec(dx, dy) ? 2 : 0;
Updated to 8.3j
2016-08-26 09:58:03 +00:00
WASD keys and VI keys as help for keyboard users options
2020-05-15 13:28:59 +00:00
if(rax == 0 || vid.axes >= 4) return;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
int starcol = getcs().uicolor;
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
ignore(starcol);
if(0);
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
else if(vid.axes == 3)
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(Centered, cgi.shMovestar, starcol);
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Updated to 8.3j
2016-08-26 09:58:03 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else for(int d=0; d<8; d++) {
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = starcol;
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if ISPANDORA
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(leftclick && (d == 2 || d == 6 || d == 1 || d == 7)) col &= 0xFFFFFF3F;
if(rightclick && (d == 2 || d == 6 || d == 3 || d == 5)) col &= 0xFFFFFF3F;
if(!leftclick && !rightclick && (d&1)) col &= 0xFFFFFF3F;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
#endif
'light' movestar now has size adjusting to geometry
2020-05-15 13:30:04 +00:00
queueline(tC0(Centered), Centered * xspinpush0(d * M_PI / 4, cgi.scalefactor/2), col, 3 + vid.linequality);
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// old style joystick control
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
export everything: modules compiled separately
2019-09-06 06:17:02 +00:00
EX bool dronemode;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
calls to rogueviz::mark and rogueviz::fixparam from HR main are now replaced by hooks
2018-07-09 16:59:12 +00:00
purehookset hooks_calcparam;
rots:: show the underlying geometry
2019-09-09 13:31:49 +00:00
EX int corner_centering;
option 'permaside' (-pside) to permanently move the model to the left side
2019-10-06 22:08:37 +00:00
EX bool permaside;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void calcparam() {
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_GRAPH, ("calc param"));
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
auto cd = current_display;
fixed subscreen computations
2018-11-17 23:35:50 +00:00
cd->xtop = vid.xres * cd->xmin;
cd->ytop = vid.yres * cd->ymin;
cd->xsize = vid.xres * (cd->xmax - cd->xmin);
cd->ysize = vid.yres * (cd->ymax - cd->ymin);
cd->xcenter = cd->xtop + cd->xsize / 2;
cd->ycenter = cd->ytop + cd->ysize / 2;
fixed texts disappearing when scale is set to less than 0
2018-09-10 15:24:58 +00:00
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
if(pconf.scale > -1e-2 && pconf.scale < 1e-2) pconf.scale = 1;
commited changes from 9.4i and some extra
2017-05-27 19:40:40 +00:00
fixed subscreen computations
2018-11-17 23:35:50 +00:00
ld realradius = min(cd->xsize / 2, cd->ysize / 2);
further work on textures
2017-12-14 01:53:29 +00:00
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
cd->scrsize = realradius - (inHighQual ? 0 : ISANDROID ? 2 : ISIOS ? 40 : 40);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
option 'permaside' (-pside) to permanently move the model to the left side
2019-10-06 22:08:37 +00:00
current_display->sidescreen = permaside;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
geodesics in Sol
2019-07-28 09:07:21 +00:00
if(vid.xres < vid.yres - 2 * vid.fsize && !inHighQual && !in_perspective()) {
less awkward map position in portrait
2020-04-06 06:46:32 +00:00
cd->ycenter = lerp(vid.fsize + cd->scrsize, vid.yres - cd->scrsize - vid.fsize, .8);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
else {
replace vrhr::state checking with nicer functions
2020-12-30 13:20:30 +00:00
bool ok = !vrhr::active();
initial implementation of VR
2020-11-19 17:20:06 +00:00
if(vid.xres > vid.yres * 4/3+16 && (cmode & sm::SIDE) && ok)
fixed a bug with sidescreen working
2018-11-27 01:33:10 +00:00
current_display->sidescreen = true;
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_TOUR
initial implementation of VR
2020-11-19 17:20:06 +00:00
if(tour::on && (tour::slides[tour::currentslide].flags & tour::SIDESCREEN) && ok)
fixed a bug with sidescreen working
2018-11-27 01:33:10 +00:00
current_display->sidescreen = true;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
#endif
fixed a bug with sidescreen working
2018-11-27 01:33:10 +00:00
if(current_display->sidescreen) cd->xcenter = vid.yres/2;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
fixed screensize/radius in portrait
2018-02-20 21:11:39 +00:00
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
cd->radius = pconf.scale * cd->scrsize;
renamed DIM to GDIM
2019-08-15 13:05:43 +00:00
if(GDIM == 3 && in_perspective()) cd->radius = cd->scrsize;
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
realradius = min(realradius, cd->radius);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
ld aradius = sphere ? cd->radius / (pconf.alpha - 1) : cd->radius;
MAXMDIM guard
2021-05-09 00:25:41 +00:00
#if MAXMDIM >= 4
hybrid:: draw_underlying_space no longer covers the screen in e2xe, and also fixed the orientation in product
2021-05-01 09:13:51 +00:00
if(euclid && rots::drawing_underlying) aradius *= 2.5;
MAXMDIM guard
2021-05-09 00:25:41 +00:00
#endif
rots:: show the underlying geometry
2019-09-09 13:31:49 +00:00
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
if(dronemode) { cd->ycenter -= cd->radius; cd->ycenter += vid.fsize/2; cd->ycenter += vid.fsize/2; cd->radius *= 2; }
moving the screen center
2017-12-25 09:26:50 +00:00
rots:: show the underlying geometry
2019-09-09 13:31:49 +00:00
if(corner_centering) {
cd->ycenter = cd->ytop + cd->ysize - vid.fsize - aradius;
if(corner_centering == 1)
cd->xcenter = cd->xtop + vid.fsize + aradius;
if(corner_centering == 2)
cd->xcenter = cd->xtop + cd->xsize - vid.fsize - aradius;
}
moved all projection-related parameters to a special struct; another copy of that struct created for rug
2020-04-16 22:53:58 +00:00
cd->xcenter += cd->scrsize * pconf.xposition;
cd->ycenter += cd->scrsize * pconf.yposition;
rots:: show the underlying geometry
2019-09-09 13:31:49 +00:00
Panini projection
2020-11-01 20:20:54 +00:00
ld fov = vid.fov * degree / 2;
stereographic projection added
2021-03-21 10:28:10 +00:00
cd->tanfov = sin(fov) / (cos(fov) + (panini_alpha ? panini_alpha : stereo_alpha));
reworked 3D vision
2018-02-03 12:41:49 +00:00
calls to rogueviz::mark and rogueviz::fixparam from HR main are now replaced by hooks
2018-07-09 16:59:12 +00:00
callhooks(hooks_calcparam);
major cleanup of projection setting
2019-04-23 13:03:17 +00:00
reset_projection();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
export wrap_drawfullmap
2020-04-10 22:41:57 +00:00
EX function<void()> wrap_drawfullmap = drawfullmap;
external additions can wrap drawthemap
2018-01-25 16:22:04 +00:00
force_sphere_outline, fixed sphere outline in SVG
2018-02-26 12:17:06 +00:00
bool force_sphere_outline = false;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void drawfullmap() {
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_GRAPH, ("draw full map"));
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
cgi set in other places
2019-05-27 05:19:04 +00:00
check_cgi();
cgi.require_shapes();
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
ptds.clear();
/*
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
if(models::on) {
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
char ch = 'A';
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
for(auto& v: history::v) {
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(ggmatrix(v->base) * v->at, cgi.shTriangle, 0x306090C0);
removed the functions queuechr -- use queuestr now
2019-12-26 22:38:28 +00:00
queuestr(ggmatrix(v->base) * v->at * C0, 10, s0+(ch++), 0xFF0000);
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
}
}
*/
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_QUEUE
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
draw_boundary(0);
draw_boundary(1);
draw_model_elements();
more guards cont.
2020-07-03 12:48:36 +00:00
#if MAXMDIM >= 4 && CAP_GL
better sky, sky color variation
2019-06-01 15:01:04 +00:00
prepare_sky();
#endif
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
filled model drawing (for some models)
2018-11-08 15:28:17 +00:00
Refactoring: moved all the remaining pattern code from mapeditor to pattern2
2017-12-09 02:48:30 +00:00
/* if(vid.wallmode < 2 && !euclid && !patterns::whichShape) {
renamed the size function to isize
2018-06-22 12:47:24 +00:00
int ls = isize(lines);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(ISMOBILE) ls /= 10;
for(int t=0; t<ls; t++) queueline(View * lines[t].P1, View * lines[t].P2, lines[t].col >> (darken+1));
} */
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
clearaura();
shift+f2 to shift+f4 can now disable HUD, FPS, and the map
2018-07-09 16:10:28 +00:00
if(!nomap) drawthemap();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(!inHighQual) {
better mode handling
2017-07-12 17:50:39 +00:00
if((cmode & sm::NORMAL) && !rug::rugged) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(multi::players > 1) {
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
auto bcwtV = cwtV;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int i=0; i<multi::players; i++) if(multi::playerActive(i))
cwtV = multi::whereis[i], multi::cpid = i, drawmovestar(multi::mdx[i], multi::mdy[i]);
cwtV = bcwtV;
}
else if(multi::alwaysuse)
drawmovestar(multi::mdx[0], multi::mdy[0]);
else
drawmovestar(0, 0);
}
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_EDIT
better mode handling
2017-07-12 17:50:39 +00:00
if(cmode & sm::DRAW) mapeditor::drawGrid();
updated to 10.0c
2017-07-22 23:33:27 +00:00
#endif
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
10.0
2017-07-16 21:00:55 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawaura();
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#if CAP_QUEUE
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawqueue();
CAP_POLY part 1
2019-02-17 17:41:40 +00:00
#endif
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
wclick fixup
2019-06-28 08:22:48 +00:00
#if ISMOBILE
extern bool wclick;
#endif
correct key buffering
2020-09-11 09:14:32 +00:00
EX bool just_refreshing;
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void gamescreen(int _darken) {
no SIDE used on mobiles
2017-11-07 15:42:31 +00:00
correct key buffering
2020-09-11 09:14:32 +00:00
if(just_refreshing) return;
3D:: two-player uses split screen
2019-03-09 15:20:06 +00:00
if(subscreens::split([=] () {
racing:: first commit
2018-11-17 18:30:50 +00:00
calcparam();
compute_graphical_distance();
gamescreen(_darken);
racing:: subscreens used with multiple players
2018-11-17 23:36:31 +00:00
})) {
3D:: two-player uses split screen
2019-03-09 15:20:06 +00:00
if(racing::on) return;
// create the gmatrix
View = subscreens::player_displays[0].view_matrix;
viewctr is no more... major reduction of redundancy/complexity
2019-11-13 23:26:50 +00:00
centerover = subscreens::player_displays[0].precise_center;
3D:: two-player uses split screen
2019-03-09 15:20:06 +00:00
just_gmatrix = true;
redone hrmap::draw() function to keep DRY
2020-07-27 17:36:19 +00:00
currentmap->draw_all();
3D:: two-player uses split screen
2019-03-09 15:20:06 +00:00
just_gmatrix = false;
racing:: subscreens used with multiple players
2018-11-17 23:36:31 +00:00
return;
}
multigame support, including dualmode
2019-05-28 23:09:38 +00:00
gamescreen should now be able to draw multiple screens in screenshot
2020-11-01 19:23:14 +00:00
auto gx = vid.xres;
auto gy = vid.yres;
multigame support, including dualmode
2019-05-28 23:09:38 +00:00
if(dual::split([=] () {
gamescreen should now be able to draw multiple screens in screenshot
2020-11-01 19:23:14 +00:00
vid.xres = gx;
vid.yres = gy;
multigame support, including dualmode
2019-05-28 23:09:38 +00:00
dual::in_subscreen([=] () { gamescreen(_darken); });
})) {
calcparam();
return;
}
gamescreen should now be able to draw multiple screens in screenshot
2020-11-01 19:23:14 +00:00
calcparam();
shot:: default_screenshot_content now calls gamescreen, which correctly renders multi-game and some other things
2020-11-14 12:17:55 +00:00
if((cmode & sm::MAYDARK) && !current_display->sidescreen && !inHighQual) {
emeraldpattern on a46; fixed/improved darkening when sidedialog not available; pattern dialogs are now sidedialogs
2017-12-03 10:48:02 +00:00
_darken += 2;
no SIDE used on mobiles
2017-11-07 15:42:31 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
darken = _darken;
replace vrhr::state checking with nicer functions
2020-12-30 13:20:30 +00:00
if(vrhr::active()) darken = 0;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
if(history::includeHistory) history::restore();
work in progress for 10.0
2017-07-04 13:38:33 +00:00
animation menu
2018-09-10 15:58:36 +00:00
anims::apply();
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_RUG
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(rug::rugged) {
rug::actDraw();
updated to 10.0c
2017-07-22 23:33:27 +00:00
} else
work in progress for 10.0
2017-07-04 13:38:33 +00:00
#endif
external additions can wrap drawthemap
2018-01-25 16:22:04 +00:00
wrap_drawfullmap();
animation menu
2018-09-10 15:58:36 +00:00
anims::rollback();
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
split namespace conformal into models and history
2019-08-09 22:58:50 +00:00
if(history::includeHistory) history::restoreBack();
Updated to 9.4f (tutorial)
2017-04-08 15:18:29 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
poly_outline = OUTLINE_DEFAULT;
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if ISMOBILE
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
buttonclicked = false;
shot:: default_screenshot_content now calls gamescreen, which correctly renders multi-game and some other things
2020-11-14 12:17:55 +00:00
if((cmode & sm::NORMAL) && vid.stereo_mode != sLR && !inHighQual) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(andmode == 0 && shmup::on) {
using namespace shmupballs;
calc();
drawCircle(xmove, yb, rad, OUTLINE_FORE);
drawCircle(xmove, yb, rad/2, OUTLINE_FORE);
drawCircle(xfire, yb, rad, 0xFF0000FF);
drawCircle(xfire, yb, rad/2, 0xFF0000FF);
Updated to 9.4g (mostly tutorial fixes)
2017-04-14 18:12:23 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else {
XLAT refactor continued
2021-05-23 12:33:25 +00:00
if(!haveMobileCompass()) displayabutton(-1, +1, andmode == 0 && useRangedOrb ? XLAT("FIRE") : andmode == 0 && WDIM == 3 && wclick ? XLAT("WAIT") : XLAT("MOVE"), andmode == 0 ? BTON : BTOFF);
displayabutton(+1, +1, rug::rugged ? XLAT("RUG") :andmode == 1 ? XLAT("BACK") : GDIM == 3 ? XLAT("CAM") : XLAT("DRAG"), andmode == 1 ? BTON : BTOFF);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
displayabutton(-1, -1, XLAT("INFO"), andmode == 12 ? BTON : BTOFF);
displayabutton(+1, -1, XLAT("MENU"), andmode == 3 ? BTON : BTOFF);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
darken = 0;
moving the screen center
2017-12-25 09:26:50 +00:00
fixed CAP_TEXTURE disabling
2018-01-05 16:30:03 +00:00
#if CAP_TEXTURE
structurized textures.cpp
2018-03-17 20:12:46 +00:00
if(texture::config.tstate == texture::tsAdjusting)
texture::config.drawRawTexture();
fixed CAP_TEXTURE disabling
2018-01-05 16:30:03 +00:00
#endif
initial implementation of VR
2020-11-19 17:20:06 +00:00
#if CAP_VR
generalized VR UI placement
2021-02-06 18:11:53 +00:00
vrhr::size_and_draw_ui_box();
initial implementation of VR
2020-11-19 17:20:06 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
vr:: emptyscreen() so that VR knows what to do if there is no screen
2021-02-07 17:32:39 +00:00
EX void emptyscreen() {
ptds.clear();
ray::in_use = false;
drawqueue();
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool nohelp;
no_find_player option
2020-09-11 09:16:59 +00:00
EX bool no_find_player;
nomenu and nohelp options
2018-03-02 12:03:50 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void normalscreen() {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
help = "@";
further work for 10.0
2017-07-12 16:03:53 +00:00
show the big numbers in the Clearing
2019-12-25 10:53:50 +00:00
mouseovers = standard_help();
further work for 10.0
2017-07-12 16:03:53 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_TOUR
further work for 10.0
2017-07-12 16:03:53 +00:00
if(tour::on) mouseovers = tour::tourhelp;
#endif
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
if(GDIM == 3 || !outofmap(mouseh.h)) getcstat = '-';
better mode handling
2017-07-12 17:50:39 +00:00
cmode = sm::NORMAL | sm::DOTOUR | sm::CENTER;
displaying distance lists now depends on show_distance_lists, not whether sidescreen is supported
2018-09-23 11:48:59 +00:00
if(viewdists && show_distance_lists) cmode |= sm::SIDE | sm::MAYDARK;
separated highlight
2020-09-15 18:39:15 +00:00
gamescreen((vid.highlightmode == (hiliteclick ? 0 : 2)) ? 1 : 0); drawStats();
10.0g
2017-08-06 12:50:16 +00:00
if(nomenukey || ISMOBILE)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
;
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_TOUR
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
else if(tour::on)
displayButton(vid.xres-8, vid.yres-vid.fsize, XLAT("(ESC) tour menu"), SDLK_ESCAPE, 16);
else
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
displayButton(vid.xres-8, vid.yres-vid.fsize, XLAT("(v) menu"), 'v', 16);
keyhandler = handleKeyNormal;
further work for 10.0
2017-07-12 16:03:53 +00:00
no more 'press SPACE to find the player' if no mapeditor::drawplayer
2021-04-15 15:56:17 +00:00
if(!playerfound && !anims::any_on() && !sphere && !no_find_player && mapeditor::drawplayer)
XLAT refactor continued
2021-05-23 12:33:25 +00:00
displayButton(current_display->xcenter, current_display->ycenter, mousing ? XLAT("find the player") : XLAT("press SPACE to find the player"), ' ', 8);
a button appears when player not visible; fixed space-centering
2018-08-21 16:23:31 +00:00
further work for 10.0
2017-07-12 16:03:53 +00:00
describeMouseover();
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
cleanup mapeditor
2019-08-09 23:15:41 +00:00
EX vector< function<void()> > screens = { normalscreen };
#if HDR
template<class T> void pushScreen(const T& x) { screens.push_back(x); }
inline void popScreen() { if(isize(screens)>1) screens.pop_back(); }
inline void popScreenAll() { while(isize(screens)>1) popScreen(); }
replaced hooks_startmenu and hooks_mainmenu with a general hooks_display_dialog
2019-09-08 08:08:05 +00:00
typedef void (*cfunction)();
cleanup mapeditor
2019-08-09 23:15:41 +00:00
#endif
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
replaced hooks_startmenu and hooks_mainmenu with a general hooks_display_dialog
2019-09-08 08:08:05 +00:00
EX cfunction current_screen_cfunction() {
auto tgt = screens.back().target<cfunction>();
if(!tgt) return nullptr;
return *tgt;
}
further cleanup
2019-08-10 08:57:14 +00:00
#if HDR
namespace sm {
static const int NORMAL = 1;
static const int MISSION = 2;
static const int HELP = 4;
static const int MAP = 8;
static const int DRAW = 16;
static const int NUMBER = 32;
static const int SHMUPCONFIG = 64;
static const int OVERVIEW = 128;
static const int SIDE = 256;
static const int DOTOUR = 512;
static const int CENTER = 1024;
static const int ZOOMABLE = 4096;
static const int TORUSCONFIG = 8192;
static const int MAYDARK = 16384;
static const int DIALOG_STRICT_X = 32768; // do not interpret dialog clicks outside of the X region
static const int EXPANSION = (1<<16);
static const int HEXEDIT = (1<<17);
generalized VR UI placement
2021-02-06 18:11:53 +00:00
static const int VR_MENU = (1<<18); // always show the menu in VR
Remove extraneous semicolons to quiet pedantic GCC warnings.
2020-02-23 01:51:27 +00:00
}
further cleanup
2019-08-10 08:57:14 +00:00
#endif
more header cleanup
2019-08-09 20:07:03 +00:00
EX int cmode;
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void drawscreen() {
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_GRAPH, ("drawscreen"));
added some missing CAP_SDL and CAP_GL guards
2021-05-21 23:24:28 +00:00
#if CAP_GL
using GLWRAP
2020-11-08 10:49:19 +00:00
GLWRAP;
added some missing CAP_SDL and CAP_GL guards
2021-05-21 23:24:28 +00:00
#endif
Updated to 8.3j
2016-08-26 09:58:03 +00:00
debug cleanup
2019-05-12 23:57:40 +00:00
if(vid.xres == 0 || vid.yres == 0) return;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
calcparam();
Hypersian Rug for the torus
2017-11-06 18:24:02 +00:00
// rug::setVidParam();
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_GL
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(vid.usingGL) setGLProjection();
#endif
various changes and fixes to make coolfog and sky work correctly in VR
2021-03-09 12:12:53 +00:00
XGD: filled circles and start with clearscreen
2021-06-01 08:08:16 +00:00
#if CAP_XGD
if(!vid.usingGL) {
gdpush(5); gdpush(backcolor);
}
#endif
various changes and fixes to make coolfog and sky work correctly in VR
2021-03-09 12:12:53 +00:00
#if CAP_VR
vrhr::clear();
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_SDL
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// SDL_LockSurface(s);
// unsigned char *b = (unsigned char*) s->pixels;
// int n = vid.xres * vid.yres * 4;
// while(n) *b >>= 1, b++, n--;
// memset(s->pixels, 0, vid.xres * vid.yres * 4);
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if CAP_GL
if(!vid.usingGL)
#endif
SDL_FillRect(s, NULL, backcolor);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
// displaynum(vx,100, 0, 24, 0xc0c0c0, celldist(cwt.at), ":");
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
lgetcstat = getcstat;
getcstat = 0; inslider = false;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
further work for 10.0
2017-07-12 16:03:53 +00:00
mouseovers = " ";
better mode handling
2017-07-12 17:50:39 +00:00
cmode = 0;
Fix some minor std::function-related bugs. Lambdas to be stored in `function<void()>` should not return `bool`. Two uses of `std::function` could be just `function`, like everywhere else in the codebase.
2019-01-06 01:40:45 +00:00
keyhandler = [] (int sym, int uni) {};
shmup:: rewritten shmup configuration in OOP style
2018-11-18 02:18:11 +00:00
#if CAP_SDL
joyhandler = [] (SDL_Event& ev) { return false; };
#endif
renamed the size function to isize
2018-06-22 12:47:24 +00:00
if(!isize(screens)) pushScreen(normalscreen);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
screens.back()();
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
updated to 10.0c
2017-07-22 23:33:27 +00:00
#if !ISMOBILE
type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion
2018-09-04 17:53:42 +00:00
color_t col = linf[cwt.at->land].color;
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(cwt.at->land == laRedRock) col = 0xC00000;
nomenu and nohelp options
2018-03-02 12:03:50 +00:00
if(!nohelp)
displayfr(vid.xres/2, vid.fsize, 2, vid.fsize, mouseovers, col, 8);
further work for 10.0
2017-07-12 16:03:53 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
drawmessages();
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
better mode handling
2017-07-12 17:50:39 +00:00
bool normal = cmode & sm::NORMAL;
if((havewhat&HF_BUG) && darken == 0 && normal) for(int k=0; k<3; k++)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
displayfr(vid.xres/2 + vid.fsize * 5 * (k-1), vid.fsize*2, 2, vid.fsize,
its(hive::bugcount[k]), minf[moBug0+k].color, 8);
bool minefieldNearby = false;
fixed mines when more than 7 adjacent mines
2019-04-08 12:56:46 +00:00
int mines[MAXPLAYER], tmines=0;
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
for(int p=0; p<numplayers(); p++) {
mines[p] = 0;
cell *c = playerpos(p);
if(!c) continue;
mine adjacency rule can be changed (in 2D for now)
2019-04-08 12:58:54 +00:00
for(cell *c2: adj_minefield_cells(c)) {
if(c2->land == laMinefield)
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
minefieldNearby = true;
mine adjacency rule can be changed (in 2D for now)
2019-04-08 12:58:54 +00:00
if(c2->wall == waMineMine) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
bool ep = false;
if(!ep) mines[p]++, tmines++;
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Updated HyperRogue sources to 7.4f.
2016-01-02 10:09:13 +00:00
newlands:: implemented new Orbs: Gravity, Intensity, Choice
2018-12-23 02:14:48 +00:00
if((minefieldNearby || tmines) && !items[itOrbAether] && !last_gravity_state && darken == 0 && normal) {
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
string s;
fixed mines when more than 7 adjacent mines
2019-04-08 12:56:46 +00:00
if(tmines > 9) tmines = 9;
color_t col = minecolors[tmines%10];
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(tmines == 7) seenSevenMines = true;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more fixes to multiplayer
2021-03-06 10:46:13 +00:00
for(int p: player_indices())
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
displayfr(vid.xres * (p+.5) / numplayers(),
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
current_display->ycenter - current_display->radius * 3/4, 2,
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
vid.fsize,
fixed mines when more than 7 adjacent mines
2019-04-08 12:56:46 +00:00
mines[p] > 7 ? its(mines[p]) : XLAT(minetexts[mines[p]]), minecolors[mines[p]%10], 8);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(minefieldNearby && !shmup::on && cwt.at->land != laMinefield && cwt.peek()->land != laMinefield) {
refactored some global and stereo:: variables into display_data structure
2018-11-17 18:24:02 +00:00
displayfr(vid.xres/2, current_display->ycenter - current_display->radius * 3/4 - vid.fsize*3/2, 2,
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
vid.fsize,
XLAT("WARNING: you are entering a minefield!"),
col, 8);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
// SDL_UnlockSurface(s);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
faster graphics with MINIMIZE_GL_CALLS
2018-09-04 21:27:27 +00:00
glflush();
debug cleanup
2019-05-12 23:57:40 +00:00
DEBB(DF_GRAPH, ("swapbuffers"));
initial implementation of VR
2020-11-19 17:20:06 +00:00
#if CAP_VR
vrhr::submit();
#endif
HyperRogue ported to SDL2 (in mymake do -sdl2)
2021-03-06 13:53:25 +00:00
added some missing CAP_SDL and CAP_GL guards
2021-05-21 23:24:28 +00:00
#if CAP_SDL
HyperRogue ported to SDL2 (in mymake do -sdl2)
2021-03-06 13:53:25 +00:00
present_screen();
added some missing CAP_SDL and CAP_GL guards
2021-05-21 23:24:28 +00:00
#endif
vr:: improved performance?
2021-02-04 20:30:08 +00:00
added missing CAP_VR guard
2021-02-06 18:12:04 +00:00
#if CAP_VR
vr:: improved performance?
2021-02-04 20:30:08 +00:00
vrhr::handoff();
added missing CAP_VR guard
2021-02-06 18:12:04 +00:00
#endif
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
//printf("\ec");
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void restartGraph() {
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_INIT, ("restartGraph"));
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
do not clear linepattern alpha in autocheat
2018-04-21 17:35:17 +00:00
if(!autocheat) linepatterns::clearAll();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(currentmap) {
the orientation after recentering is now always 'player facing upwards'
2019-11-13 23:43:36 +00:00
resetview();
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
if(sphere) View = spin(-M_PI/2);
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
Initialization with hyperrogue-66
2015-08-08 13:57:52 +00:00
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void clearAnimations() {
a single function clearAnimations
2018-01-13 18:20:46 +00:00
for(int i=0; i<ANIMLAYERS; i++) animations[i].clear();
flashes.clear();
fallanims.clear();
}
Consistently name every hookset with prefix `hooks_`. NFC. I'm sure this causes massive merge-conflicts in the non-public code, but I think it'd be a good idea, if only to avoid confusion between e.g. `clearMemory` and the-variable-formerly-known-as `clearmemory`.
2020-04-11 18:40:12 +00:00
auto graphcm = addHook(hooks_clearmemory, 0, [] () {
debug cleanup
2019-05-12 23:57:40 +00:00
DEBBI(DF_MEMORY, ("clear graph memory"));
viewctr is no more... major reduction of redundancy/complexity
2019-11-13 23:26:50 +00:00
mouseover = centerover = lmouseover = NULL;
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
gmatrix.clear(); gmatrix0.clear(); current_display->all_drawn_copies.clear();
a single function clearAnimations
2018-01-13 18:20:46 +00:00
clearAnimations();
multigame support, including dualmode
2019-05-28 23:09:38 +00:00
})
+ addHook(hooks_gamedata, 0, [] (gamedata* gd) {
gd->store(mouseover);
gd->store(lmouseover);
gd->store(animations);
gd->store(flashes);
gd->store(fallanims);
dual:: added some missing gd->store's
2019-05-30 14:12:38 +00:00
gd->store(radar_transform);
gd->store(actual_view_transform);
Major refactoring, multisampling
2017-07-10 18:47:38 +00:00
});
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
//=== animation
more header cleanup
2019-08-09 21:08:42 +00:00
#if HDR
struct animation {
int ltick;
double footphase;
transmatrix wherenow;
Princess hug animation
2020-12-26 17:09:09 +00:00
int attacking; /** 0 = no attack animation, 1 = first phase, 2 = second phase, 3 = hugging */
more header cleanup
2019-08-09 21:08:42 +00:00
transmatrix attackat;
bool mirrored;
curses thrown are now animated
2021-06-06 08:35:55 +00:00
eItem thrown_item; /** for thrown items */
more header cleanup
2019-08-09 21:08:42 +00:00
};
// we need separate animation layers for Orb of Domination and Tentacle+Ghost,
// and also to mark Boats
curses thrown are now animated
2021-06-06 08:35:55 +00:00
#define ANIMLAYERS 4
more header cleanup
2019-08-09 21:08:42 +00:00
#define LAYER_BIG 0 // for worms and krakens
#define LAYER_SMALL 1 // for others
#define LAYER_BOAT 2 // mark that a boat has moved
curses thrown are now animated
2021-06-06 08:35:55 +00:00
#define LAYER_THROW 3 // for thrown items
more header cleanup
2019-08-09 21:08:42 +00:00
#endif
EX array<map<cell*, animation>, ANIMLAYERS> animations;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
more header cleanup
2019-08-09 20:37:11 +00:00
EX int revhint(cell *c, int hint) {
major rewrite: unified the common parts of heptagon and cell via struct connection<T> and struct walker<T>
2018-08-17 22:46:45 +00:00
if(hint >= 0 && hint < c->type) return c->c.spin(hint);
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
else return hint;
}
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
EX transmatrix adj(const movei& m) {
if(m.proper()) return currentmap->adj(m.s, m.d);
else return currentmap->relative_matrix(m.t, m.s, C0);
}
EX transmatrix iadj(const movei& m) {
if(m.proper()) return currentmap->iadj(m.s, m.d);
else return currentmap->relative_matrix(m.s, m.t, C0);
}
EX void animateMovement(const movei& m, int layer) {
attack animations
2018-01-25 16:19:50 +00:00
if(vid.mspeed >= 5) return; // no animations!
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE ( animateMovement(m, layer); )
fixup animateMovement
2019-11-22 15:37:32 +00:00
transmatrix T = iadj(m);
animateMovement: correct even if moved to the same cell
2019-11-22 18:39:50 +00:00
bool found_s = animations[layer].count(m.s);
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
animation& a = animations[layer][m.t];
animateMovement: correct even if moved to the same cell
2019-11-22 18:39:50 +00:00
if(found_s) {
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
a = animations[layer][m.s];
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
a.wherenow = T * a.wherenow;
fixed a bug when moving animation with m.s == m.t
2020-12-25 05:08:19 +00:00
if(m.s != m.t)
animations[layer].erase(m.s);
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
a.attacking = 0;
}
else {
a.ltick = ticks;
a.wherenow = T;
a.footphase = 0;
monster orientation is now modelled in non-orientable geometries
2019-05-15 12:19:19 +00:00
a.mirrored = false;
}
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
if(m.proper() && m.s->c.mirror(m.d))
a.mirrored = !a.mirrored;
}
curses thrown are now animated
2021-06-06 08:35:55 +00:00
EX void animate_item_throw(cell *from, cell *to, eItem it) {
bool steps = false;
again:
if(from != to) {
forCellIdEx(c1, i, from) if(celldistance(c1, to) < celldistance(from, to)) {
animateMovement(movei(from, i), LAYER_THROW);
from = c1;
steps = true;
goto again;
}
}
if(steps) {
animation& a = animations[LAYER_THROW][to];
a.thrown_item = it;
}
}
Princess hug animation
2020-12-26 17:09:09 +00:00
EX void animateAttackOrHug(const movei& m, int layer, int phase, ld ratio, ld delta) {
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( animateAttack(m, layer); )
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
if(vid.mspeed >= 5) return; // no animations!
animateMov YA fixup
2019-11-22 15:46:37 +00:00
transmatrix T = iadj(m);
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
bool newanim = !animations[layer].count(m.s);
animation& a = animations[layer][m.s];
Princess hug animation
2020-12-26 17:09:09 +00:00
a.attacking = phase;
if(phase == 3) println(hlog, "distance = ", hdist0(T * C0));
a.attackat = rspintox(tC0(iso_inverse(T))) * xpush(hdist0(T*C0) * ratio + delta);
movement animations now work in quotient geometries
2018-06-17 15:51:26 +00:00
if(newanim) a.wherenow = Id, a.ltick = ticks, a.footphase = 0;
}
Princess hug animation
2020-12-26 17:09:09 +00:00
EX void animateAttack(const movei& m, int layer) {
animateAttackOrHug(m, layer, 1, 1/3., 0);
}
EX void animateHug(const movei& m, int layer) {
animateAttackOrHug(m, layer, 3, 0.5, -0.0713828 * cgi.scalefactor);
}
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
vector<pair<cell*, animation> > animstack;
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
EX void indAnimateMovement(const movei& m, int layer) {
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
if(vid.mspeed >= 5) return; // no animations!
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( indAnimateMovement(m, layer); )
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
if(animations[layer].count(m.t)) {
animation res = animations[layer][m.t];
animations[layer].erase(m.t);
animateMovement(m, layer);
if(animations[layer].count(m.t))
animstack.push_back(make_pair(m.t, animations[layer][m.t]));
animations[layer][m.t] = res;
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
else {
used movei in movement animations; also replaced animateReplacement with indAnimateMovement
2019-11-22 15:32:05 +00:00
animateMovement(m, layer);
if(animations[layer].count(m.t)) {
animstack.push_back(make_pair(m.t, animations[layer][m.t]));
animations[layer].erase(m.t);
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
}
}
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX void commitAnimations(int layer) {
rewritten undo: part 1
2020-02-29 16:58:59 +00:00
LATE( commitAnimations(layer); )
renamed the size function to isize
2018-06-22 12:47:24 +00:00
for(int i=0; i<isize(animstack); i++)
Updated the source files to 9.4c
2017-03-23 10:53:57 +00:00
animations[layer][animstack[i].first] = animstack[i].second;
animstack.clear();
}
more header cleanup
2019-08-09 20:07:03 +00:00
EX void drawBug(const cellwalker& cw, color_t col) {
added CAP_SHAPES: poly system works, but no shapes are used
2019-02-17 18:39:44 +00:00
#if CAP_SHAPES
10.0g
2017-08-06 12:50:16 +00:00
initquickqueue();
MAJOR CHANGE: replaced (transmatrix,band_shift) pair with shiftmatrix
2020-07-27 16:49:04 +00:00
shiftmatrix V = ggmatrix(cw.at);
functions with rotation parameters in S84-degree system have been removed or replaced in radian versions
2018-08-19 13:52:39 +00:00
if(cw.spin) V = V * ddspin(cw.at, cw.spin, M_PI);
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
2019-05-26 16:04:02 +00:00
queuepoly(V, cgi.shBugBody, col);
10.0g
2017-08-06 12:50:16 +00:00
quickqueue();
partial disabling of CAP_POLY; new hook; aurac is std::array
2017-12-01 23:23:15 +00:00
#endif
10.0g
2017-08-06 12:50:16 +00:00
}
autohdr.h applied in more files
2019-08-09 19:00:52 +00:00
EX bool inscreenrange(cell *c) {
improved insightrange
2018-04-06 21:28:58 +00:00
if(sphere) return true;
viewctr is no more... major reduction of redundancy/complexity
2019-11-13 23:26:50 +00:00
if(euclid) return celldistance(centerover, c) <= get_sightrange_ambush();
nilv:: preliminary implementation
2019-08-06 10:00:46 +00:00
if(nonisotropic) return gmatrix.count(c);
fixed the racing marker in Crystal344
2019-10-12 12:40:33 +00:00
if(geometry == gCrystal344) return gmatrix.count(c);
viewctr is no more... major reduction of redundancy/complexity
2019-11-13 23:26:50 +00:00
return heptdistance(centerover, c) <= 8;
10.0g
2017-08-06 12:50:16 +00:00
}
2D3D:: Archimedean no longer crashes after changing
2019-05-08 19:09:22 +00:00
#if MAXMDIM >= 4
'circles' are now drawn on all copies in quotient geometries
2019-12-06 13:03:02 +00:00
auto hooksw = addHook(hooks_swapdim, 100, [] { clearAnimations(); gmatrix.clear(); gmatrix0.clear(); current_display->all_drawn_copies.clear(); });
2D3D:: Archimedean no longer crashes after changing
2019-05-08 19:09:22 +00:00
#endif
moved all the HyperRogue stuff except RogueViz to namespace 'hr' -- useful when using hr as a library
2018-06-10 23:58:31 +00:00
}
Reference in New Issue Copy Permalink