mirrors/hyperrogue
1
0
Fork 0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2025-05-06 17:24:06 +00:00
Code Issues Releases Wiki Activity

drawMonsterType with cases

Browse Source
This commit is contained in:
Zeno Rogue 2019-03-30 13:16:19 +01:00
parent 3634956046
commit 11ee7c1b9a
1 changed files with 908 additions and 795 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

463
graph.cpp
View File

@ -891,36 +891,13 @@ void drawTerraWarrior(const transmatrix& V, int t, int hp, double footphase) {
} }
#endif #endif
bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col, double footphase) { void drawPlayer(eMonster m, cell *where, const transmatrix& V, color_t col, double footphase) {
#if MAXMDIM >= 4
if(DIM == 3 && m != moPlayer)
radarpoints.emplace_back(radarpoint{makeradar(V), minf[m].glyph, col, isFriendly(m) ? 0x00FF00FF : 0xFF0000FF });
#endif
#if CAP_SHAPES
char xch = minf[m].glyph;
if(m == moTortoise && where && where->stuntime >= 3)
drawStunStars(V, where->stuntime-2);
else if (m == moTortoise || m == moPlayer || (where && !where->stuntime)) ;
else if(where && !(isMetalBeast(m) && where->stuntime == 1))
drawStunStars(V, where->stuntime);
if(m == 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)
queuepoly(V, shRing, darkena(0xFFFFFF, 0, 0x80 + 0x70 * sintick(200)));
}
else if(m == moPlayer) {
charstyle& cs = getcs(); charstyle& cs = getcs();
if(mapeditor::drawplayer && !mapeditor::drawUserShape(V, mapeditor::sgPlayer, cs.charid, cs.skincolor, where)) { if(mapeditor::drawplayer && !mapeditor::drawUserShape(V, mapeditor::sgPlayer, cs.charid, cs.skincolor, where)) {
if(cs.charid >= 8) { if(cs.charid >= 8) {
/* famililar */
if(!mmspatial && !footphase) if(!mmspatial && !footphase)
queuepoly(VALEGS, shWolfLegs, fc(150, cs.dresscolor, 4)); queuepoly(VALEGS, shWolfLegs, fc(150, cs.dresscolor, 4));
else { else {
@ -942,6 +919,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
tortoise::draw(VABODY, tortoise::seekbits, 4, 0); tortoise::draw(VABODY, tortoise::seekbits, 4, 0);
} }
else if(cs.charid >= 6) { else if(cs.charid >= 6) {
/* dog */
if(!mmspatial && !footphase) if(!mmspatial && !footphase)
queuepoly(VABODY, shDogBody, fc(0, cs.skincolor, 0)); queuepoly(VABODY, shDogBody, fc(0, cs.skincolor, 0));
else { else {
@ -967,6 +945,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
tortoise::draw(VABODY, tortoise::seekbits, 4, 0); tortoise::draw(VABODY, tortoise::seekbits, 4, 0);
} }
else if(cs.charid >= 4) { else if(cs.charid >= 4) {
/* cat */
if(!mmspatial && !footphase) if(!mmspatial && !footphase)
queuepoly(VALEGS, shCatLegs, fc(500, cs.dresscolor, 4)); queuepoly(VALEGS, shCatLegs, fc(500, cs.dresscolor, 4));
else { else {
@ -988,7 +967,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
tortoise::draw(VABODY, tortoise::seekbits, 4, 0); tortoise::draw(VABODY, tortoise::seekbits, 4, 0);
} }
else { else {
/* human */
const transmatrix VBS = otherbodyparts(V, fc(0, cs.skincolor, 0), items[itOrbFish] ? moWaterElemental : moPlayer, footphase); const transmatrix VBS = otherbodyparts(V, fc(0, cs.skincolor, 0), items[itOrbFish] ? moWaterElemental : moPlayer, footphase);
queuepoly(VBODY * VBS, (cs.charid&1) ? shFemaleBody : shPBody, fc(0, cs.skincolor, 0)); queuepoly(VBODY * VBS, (cs.charid&1) ? shFemaleBody : shPBody, fc(0, cs.skincolor, 0));
@ -1019,10 +998,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
if(peace::on) ; if(peace::on) ;
else if(racing::on) { else if(racing::on) {
#if CAP_RACING #if CAP_RACING
if(racing::trophy[multi::cpid]) if(racing::trophy[multi::cpid])
queuepoly(VWPN, shTrophy, racing::trophy[multi::cpid]); queuepoly(VWPN, shTrophy, racing::trophy[multi::cpid]);
#endif #endif
} }
else if(items[itOrbThorns]) else if(items[itOrbThorns])
queuepoly(VWPN, shHedgehogBladePlayer, items[itOrbDiscord] ? watercolor(0) : 0x00FF00FF); queuepoly(VWPN, shHedgehogBladePlayer, items[itOrbDiscord] ? watercolor(0) : 0x00FF00FF);
@ -1066,16 +1045,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
if(tortoise::seek()) if(tortoise::seek())
tortoise::draw(VBODY * VBS * ypush(-crossf*.25), tortoise::seekbits, 4, 0); tortoise::draw(VBODY * VBS * ypush(-crossf*.25), tortoise::seekbits, 4, 0);
} }
} }
} }
else if(mapeditor::drawUserShape(V, mapeditor::sgMonster, m, darkena(col, 0, 0xFF), where)) { void drawMimic(eMonster m, cell *where, const transmatrix& V, color_t col, double footphase) {
return false;
}
else if(isMimic(m) || m == moShadow || m == moIllusion) {
charstyle& cs = getcs(); charstyle& cs = getcs();
if(mapeditor::drawUserShape(V, mapeditor::sgPlayer, cs.charid, darkena(col, 0, 0x80), where)) return false; if(mapeditor::drawUserShape(V, mapeditor::sgPlayer, cs.charid, darkena(col, 0, 0x80), where)) return false;
@ -1149,12 +1122,48 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
} }
} }
else if(m == moBullet) { bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col, double footphase) {
ShadowV(V, shKnife);
queuepoly(VBODY * spin(-M_PI/4), shKnife, getcs().swordcolor); #if MAXMDIM >= 4
if(DIM == 3 && m != moPlayer)
radarpoints.emplace_back(radarpoint{makeradar(V), minf[m].glyph, col, isFriendly(m) ? 0x00FF00FF : 0xFF0000FF });
#endif
#if CAP_SHAPES
char xch = minf[m].glyph;
if(m == moTortoise && where && where->stuntime >= 3)
drawStunStars(V, where->stuntime-2);
else if (m == moTortoise || m == moPlayer || (where && !where->stuntime)) ;
else if(where && !(isMetalBeast(m) && where->stuntime == 1))
drawStunStars(V, where->stuntime);
if(mapeditor::drawUserShape(V, mapeditor::sgMonster, m, darkena(col, 0, 0xFF), where))
return false;
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)
queuepoly(V, shRing, darkena(0xFFFFFF, 0, 0x80 + 0x70 * sintick(200)));
return false;
} }
else if(m == moKnight || m == moKnightMoved) { case moPlayer:
drawPlayer(m, where, V, col, footphase);
return false;
case moMimic: moShadow: moIllusion:
drawMimic(m, where, V, col, footphase);
return false;
case moBullet:
ShadowV(V, shKnife);
queuepoly(VBODY * spin(-M_PI/4), shKnife, getcs().swordcolor);
return false;
case moKnight: case moKnightMoved: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = otherbodyparts(V, darkena(0xC0C0A0, 0, 0xC0), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(0xC0C0A0, 0, 0xC0), m, footphase);
queuepoly(VBODY * VBS, shPBody, darkena(0xC0C0A0, 0, 0xC0)); queuepoly(VBODY * VBS, shPBody, darkena(0xC0C0A0, 0, 0xC0));
@ -1172,15 +1181,24 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
return false; return false;
} }
else if(m == moGolem || m == moGolemMoved) { case moGolem: case moGolemMoved: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0XC0), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0XC0), m, footphase);
queuepoly(VBODY * VBS, shPBody, darkena(col, 0, 0XC0)); queuepoly(VBODY * VBS, shPBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, shGolemhead, darkena(col, 1, 0XFF)); queuepoly(VHEAD, shGolemhead, darkena(col, 1, 0XFF));
return false;
} }
else if(isPrincess(m) || m == moFalsePrincess || m == moRoseLady || m == moRoseBeauty) { case moEvilGolem: case moIceGolem: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 2, 0xC0), m, footphase);
ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, shGolemhead, darkena(col, 1, 0XFF));
return false;
}
case moFalsePrincess: case moRoseLady: case moRoseBeauty: {
princess:
bool girl = princessgender() == GEN_F; bool girl = princessgender() == GEN_F;
bool evil = !isPrincess(m); bool evil = !isPrincess(m);
@ -1212,7 +1230,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
} }
if(m == moRoseLady) { if(m == moRoseLady) {
// queuepoly(V, girl ? shGoatHead : shDemon, 0x800000FF); // queuepoly(V, girl ? shGoatHead : shDemon, 0x800000FF);
queuepoly(VHEAD1, girl ? shFemaleHair : shPHead, evil ? 0x500050FF : 0x332A22FF); queuepoly(VHEAD1, girl ? shFemaleHair : shPHead, evil ? 0x500050FF : 0x332A22FF);
} }
else if(m == moRoseBeauty) { else if(m == moRoseBeauty) {
@ -1233,7 +1251,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VHEAD, shPFace, facecolor); queuepoly(VHEAD, shPFace, facecolor);
} }
else if(m == moWolf || m == moRedFox || m == moWolfMoved || m == moLavaWolf) { case moWolf: case moRedFox: case moWolfMoved: case moLavaWolf: {
ShadowV(V, shWolfBody); ShadowV(V, shWolfBody);
if(mmspatial || footphase) if(mmspatial || footphase)
animallegs(VALEGS, moWolf, darkena(col, 0, 0xFF), footphase); animallegs(VALEGS, moWolf, darkena(col, 0, 0xFF), footphase);
@ -1246,20 +1264,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
} }
queuepoly(VAHEAD, shWolfHead, darkena(col, 0, 0xFF)); queuepoly(VAHEAD, shWolfHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, shWolfEyes, darkena(col, 3, 0xFF)); queuepoly(VAHEAD, shWolfEyes, darkena(col, 3, 0xFF));
break;
} }
else if(isBull(m)) { case moReptile: {
ShadowV(V, shBullBody);
int hoofcol = darkena(gradient(0, col, 0, .65, 1), 0, 0xFF);
if(mmspatial || footphase)
animallegs(VALEGS, moRagingBull, hoofcol, footphase);
queuepoly(VABODY, shBullBody, darkena(gradient(0, col, 0, .80, 1), 0, 0xFF));
queuepoly(VAHEAD, shBullHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, shBullHorn, darkena(0xFFFFFF, 0, 0xFF));
queuepoly(VAHEAD * Mirror, shBullHorn, darkena(0xFFFFFF, 0, 0xFF));
}
else if(m == moReptile) {
ShadowV(V, shReptileBody); ShadowV(V, shReptileBody);
animallegs(VALEGS, moReptile, darkena(col, 0, 0xFF), footphase); animallegs(VALEGS, moReptile, darkena(col, 0, 0xFF), footphase);
queuepoly(VABODY, shReptileBody, darkena(col, 0, 0xFF)); queuepoly(VABODY, shReptileBody, darkena(col, 0, 0xFF));
@ -1267,9 +1275,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VAHEAD, shReptileEye, darkena(col, 3, 0xFF)); queuepoly(VAHEAD, shReptileEye, darkena(col, 3, 0xFF));
queuepoly(VAHEAD * Mirror, shReptileEye, darkena(col, 3, 0xFF)); queuepoly(VAHEAD * Mirror, shReptileEye, darkena(col, 3, 0xFF));
queuepoly(VABODY, shReptileTail, darkena(col, 2, 0xFF)); queuepoly(VABODY, shReptileTail, darkena(col, 2, 0xFF));
break;
} }
else if(m == moSalamander) { case moSalamander: {
ShadowV(V, shReptileBody); ShadowV(V, shReptileBody);
animallegs(VALEGS, moReptile, darkena(0xD00000, 1, 0xFF), footphase); animallegs(VALEGS, moReptile, darkena(0xD00000, 1, 0xFF), footphase);
queuepoly(VABODY, shReptileBody, darkena(0xD00000, 0, 0xFF)); queuepoly(VABODY, shReptileBody, darkena(0xD00000, 0, 0xFF));
@ -1277,9 +1286,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VAHEAD, shReptileEye, darkena(0xD00000, 0, 0xFF)); queuepoly(VAHEAD, shReptileEye, darkena(0xD00000, 0, 0xFF));
queuepoly(VAHEAD * Mirror, shReptileEye, darkena(0xD00000, 0, 0xFF)); queuepoly(VAHEAD * Mirror, shReptileEye, darkena(0xD00000, 0, 0xFF));
queuepoly(VABODY, shReptileTail, darkena(0xD08000, 0, 0xFF)); queuepoly(VABODY, shReptileTail, darkena(0xD08000, 0, 0xFF));
break;
} }
else if(m == moVineBeast) { case moVineBeast: {
ShadowV(V, shWolfBody); ShadowV(V, shWolfBody);
if(mmspatial || footphase) if(mmspatial || footphase)
animallegs(VALEGS, moWolf, 0x00FF00FF, footphase); animallegs(VALEGS, moWolf, 0x00FF00FF, footphase);
@ -1288,23 +1298,17 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VABODY, shWolfBody, darkena(col, 1, 0xFF)); queuepoly(VABODY, shWolfBody, darkena(col, 1, 0xFF));
queuepoly(VAHEAD, shWolfHead, darkena(col, 0, 0xFF)); queuepoly(VAHEAD, shWolfHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, shWolfEyes, 0xFF0000FF); queuepoly(VAHEAD, shWolfEyes, 0xFF0000FF);
break;
} }
else if(m == moMouse || m == moMouseMoved) {
case moMouse: case moMouseMoved: {
queuepoly(VALEGS, shMouse, darkena(col, 0, 0xFF)); queuepoly(VALEGS, shMouse, darkena(col, 0, 0xFF));
queuepoly(VALEGS, shMouseLegs, darkena(col, 1, 0xFF)); queuepoly(VALEGS, shMouseLegs, darkena(col, 1, 0xFF));
queuepoly(VALEGS, shMouseEyes, 0xFF); queuepoly(VALEGS, shMouseEyes, 0xFF);
break;
} }
else if(isBug(m)) {
ShadowV(V, shBugBody); case moRunDog: case moHunterDog: case moHunterGuard: case moHunterChanging: case moFallingDog: {
if(!mmspatial && !footphase)
queuepoly(VABODY, shBugBody, darkena(col, 0, 0xFF));
else {
animallegs(VALEGS, moBug0, darkena(col, 0, 0xFF), footphase);
queuepoly(VABODY, shBugAntenna, darkena(col, 1, 0xFF));
}
queuepoly(VABODY, shBugArmor, darkena(col, 1, 0xFF));
}
else if(among(m, moRunDog, moHunterDog, moHunterGuard, moHunterChanging, moFallingDog)) {
if(!mmspatial && !footphase) if(!mmspatial && !footphase)
queuepoly(VABODY, shDogBody, darkena(col, 0, 0xFF)); queuepoly(VABODY, shDogBody, darkena(col, 0, 0xFF));
else { else {
@ -1328,8 +1332,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VAHEAD, shWolf2, eyes).flags |= POLY_FORCEWIDE; queuepoly(VAHEAD, shWolf2, eyes).flags |= POLY_FORCEWIDE;
} }
queuepoly(VAHEAD, shWolf3, darkena(m == moRunDog ? 0x202020 : 0x000000, 0, 0xFF)); queuepoly(VAHEAD, shWolf3, darkena(m == moRunDog ? 0x202020 : 0x000000, 0, 0xFF));
return false;
} }
else if(m == moOrangeDog) {
case moOrangeDog: {
if(!mmspatial && !footphase) if(!mmspatial && !footphase)
queuepoly(VABODY, shDogBody, darkena(0xFFFFFF, 0, 0xFF)); queuepoly(VABODY, shDogBody, darkena(0xFFFFFF, 0, 0xFF));
else { else {
@ -1342,30 +1348,39 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VAHEAD, shWolf1, darkena(0x202020, 0, 0xFF)); queuepoly(VAHEAD, shWolf1, darkena(0x202020, 0, 0xFF));
queuepoly(VAHEAD, shWolf2, darkena(0x202020, 0, 0xFF)); queuepoly(VAHEAD, shWolf2, darkena(0x202020, 0, 0xFF));
queuepoly(VAHEAD, shWolf3, darkena(0x202020, 0, 0xFF)); queuepoly(VAHEAD, shWolf3, darkena(0x202020, 0, 0xFF));
return false;
} }
else if(m == moShark || m == moGreaterShark || m == moCShark)
case moShark: moGreaterShark: moCShark:
queuepoly(VFISH, shShark, darkena(col, 0, 0xFF)); queuepoly(VFISH, shShark, darkena(col, 0, 0xFF));
else if(m == moEagle || m == moParrot || m == moBomberbird || m == moAlbatross || return false;
m == moTameBomberbird || m == moWindCrow || m == moTameBomberbirdMoved ||
m == moSandBird || m == moAcidBird) { case moEagle: moParrot: moBomberbird: moAlbatross:
case moTameBomberbird: case moWindCrow: case moTameBomberbirdMoved:
case moSandBird: case moAcidBird:
ShadowV(V, shEagle); ShadowV(V, shEagle);
if(m == moParrot && DIM == 3) if(m == moParrot && DIM == 3)
queuepolyat(VBIRD, shEagle, darkena(col, 0, 0xFF), PPR::SUPERLINE); queuepolyat(VBIRD, shEagle, darkena(col, 0, 0xFF), PPR::SUPERLINE);
else else
queuepoly(VBIRD, shEagle, darkena(col, 0, 0xFF)); queuepoly(VBIRD, shEagle, darkena(col, 0, 0xFF));
} return false;
else if(among(m, moSparrowhawk, moWestHawk)) {
case moSparrowhawk: case moWestHawk: {
ShadowV(V, shHawk); ShadowV(V, shHawk);
queuepoly(VBIRD, shHawk, darkena(col, 0, 0xFF)); queuepoly(VBIRD, shHawk, darkena(col, 0, 0xFF));
return false;
} }
else if(m == moButterfly) {
case moButterfly: {
transmatrix Vwing = Id; transmatrix Vwing = Id;
Vwing[1][1] = .85 + .15 * sintick(100); Vwing[1][1] = .85 + .15 * sintick(100);
ShadowV(V * Vwing, shButterflyWing); ShadowV(V * Vwing, shButterflyWing);
queuepoly(VBIRD * Vwing, shButterflyWing, darkena(col, 0, 0xFF)); queuepoly(VBIRD * Vwing, shButterflyWing, darkena(col, 0, 0xFF));
queuepoly(VBIRD, shButterflyBody, darkena(col, 2, 0xFF)); queuepoly(VBIRD, shButterflyBody, darkena(col, 2, 0xFF));
return false;
} }
else if(m == moGadfly) {
case moGadfly: {
transmatrix Vwing = Id; transmatrix Vwing = Id;
Vwing[1][1] = .85 + .15 * sintick(100); Vwing[1][1] = .85 + .15 * sintick(100);
ShadowV(V * Vwing, shGadflyWing); ShadowV(V * Vwing, shGadflyWing);
@ -1373,8 +1388,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VBIRD, shGadflyBody, darkena(col, 1, 0xFF)); queuepoly(VBIRD, shGadflyBody, darkena(col, 1, 0xFF));
queuepoly(VBIRD, shGadflyEye, darkena(col, 2, 0xFF)); queuepoly(VBIRD, shGadflyEye, darkena(col, 2, 0xFF));
queuepoly(VBIRD * Mirror, shGadflyEye, darkena(col, 2, 0xFF)); queuepoly(VBIRD * Mirror, shGadflyEye, darkena(col, 2, 0xFF));
return false;
} }
else if(m == moVampire || m == moBat) {
case moVampire: case moBat: {
// vampires have no shadow and no mirror images // vampires have no shadow and no mirror images
if(m == moBat) ShadowV(V, shBatWings); if(m == moBat) ShadowV(V, shBatWings);
if(m == moBat || !inmirrorcount) { if(m == moBat || !inmirrorcount) {
@ -1386,42 +1403,48 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(V*Mirror, shBatFang, darkena(0xFFC0C0, 0, 0xFF)); queuepoly(V*Mirror, shBatFang, darkena(0xFFC0C0, 0, 0xFF));
queuepoly(V, shBatEye, darkena(00000000, 0, 0xFF)); queuepoly(V, shBatEye, darkena(00000000, 0, 0xFF));
queuepoly(V*Mirror, shBatEye, darkena(00000000, 0, 0xFF)); */ queuepoly(V*Mirror, shBatEye, darkena(00000000, 0, 0xFF)); */
return false;
} }
else if(m == moGargoyle) {
case moGargoyle: {
ShadowV(V, shGargoyleWings); ShadowV(V, shGargoyleWings);
queuepoly(VBIRD, shGargoyleWings, darkena(col, 0, 0xD0)); queuepoly(VBIRD, shGargoyleWings, darkena(col, 0, 0xD0));
queuepoly(VBIRD, shGargoyleBody, darkena(col, 0, 0xFF)); queuepoly(VBIRD, shGargoyleBody, darkena(col, 0, 0xFF));
return false;
} }
else if(m == moZombie) {
case moZombie: {
int c = darkena(col, where && where->land == laHalloween ? 1 : 0, 0xFF); int c = darkena(col, where && where->land == laHalloween ? 1 : 0, 0xFF);
const transmatrix VBS = otherbodyparts(V, c, m, footphase); const transmatrix VBS = otherbodyparts(V, c, m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBODY * VBS, shPBody, c); queuepoly(VBODY * VBS, shPBody, c);
return false;
} }
else if(m == moTerraWarrior)
case moTerraWarrior: {
drawTerraWarrior(V, 7, (where ? where->hitpoints : 7), footphase); drawTerraWarrior(V, 7, (where ? where->hitpoints : 7), footphase);
else if(m == moVariantWarrior) { return false;
}
case moVariantWarrior: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(0xFFD500, 0, 0xF0)); queuepoly(VBS, shPBody, darkena(0xFFD500, 0, 0xF0));
if(!peace::on) queuepoly(VBS, shPSword, 0xFFFF00FF); if(!peace::on) queuepoly(VBS, shPSword, 0xFFFF00FF);
queuepoly(VHEAD, shHood, 0x008000FF); queuepoly(VHEAD, shHood, 0x008000FF);
return false;
} }
else if(m == moDesertman) {
case moDesertman: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(col, 0, 0xC0)); queuepoly(VBS, shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBS, shPSword, 0xFFFF00FF); if(!peace::on) queuepoly(VBS, shPSword, 0xFFFF00FF);
queuepoly(VHEAD, shHood, 0xD0D000C0); queuepoly(VHEAD, shHood, 0xD0D000C0);
return false;
} }
/* else if(isSwitch(m)) {
otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); case moMonk: {
ShadowV(V, shPBody);
queuepoly(VBODY, shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBODY, shPSword, 0xFFFF00FF);
queuepoly(VHEAD, shHood, darkena(col, 0, 0xFF));
} */
else if(m == moMonk) {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
ShadowV(V, shRaiderBody); ShadowV(V, shRaiderBody);
queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF)); queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF));
@ -1431,8 +1454,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepolyat(VBODY3 * VBS, shRatCape2, darkena(col, 2, 0xFF), PPR::MONSTER_ARMOR0); queuepolyat(VBODY3 * VBS, shRatCape2, darkena(col, 2, 0xFF), PPR::MONSTER_ARMOR0);
queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF)); queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF)); queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF));
return false;
} }
else if(m == moCrusher) {
case moCrusher: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, shRaiderBody); ShadowV(V, shRaiderBody);
queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF)); queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF));
@ -1442,8 +1467,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VBODY1 * VBS, shHammerHead, darkena(col, 0, 0XFF)); queuepoly(VBODY1 * VBS, shHammerHead, darkena(col, 0, 0XFF));
queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF)); queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF)); queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF));
return false;
} }
else if(m == moPair) {
case moPair: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, shRaiderBody); ShadowV(V, shRaiderBody);
queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF)); queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF));
@ -1452,8 +1479,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VBODY * VBS, shPickAxe, darkena(0xA0A0A0, 0, 0XFF)); queuepoly(VBODY * VBS, shPickAxe, darkena(0xA0A0A0, 0, 0XFF));
queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF)); queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF)); queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF));
return false;
} }
else if(m == moAltDemon || m == moHexDemon) {
case moAltDemon: case moHexDemon: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
ShadowV(V, shRaiderBody); ShadowV(V, shRaiderBody);
queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF)); queuepoly(VBODY * VBS, shRaiderBody, darkena(col, 0, 0xFF));
@ -1462,17 +1491,20 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
if(!peace::on) queuepoly(VBODY * VBS, shPSword, 0xFFD0D0D0); if(!peace::on) queuepoly(VBODY * VBS, shPSword, 0xFFD0D0D0);
queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF)); queuepoly(VHEAD1, shRaiderHelmet, darkena(col, 0, 0XFF));
queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF)); queuepoly(VHEAD, shPFace, darkena(0xC0C0A0, 0, 0XFF));
return false;
} }
else if(m == moPalace || m == moFatGuard || m == moVizier || m == moSkeleton) {
if(m == moSkeleton) { case moSkeleton: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(0xFFFFFF, 0, 0xFF), moSkeleton, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(0xFFFFFF, 0, 0xFF), moSkeleton, footphase);
queuepoly(VBS, shSkeletonBody, darkena(0xFFFFFF, 0, 0xFF)); queuepoly(VBS, shSkeletonBody, darkena(0xFFFFFF, 0, 0xFF));
queuepoly(VHEAD, shSkull, darkena(0xFFFFFF, 0, 0xFF)); queuepoly(VHEAD, shSkull, darkena(0xFFFFFF, 0, 0xFF));
queuepoly(VHEAD1, shSkullEyes, darkena(0, 0, 0xFF)); queuepoly(VHEAD1, shSkullEyes, darkena(0, 0, 0xFF));
ShadowV(V, shSkeletonBody); ShadowV(V, shSkeletonBody);
queuepoly(VBS, shSabre, 0xFFFFFFFF); queuepoly(VBS, shSabre, 0xFFFFFFFF);
return false;
} }
else {
case moPalace: case moFatGuard: case moVizier: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = otherbodyparts(V, darkena(0xFFD500, 0, 0xFF), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(0xFFD500, 0, 0xFF), m, footphase);
if(m == moFatGuard) { if(m == moFatGuard) {
@ -1493,49 +1525,46 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
if(!where || where->hitpoints >= 2) if(!where || where->hitpoints >= 2)
queuepoly(VHEAD2, shTurban2, darkena(col, 0, 0xFF)); queuepoly(VHEAD2, shTurban2, darkena(col, 0, 0xFF));
queuepoly(VBODY * VBS, shSabre, 0xFFFFFFFF); queuepoly(VBODY * VBS, shSabre, 0xFFFFFFFF);
return false;
} }
drawStunStars(V, where ? where->stuntime : 0); case moCrystalSage: {
}
else if(m == moCrystalSage) {
const transmatrix VBS = VBODY * otherbodyparts(V, 0xFFFFFFFF, m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, 0xFFFFFFFF, m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, 0xFFFFFFFF); queuepoly(VBS, shPBody, 0xFFFFFFFF);
queuepoly(VHEAD1, shPHead, 0xFFFFFFFF); queuepoly(VHEAD1, shPHead, 0xFFFFFFFF);
queuepoly(VHEAD, shPFace, 0xFFFFFFFF); queuepoly(VHEAD, shPFace, 0xFFFFFFFF);
return false;
} }
else if(m == moHedge) {
case moHedge: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
queuepoly(VBS, shPBody, darkena(col, 0, 0xFF)); queuepoly(VBS, shPBody, darkena(col, 0, 0xFF));
queuepoly(VBS, shHedgehogBlade, 0xC0C0C0FF); queuepoly(VBS, shHedgehogBlade, 0xC0C0C0FF);
queuepoly(VHEAD1, shPHead, 0x804000FF); queuepoly(VHEAD1, shPHead, 0x804000FF);
queuepoly(VHEAD, shPFace, 0xF09000FF); queuepoly(VHEAD, shPFace, 0xF09000FF);
return false;
} }
else if(m == moYeti || m == moMonkey) {
case moYeti: case moMonkey: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shYeti, darkena(col, 0, 0xC0)); queuepoly(VBS, shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, shPHead, darkena(col, 0, 0xFF)); queuepoly(VHEAD1, shPHead, darkena(col, 0, 0xFF));
return false;
} }
else if(m == moResearcher) {
case moResearcher: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(0xFFFF00, 0, 0xC0)); queuepoly(VBS, shPBody, darkena(0xFFFF00, 0, 0xC0));
queuepoly(VHEAD, shAztecHead, darkena(col, 0, 0xFF)); queuepoly(VHEAD, shAztecHead, darkena(col, 0, 0xFF));
queuepoly(VHEAD1, shAztecCap, darkena(0xC000C0, 0, 0xFF)); queuepoly(VHEAD1, shAztecCap, darkena(0xC000C0, 0, 0xFF));
return false;
} }
else if(m == moFamiliar) {
/* queuepoly(V, shFemaleBody, darkena(0xC0B070, 0, 0xFF));
queuepoly(V, shPFace, darkena(0xC0B070, 0, 0XFF));
queuepoly(V, shWizardCape1, 0x601000FF);
queuepoly(V, shWizardCape2, 0x781800FF);
queuepoly(V, shWizardHat1, 0x902000FF);
queuepoly(V, shWizardHat2, 0xA82800FF); */
// queuepoly(V, shCatBody, darkena(0x601000, 0, 0xFF));
// queuepoly(V, shGargoyleBody, darkena(0x903000, 0, 0xFF));
case moFamiliar: {
ShadowV(V, shWolfBody); ShadowV(V, shWolfBody);
queuepoly(VABODY, shWolfBody, darkena(0xA03000, 0, 0xFF)); queuepoly(VABODY, shWolfBody, darkena(0xA03000, 0, 0xFF));
if(mmspatial || footphase) if(mmspatial || footphase)
@ -1549,15 +1578,19 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VAHEAD, shFamiliarEye, darkena(0xFFFF000, 0, 0xFF)); queuepoly(VAHEAD, shFamiliarEye, darkena(0xFFFF000, 0, 0xFF));
queuepoly(VAHEAD * Mirror, shFamiliarEye, darkena(0xFFFF000, 0, 0xFF)); queuepoly(VAHEAD * Mirror, shFamiliarEye, darkena(0xFFFF000, 0, 0xFF));
} }
return false;
} }
else if(m == moRanger) {
case moRanger: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
queuepoly(VBS, shPBody, darkena(col, 0, 0xC0)); queuepoly(VBS, shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBS, shPSword, darkena(col, 0, 0xFF)); if(!peace::on) queuepoly(VBS, shPSword, darkena(col, 0, 0xFF));
queuepoly(VHEAD, shArmor, darkena(col, 1, 0xFF)); queuepoly(VHEAD, shArmor, darkena(col, 1, 0xFF));
return false;
} }
else if(m == moNarciss) {
case moNarciss: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
queuepoly(VBS, shFlowerHand, darkena(col, 0, 0xFF)); queuepoly(VBS, shFlowerHand, darkena(col, 0, 0xFF));
@ -1565,8 +1598,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
if(!peace::on) queuepoly(VBS, shPKnife, 0xC0C0C0FF); if(!peace::on) queuepoly(VBS, shPKnife, 0xC0C0C0FF);
queuepoly(VHEAD, shPFace, 0xFFE080FF); queuepoly(VHEAD, shPFace, 0xFFE080FF);
queuepoly(VHEAD1, shPHead, 0x806A00FF); queuepoly(VHEAD1, shPHead, 0x806A00FF);
return false;
} }
else if(m == moMirrorSpirit) {
case moMirrorSpirit: {
ShadowV(V, shPBody); ShadowV(V, shPBody);
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0x90), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0x90), m, footphase);
queuepoly(VBS, shPBody, darkena(col, 0, 0x90)); queuepoly(VBS, shPBody, darkena(col, 0, 0x90));
@ -1574,8 +1609,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VHEAD, shPHead, darkena(col, 1, 0x90)); queuepoly(VHEAD, shPHead, darkena(col, 1, 0x90));
queuepoly(VHEAD, shPFace, darkena(col, 1, 0x90)); queuepoly(VHEAD, shPFace, darkena(col, 1, 0x90));
queuepoly(VHEAD, shArmor, darkena(col, 0, 0xC0)); queuepoly(VHEAD, shArmor, darkena(col, 0, 0xC0));
return false;
} }
else if(m == moJiangshi) {
case moJiangshi: {
ShadowV(V, shJiangShi); ShadowV(V, shJiangShi);
auto z2 = geom3::lev_to_factor(abs(sin(footphase * M_PI * 2)) * geom3::human_height); auto z2 = geom3::lev_to_factor(abs(sin(footphase * M_PI * 2)) * geom3::human_height);
auto V0 = V; auto V0 = V;
@ -1587,52 +1624,60 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VHEAD, shPFace, darkena(col, 0, 0xFF)); queuepoly(VHEAD, shPFace, darkena(col, 0, 0xFF));
queuepoly(VHEAD, shJiangShiCap1, darkena(0x800000, 0, 0xFF)); queuepoly(VHEAD, shJiangShiCap1, darkena(0x800000, 0, 0xFF));
queuepoly(VHEAD, shJiangShiCap2, darkena(0x400000, 0, 0xFF)); queuepoly(VHEAD, shJiangShiCap2, darkena(0x400000, 0, 0xFF));
return false;
} }
else if(m == moGhost || m == moSeep || m == moFriendlyGhost) {
case moGhost: case moSeep: case moFriendlyGhost: {
if(m == moFriendlyGhost) col = fghostcolor(where); if(m == moFriendlyGhost) col = fghostcolor(where);
queuepoly(VGHOST, shGhost, darkena(col, 0, m == moFriendlyGhost ? 0xC0 : 0x80)); queuepoly(VGHOST, shGhost, darkena(col, 0, m == moFriendlyGhost ? 0xC0 : 0x80));
queuepoly(VGHOST, shEyes, 0xFF); queuepoly(VGHOST, shEyes, 0xFF);
return false;
} }
else if(m == moVineSpirit) {
case moVineSpirit: {
queuepoly(VGHOST, shGhost, 0xD0D0D0C0); queuepoly(VGHOST, shGhost, 0xD0D0D0C0);
queuepoly(VGHOST, shEyes, 0xFF0000FF); queuepoly(VGHOST, shEyes, 0xFF0000FF);
return false;
} }
else if(m == moFireFairy) {
case moFireFairy: {
col = firecolor(0); col = firecolor(0);
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shFemaleBody); ShadowV(V, shFemaleBody);
queuepoly(VBS, shFemaleBody, darkena(col, 0, 0XC0)); queuepoly(VBS, shFemaleBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, shWitchHair, darkena(col, 1, 0xFF)); queuepoly(VHEAD, shWitchHair, darkena(col, 1, 0xFF));
queuepoly(VHEAD, shPFace, darkena(col, 0, 0XFF)); queuepoly(VHEAD, shPFace, darkena(col, 0, 0XFF));
return false;
} }
else if(m == moSlime) {
case moSlime: {
queuepoly(VFISH, shSlime, darkena(col, 0, 0x80)); queuepoly(VFISH, shSlime, darkena(col, 0, 0x80));
queuepoly(VSLIMEEYE, shEyes, 0xFF); queuepoly(VSLIMEEYE, shEyes, 0xFF);
} }
else if(isSwitch(m)) { case moKrakenH: {
queuepoly(VFISH, shJelly, darkena(col, 0, 0xD0));
queuepolyat(VBODY, shJelly, darkena(col, 0, 0xD0), PPR::MONSTER_BODY);
queuepolyat(VHEAD, shJelly, darkena(col, 0, 0xD0), PPR::MONSTER_HEAD);
queuepolyat(VHEAD, shEyes, 0xFF, PPR::MONSTER_HEAD);
}
else if(m == moKrakenH) {
queuepoly(VFISH, shKrakenHead, darkena(col, 0, 0xD0)); queuepoly(VFISH, shKrakenHead, darkena(col, 0, 0xD0));
queuepoly(VFISH, shKrakenEye, 0xFFFFFFC0); queuepoly(VFISH, shKrakenEye, 0xFFFFFFC0);
queuepoly(VFISH, shKrakenEye2, 0xC0); queuepoly(VFISH, shKrakenEye2, 0xC0);
queuepoly(VFISH * Mirror, shKrakenEye, 0xFFFFFFC0); queuepoly(VFISH * Mirror, shKrakenEye, 0xFFFFFFC0);
queuepoly(VFISH * Mirror, shKrakenEye2, 0xC0); queuepoly(VFISH * Mirror, shKrakenEye2, 0xC0);
return false;
} }
else if(m == moKrakenT) {
case moKrakenT: {
queuepoly(VFISH, shSeaTentacle, darkena(col, 0, 0xD0)); queuepoly(VFISH, shSeaTentacle, darkena(col, 0, 0xD0));
return false;
} }
else if(m == moCultist || m == moPyroCultist || m == moCultistLeader) {
case moCultist: case moPyroCultist: case moCultistLeader: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(col, 0, 0xC0)); queuepoly(VBS, shPBody, darkena(col, 0, 0xC0));
if(!peace::on) queuepoly(VBS, shPSword, darkena(col, 2, 0xFF)); if(!peace::on) queuepoly(VBS, shPSword, darkena(col, 2, 0xFF));
queuepoly(VHEAD, shHood, darkena(col, 1, 0xFF)); queuepoly(VHEAD, shHood, darkena(col, 1, 0xFF));
return false;
} }
else if(m == moPirate) {
case moPirate: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(0x404040, 0, 0xFF)); queuepoly(VBS, shPBody, darkena(0x404040, 0, 0xFF));
@ -1640,8 +1685,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VHEAD, shPFace, darkena(0xFFFF80, 0, 0xFF)); queuepoly(VHEAD, shPFace, darkena(0xFFFF80, 0, 0xFF));
queuepoly(VHEAD1, shEyepatch, darkena(0, 0, 0xC0)); queuepoly(VHEAD1, shEyepatch, darkena(0, 0, 0xC0));
queuepoly(VHEAD2, shPirateHood, darkena(col, 0, 0xFF)); queuepoly(VHEAD2, shPirateHood, darkena(col, 0, 0xFF));
return false;
} }
else if(m == moRatling || m == moRatlingAvenger) {
case moRatling: case moRatlingAvenger: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shYeti); ShadowV(V, shYeti);
queuepoly(VLEG, shRatTail, darkena(col, 0, 0xFF)); queuepoly(VLEG, shRatTail, darkena(col, 0, 0xFF));
@ -1659,8 +1706,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VBODY1 * VBS, shRatCape2, 0x484848FF); queuepoly(VBODY1 * VBS, shRatCape2, 0x484848FF);
queuepoly(VHEAD, shRatCape1, 0x303030FF); queuepoly(VHEAD, shRatCape1, 0x303030FF);
} }
return false;
} }
else if(m == moViking) {
case moViking: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBODY * VBS, shPBody, darkena(0xE00000, 0, 0xFF)); queuepoly(VBODY * VBS, shPBody, darkena(0xE00000, 0, 0xFF));
@ -1668,8 +1717,10 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VBODY1 * VBS, shKnightCloak, darkena(0x404040, 0, 0xFF)); queuepoly(VBODY1 * VBS, shKnightCloak, darkena(0x404040, 0, 0xFF));
queuepoly(VHEAD, shVikingHelmet, darkena(0xC0C0C0, 0, 0XFF)); queuepoly(VHEAD, shVikingHelmet, darkena(0xC0C0C0, 0, 0XFF));
queuepoly(VHEAD, shPFace, darkena(0xFFFF80, 0, 0xFF)); queuepoly(VHEAD, shPFace, darkena(0xFFFF80, 0, 0xFF));
return false;
} }
else if(m == moOutlaw) {
case moOutlaw: {
const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBODY * VBS, shPBody, darkena(col, 0, 0xFF)); queuepoly(VBODY * VBS, shPBody, darkena(col, 0, 0xFF));
@ -1678,40 +1729,50 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(VHEAD, shWestHat2, darkena(col, 1, 0XFF)); queuepoly(VHEAD, shWestHat2, darkena(col, 1, 0XFF));
queuepoly(VHEAD, shPFace, darkena(0xFFFF80, 0, 0xFF)); queuepoly(VHEAD, shPFace, darkena(0xFFFF80, 0, 0xFF));
queuepoly(VBODY * VBS, shGunInHand, darkena(col, 1, 0XFF)); queuepoly(VBODY * VBS, shGunInHand, darkena(col, 1, 0XFF));
return false;
} }
else if(m == moNecromancer) {
case moNecromancer: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shPBody); ShadowV(V, shPBody);
queuepoly(VBS, shPBody, 0xC00000C0); queuepoly(VBS, shPBody, 0xC00000C0);
queuepoly(VHEAD, shHood, darkena(col, 1, 0xFF)); queuepoly(VHEAD, shHood, darkena(col, 1, 0xFF));
return false;
} }
else if(m == moDraugr) {
case moDraugr: {
const transmatrix VBS = VBODY * otherbodyparts(V, 0x483828D0, m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, 0x483828D0, m, footphase);
queuepoly(VBS, shPBody, 0x483828D0); queuepoly(VBS, shPBody, 0x483828D0);
queuepoly(VBS, shPSword, 0xFFFFD0A0); queuepoly(VBS, shPSword, 0xFFFFD0A0);
queuepoly(VHEAD, shPHead, 0x483828D0); queuepoly(VHEAD, shPHead, 0x483828D0);
// queuepoly(V, shSkull, 0xC06020D0); // queuepoly(V, shSkull, 0xC06020D0);
//queuepoly(V, shSkullEyes, 0x000000D0); //queuepoly(V, shSkullEyes, 0x000000D0);
// queuepoly(V, shWightCloak, 0xC0A080A0); // queuepoly(V, shWightCloak, 0xC0A080A0);
int b = where ? where->cpdist : 0; int b = where ? where->cpdist : 0;
b--; b--;
if(b < 0) b = 0; if(b < 0) b = 0;
if(b > 6) b = 6; if(b > 6) b = 6;
queuepoly(VHEAD1, shWightCloak, 0x605040A0 + 0x10101000 * b); queuepoly(VHEAD1, shWightCloak, 0x605040A0 + 0x10101000 * b);
return false;
} }
else if(m == moVoidBeast) {
case moVoidBeast: {
const transmatrix VBS = VBODY * otherbodyparts(V, 0x080808D0, m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, 0x080808D0, m, footphase);
queuepoly(VBS, shPBody, 0x080808D0); queuepoly(VBS, shPBody, 0x080808D0);
queuepoly(VHEAD, shPHead, 0x080808D0); queuepoly(VHEAD, shPHead, 0x080808D0);
queuepoly(VHEAD, shWightCloak, 0xFF0000A0); queuepoly(VHEAD, shWightCloak, 0xFF0000A0);
return false;
} }
else if(m == moGoblin) {
case moGoblin: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shYeti); ShadowV(V, shYeti);
queuepoly(VBS, shYeti, darkena(col, 0, 0xC0)); queuepoly(VBS, shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD, shArmor, darkena(col, 1, 0XFF)); queuepoly(VHEAD, shArmor, darkena(col, 1, 0XFF));
return false;
} }
else if(m == moLancer || m == moFlailer || m == moMiner) {
case moLancer: case moFlailer: case moMiner: {
transmatrix V2 = V; transmatrix V2 = V;
if(m == moLancer) if(m == moLancer)
V2 = V * spin((where && where->type == 6) ? -M_PI/3 : -M_PI/2 ); V2 = V * spin((where && where->type == 6) ? -M_PI/3 : -M_PI/2 );
@ -1730,64 +1791,140 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
queuepoly(Vb, shFlailChain, darkena(col, 1, 0XFF)); queuepoly(Vb, shFlailChain, darkena(col, 1, 0XFF));
queuepoly(Vb, shFlailTrunk, darkena(col, 0, 0XFF)); queuepoly(Vb, shFlailTrunk, darkena(col, 0, 0XFF));
} }
return false;
} }
else if(m == moTroll) {
case moTroll: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shYeti); ShadowV(V, shYeti);
queuepoly(VBS, shYeti, darkena(col, 0, 0xC0)); queuepoly(VBS, shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, shPHead, darkena(col, 1, 0XFF)); queuepoly(VHEAD1, shPHead, darkena(col, 1, 0XFF));
queuepoly(VHEAD, shPFace, darkena(col, 2, 0XFF)); queuepoly(VHEAD, shPFace, darkena(col, 2, 0XFF));
return false;
} }
else if(m == moFjordTroll || m == moForestTroll || m == moStormTroll) {
case moFjordTroll: case moForestTroll: case moStormTroll: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shYeti); ShadowV(V, shYeti);
queuepoly(VBS, shYeti, darkena(col, 0, 0xC0)); queuepoly(VBS, shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, shPHead, darkena(col, 1, 0XFF)); queuepoly(VHEAD1, shPHead, darkena(col, 1, 0XFF));
queuepoly(VHEAD, shPFace, darkena(col, 2, 0XFF)); queuepoly(VHEAD, shPFace, darkena(col, 2, 0XFF));
return false;
} }
else if(m == moDarkTroll) {
case moDarkTroll: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shYeti); ShadowV(V, shYeti);
queuepoly(VBS, shYeti, darkena(col, 0, 0xC0)); queuepoly(VBS, shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, shPHead, darkena(col, 1, 0XFF)); queuepoly(VHEAD1, shPHead, darkena(col, 1, 0XFF));
queuepoly(VHEAD, shPFace, 0xFFFFFF80); queuepoly(VHEAD, shPFace, 0xFFFFFF80);
return false;
} }
else if(m == moRedTroll) {
case moRedTroll: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xFF), m, footphase);
ShadowV(V, shYeti); ShadowV(V, shYeti);
queuepoly(VBS, shYeti, darkena(col, 0, 0xC0)); queuepoly(VBS, shYeti, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, shPHead, darkena(0xFF8000, 0, 0XFF)); queuepoly(VHEAD1, shPHead, darkena(0xFF8000, 0, 0XFF));
queuepoly(VHEAD, shPFace, 0xFFFFFF80); queuepoly(VHEAD, shPFace, 0xFFFFFF80);
return false;
} }
else if(m == moEarthElemental) {
case moEarthElemental: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
ShadowV(V, shWaterElemental); ShadowV(V, shWaterElemental);
queuepoly(VBS, shWaterElemental, darkena(col, 0, 0xC0)); queuepoly(VBS, shWaterElemental, darkena(col, 0, 0xC0));
queuepoly(VHEAD1, shFemaleHair, darkena(col, 0, 0XFF)); queuepoly(VHEAD1, shFemaleHair, darkena(col, 0, 0XFF));
queuepoly(VHEAD, shPFace, 0xF0000080); queuepoly(VHEAD, shPFace, 0xF0000080);
return false;
} }
else if(m == moWaterElemental) {
case moWaterElemental: {
const transmatrix VBS = VBODY * otherbodyparts(V, watercolor(50), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, watercolor(50), m, footphase);
ShadowV(V, shWaterElemental); ShadowV(V, shWaterElemental);
queuepoly(VBS, shWaterElemental, watercolor(0)); queuepoly(VBS, shWaterElemental, watercolor(0));
queuepoly(VHEAD1, shFemaleHair, watercolor(100)); queuepoly(VHEAD1, shFemaleHair, watercolor(100));
queuepoly(VHEAD, shPFace, watercolor(200)); queuepoly(VHEAD, shPFace, watercolor(200));
return false;
} }
else if(m == moFireElemental) {
case moFireElemental: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(firecolor(50), 0, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(firecolor(50), 0, 0xFF), m, footphase);
ShadowV(V, shWaterElemental); ShadowV(V, shWaterElemental);
queuepoly(VBS, shWaterElemental, darkena(firecolor(0), 0, 0xFF)); queuepoly(VBS, shWaterElemental, darkena(firecolor(0), 0, 0xFF));
queuepoly(VHEAD1, shFemaleHair, darkena(firecolor(100), 0, 0xFF)); queuepoly(VHEAD1, shFemaleHair, darkena(firecolor(100), 0, 0xFF));
queuepoly(VHEAD, shPFace, darkena(firecolor(200), 0, 0xFF)); queuepoly(VHEAD, shPFace, darkena(firecolor(200), 0, 0xFF));
return false;
} }
else if(m == moAirElemental) {
case moAirElemental: {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0x40), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0x40), m, footphase);
ShadowV(V, shWaterElemental); ShadowV(V, shWaterElemental);
queuepoly(VBS, shWaterElemental, darkena(col, 0, 0x80)); queuepoly(VBS, shWaterElemental, darkena(col, 0, 0x80));
queuepoly(VHEAD1, shFemaleHair, darkena(col, 0, 0x80)); queuepoly(VHEAD1, shFemaleHair, darkena(col, 0, 0x80));
queuepoly(VHEAD, shPFace, darkena(col, 0, 0x80)); queuepoly(VHEAD, shPFace, darkena(col, 0, 0x80));
return false;
} }
else if((xch == 'd' || xch == 'D') && m != moDragonHead && m != moDragonTail) {
case moWorm: case moWormwait: case moHexSnake: {
queuepoly(V, shWormHead, darkena(col, 0, 0xFF));
queuepolyat(V, shEyes, 0xFF, PPR::ONTENTACLE_EYES);
return false;
}
case moDragonHead: {
queuepoly(V, shDragonHead, darkena(col, 0, 0xFF));
queuepolyat(V, shEyes, 0xFF, PPR::ONTENTACLE_EYES);
int noscolor = 0xFF0000FF;
queuepoly(V, shDragonNostril, noscolor);
queuepoly(V * Mirror, shDragonNostril, noscolor);
return false;
}
case moDragonTail: {
queuepoly(V, shDragonSegment, darkena(col, 0, 0xFF));
return false;
}
case moTentacle: case moTentaclewait: case moTentacleEscaping: {
queuepoly(V, shTentHead, darkena(col, 0, 0xFF));
ShadowV(V, shTentHead, PPR::GIANTSHADOW);
return false;
}
default: ;
}
if(isPrincess(m)) goto princess;
else if(isBull(m)) {
ShadowV(V, shBullBody);
int hoofcol = darkena(gradient(0, col, 0, .65, 1), 0, 0xFF);
if(mmspatial || footphase)
animallegs(VALEGS, moRagingBull, hoofcol, footphase);
queuepoly(VABODY, shBullBody, darkena(gradient(0, col, 0, .80, 1), 0, 0xFF));
queuepoly(VAHEAD, shBullHead, darkena(col, 0, 0xFF));
queuepoly(VAHEAD, shBullHorn, darkena(0xFFFFFF, 0, 0xFF));
queuepoly(VAHEAD * Mirror, shBullHorn, darkena(0xFFFFFF, 0, 0xFF));
}
else if(isBug(m)) {
ShadowV(V, shBugBody);
if(!mmspatial && !footphase)
queuepoly(VABODY, shBugBody, darkena(col, 0, 0xFF));
else {
animallegs(VALEGS, moBug0, darkena(col, 0, 0xFF), footphase);
queuepoly(VABODY, shBugAntenna, darkena(col, 1, 0xFF));
}
queuepoly(VABODY, shBugArmor, darkena(col, 1, 0xFF));
}
else if(isSwitch(m)) {
queuepoly(VFISH, shJelly, darkena(col, 0, 0xD0));
queuepolyat(VBODY, shJelly, darkena(col, 0, 0xD0), PPR::MONSTER_BODY);
queuepolyat(VHEAD, shJelly, darkena(col, 0, 0xD0), PPR::MONSTER_HEAD);
queuepolyat(VHEAD, shEyes, 0xFF, PPR::MONSTER_HEAD);
}
else if(isDemon(m)) {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 0, 0xC0), m, footphase);
queuepoly(VBS, shPBody, darkena(col, 1, 0xC0)); queuepoly(VBS, shPBody, darkena(col, 1, 0xC0));
ShadowV(V, shPBody); ShadowV(V, shPBody);
@ -1811,12 +1948,6 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
int acol = col; int acol = col;
queuepoly(VAHEAD, shTrylobiteHead, darkena(acol, 0, 0xFF)); queuepoly(VAHEAD, shTrylobiteHead, darkena(acol, 0, 0xFF));
} }
else if(m == moEvilGolem || m == moIceGolem) {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 2, 0xC0), m, footphase);
ShadowV(V, shPBody);
queuepoly(VBS, shPBody, darkena(col, 0, 0XC0));
queuepoly(VHEAD, shGolemhead, darkena(col, 1, 0XFF));
}
else if(isWitch(m)) { else if(isWitch(m)) {
const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase); const transmatrix VBS = VBODY * otherbodyparts(V, darkena(col, 1, 0xFF), m, footphase);
int cc = 0xFF; int cc = 0xFF;
@ -1838,27 +1969,9 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col,
} }
// just for the HUD glyphs... // just for the HUD glyphs...
else if(isIvy(m) || isMutantIvy(m) || m == moFriendlyIvy) { else if(isAnyIvy(m)) {
queuepoly(V, shILeaf[0], darkena(col, 0, 0xFF)); queuepoly(V, shILeaf[0], darkena(col, 0, 0xFF));
} }
else if(m == moWorm || m == moWormwait || m == moHexSnake) {
queuepoly(V, shWormHead, darkena(col, 0, 0xFF));
queuepolyat(V, shEyes, 0xFF, PPR::ONTENTACLE_EYES);
}
else if(m == moDragonHead) {
queuepoly(V, shDragonHead, darkena(col, 0, 0xFF));
queuepolyat(V, shEyes, 0xFF, PPR::ONTENTACLE_EYES);
int noscolor = 0xFF0000FF;
queuepoly(V, shDragonNostril, noscolor);
queuepoly(V * Mirror, shDragonNostril, noscolor);
}
else if(m == moDragonTail) {
queuepoly(V, shDragonSegment, darkena(col, 0, 0xFF));
}
else if(m == moTentacle || m == moTentaclewait || m == moTentacleEscaping) {
queuepoly(V, shTentHead, darkena(col, 0, 0xFF));
ShadowV(V, shTentHead, PPR::GIANTSHADOW);
}
else return true; else return true;