6345 lines
191 KiB
C++
6345 lines
191 KiB
C++
// Hyperbolic Rogue -- graphics
|
|
|
|
// Copyright (C) 2011-2012 Zeno Rogue, see 'hyper.cpp' for details
|
|
|
|
// basic graphics:
|
|
|
|
#define WOLNIEJ 1
|
|
#define BTOFF 0x404040
|
|
#define BTON 0xC0C000
|
|
|
|
// #define PANDORA
|
|
|
|
|
|
#ifndef MOBILE
|
|
#include <SDL/SDL.h>
|
|
|
|
#ifdef AUDIO
|
|
#include <SDL/SDL_mixer.h>
|
|
#endif
|
|
bool audio;
|
|
int audiovolume = 60;
|
|
|
|
#ifndef MAC
|
|
#undef main
|
|
#endif
|
|
|
|
#include <SDL/SDL_ttf.h>
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
|
|
// x resolutions
|
|
|
|
#define NUMMODES 7
|
|
|
|
SDL_Surface *s;
|
|
TTF_Font *font[256];
|
|
SDL_Joystick* sticks[8];
|
|
int numsticks;
|
|
|
|
#endif
|
|
|
|
ld shiftmul = 1;
|
|
|
|
bool inHighQual; // taking high quality screenshot
|
|
int webdisplay = 0;
|
|
|
|
// R:239, G:208, B:207
|
|
|
|
unsigned int skincolors[] = { 7, 0xD0D0D0FF, 0xEFD0C9FF, 0xC77A58FF, 0xA58869FF, 0x602010FF, 0xFFDCB1FF, 0xEDE4C8FF };
|
|
unsigned int haircolors[] = { 8, 0x686868FF, 0x8C684AFF, 0xF2E1AEFF, 0xB55239FF, 0xFFFFFFFF, 0x804000FF, 0x502810FF, 0x301800FF };
|
|
unsigned int dresscolors[] = { 6, 0xC00000FF, 0x00C000FF, 0x0000C0FF, 0xC0C000FF, 0xC0C0C0FF, 0x202020FF };
|
|
unsigned int dresscolors2[] = { 7, 0x8080FFC0, 0x80FF80C0, 0xFF8080C0, 0xFFFF80C0, 0xFF80FFC0, 0x80FFFFC0, 0xFFFFFF80 };
|
|
unsigned int swordcolors[] = { 6, 0xC0C0C0FF, 0xFFFFFFFF, 0xFFC0C0FF, 0xC0C0FFFF, 0x808080FF, 0x202020FF };
|
|
unsigned int eyecolors[] = { 4, 0x00C000FF, 0x0000C0FF, 0xC00000FF, 0xC0C000FF };
|
|
|
|
// is the player using mouse? (used for auto-cross)
|
|
bool mousing = true;
|
|
|
|
// is the mouse button pressed?
|
|
bool mousepressed = false;
|
|
|
|
emtype cmode = emNormal, lastmode = emNormal; // last mode in Help
|
|
|
|
//
|
|
int axestate;
|
|
|
|
int ticks;
|
|
|
|
videopar vid;
|
|
int default_language;
|
|
|
|
charstyle& getcs() {
|
|
if(shmup::on && shmup::players>1 && shmup::cpid >= 0 && shmup::cpid < shmup::players)
|
|
return shmup::scs[shmup::cpid];
|
|
else
|
|
return vid.cs;
|
|
}
|
|
|
|
int playergender() {
|
|
return (getcs().charid&1) ? GEN_F : GEN_M;
|
|
}
|
|
int princessgender() {
|
|
int g = playergender();
|
|
if(vid.samegender) return g;
|
|
return g == GEN_M ? GEN_F : GEN_M;
|
|
}
|
|
|
|
int lang() {
|
|
if(vid.language >= 0)
|
|
return vid.language;
|
|
return default_language;
|
|
}
|
|
|
|
int sightrange = 7;
|
|
|
|
cell *mouseover, *mouseover2, *lmouseover, *centerover, *lcenterover;
|
|
ld modist, modist2, centdist;
|
|
string mouseovers;
|
|
|
|
movedir mousedest, joydir;
|
|
|
|
int mousex, mousey, joyx, joyy, panjoyx, panjoyy;
|
|
bool autojoy = true;
|
|
hyperpoint mouseh;
|
|
|
|
bool leftclick, rightclick, targetclick, hiliteclick, anyshiftclick;
|
|
bool gtouched;
|
|
bool revcontrol;
|
|
|
|
int getcstat; ld getcshift;
|
|
|
|
int ZZ;
|
|
|
|
string help;
|
|
|
|
int andmode = 0;
|
|
|
|
int darken = 0;
|
|
|
|
bool doHighlight() {
|
|
return (hiliteclick && darken < 2) ? vid.monmode == 2 : vid.monmode == 3;
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
int& qpixel(SDL_Surface *surf, int x, int y) {
|
|
if(x<0 || y<0 || x >= surf->w || y >= surf->h) return ZZ;
|
|
char *p = (char*) surf->pixels;
|
|
p += y * surf->pitch;
|
|
int *pi = (int*) (p);
|
|
return pi[x];
|
|
}
|
|
|
|
int qpixel3(SDL_Surface *surf, int x, int y) {
|
|
if(x<0 || y<0 || x >= surf->w || y >= surf->h) return ZZ;
|
|
char *p = (char*) surf->pixels;
|
|
p += y * surf->pitch;
|
|
p += x;
|
|
int *pi = (int*) (p);
|
|
return pi[0];
|
|
}
|
|
|
|
void loadfont(int siz) {
|
|
if(!font[siz]) {
|
|
font[siz] = TTF_OpenFont("DejaVuSans-Bold.ttf", siz);
|
|
// Destination set by ./configure (in the GitHub repository)
|
|
#ifdef FONTDESTDIR
|
|
if (font[siz] == NULL) {
|
|
font[siz] = TTF_OpenFont(FONTDESTDIR, siz);
|
|
}
|
|
#endif
|
|
if (font[siz] == NULL) {
|
|
printf("error: Font file not found\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
int textwidth(int siz, const string &str) {
|
|
if(size(str) == 0) return 0;
|
|
|
|
loadfont(siz);
|
|
|
|
int w, h;
|
|
TTF_SizeUTF8(font[siz], str.c_str(), &w, &h);
|
|
// printf("width = %d [%d]\n", w, size(str));
|
|
return w;
|
|
}
|
|
#endif
|
|
|
|
#ifdef IOS
|
|
|
|
int textwidth(int siz, const string &str) {
|
|
return mainfont->getSize(str, siz / 36.0).width;
|
|
}
|
|
|
|
#endif
|
|
|
|
int gradient(int c0, int c1, ld v0, ld v, ld v1);
|
|
|
|
#ifdef LOCAL
|
|
double fadeout = 1;
|
|
#endif
|
|
|
|
int darkened(int c) {
|
|
#ifdef LOCAL
|
|
c = gradient(0, c, 0, fadeout, 1);
|
|
#endif
|
|
// c = ((c & 0xFFFF) << 8) | ((c & 0xFF0000) >> 16);
|
|
// c = ((c & 0xFFFF) << 8) | ((c & 0xFF0000) >> 16);
|
|
for(int i=0; i<darken; i++) c &= 0xFEFEFE, c >>= 1;
|
|
return c;
|
|
}
|
|
|
|
int darkenedby(int c, int lev) {
|
|
for(int i=0; i<lev; i++) c &= 0xFEFEFE, c >>= 1;
|
|
return c;
|
|
}
|
|
|
|
int darkena(int c, int lev, int a) {
|
|
for(int i=0; i<lev; i++) c &= 0xFEFEFE, c >>= 1;
|
|
return (c << 8) + a;
|
|
}
|
|
|
|
#ifdef GL
|
|
|
|
int lalpha = 0xFF;
|
|
|
|
void glcolor(int color) {
|
|
unsigned char *c = (unsigned char*) (&color);
|
|
glColor4f(c[2] / 255.0, c[1] / 255.0, c[0]/255.0, lalpha / 255.0); // c[3]/255.0);
|
|
}
|
|
|
|
void selectEyeGL(int ed) {
|
|
DEBB(DF_GRAPH, (debugfile,"selectEyeGL\n"));
|
|
float ve = ed*vid.eye;
|
|
ve *= 2; // vid.xres; ve /= vid.radius;
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
|
|
float lowdepth = 0.1;
|
|
float hidepth = 1e9;
|
|
|
|
// simulate glFrustum
|
|
GLfloat frustum[16] = {
|
|
GLfloat(vid.yres * 1./vid.xres), 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, -(hidepth+lowdepth)/(hidepth-lowdepth), -1,
|
|
0, 0, -2*lowdepth*hidepth/(hidepth-lowdepth), 0};
|
|
|
|
if(ve)
|
|
glTranslatef(-(ve * vid.radius) * (vid.alpha - (vid.radius*1./vid.xres) * vid.eye) / vid.xres, 0, 0);
|
|
|
|
glTranslatef((vid.xcenter*2.)/vid.xres - 1, 1 - (vid.ycenter*2.)/vid.yres, 0);
|
|
|
|
glMultMatrixf(frustum);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
GLfloat sc = vid.radius / (vid.yres/2.);
|
|
GLfloat mat[16] = {sc,0,0,0, 0,-sc,0,0, 0,0,-1,0, 0,0, GLfloat(-vid.alpha),1};
|
|
glMultMatrixf(mat);
|
|
|
|
if(ve) glTranslatef(ve, 0, vid.eye);
|
|
|
|
vid.scrdist = -vid.alpha + vid.yres * sc / 2;
|
|
}
|
|
|
|
void selectEyeMask(int ed) {
|
|
if(ed == 0) {
|
|
glColorMask( GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE );
|
|
}
|
|
else if(ed == 1) {
|
|
glColorMask( GL_TRUE,GL_FALSE,GL_FALSE,GL_TRUE );
|
|
}
|
|
else if(ed == -1) {
|
|
glColorMask( GL_FALSE,GL_TRUE,GL_TRUE,GL_TRUE );
|
|
}
|
|
}
|
|
|
|
void setGLProjection() {
|
|
DEBB(DF_GRAPH, (debugfile,"setGLProjection\n"));
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
|
|
glClearColor(0,0,0,1);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
selectEyeGL(0);
|
|
}
|
|
|
|
bool GL_initialized = false;
|
|
void buildpolys();
|
|
|
|
#ifndef MOBILE
|
|
|
|
struct glfont_t {
|
|
GLuint * textures; // Holds The Texture Id's
|
|
//GLuint list_base; // Holds The First Display List ID
|
|
int widths[128+NUMEXTRA];
|
|
int heights[128+NUMEXTRA];
|
|
float tx[128+NUMEXTRA];
|
|
float ty[128+NUMEXTRA];
|
|
};
|
|
|
|
glfont_t *glfont[256];
|
|
|
|
void init(const char * fname, unsigned int h);
|
|
|
|
inline int next_p2 (int a )
|
|
{
|
|
int rval=1;
|
|
// rval<<=1 Is A Prettier Way Of Writing rval*=2;
|
|
while(rval<a) rval<<=1;
|
|
return rval;
|
|
}
|
|
|
|
void glError(const char* GLcall, const char* file, const int line) {
|
|
GLenum errCode = glGetError();
|
|
if(errCode!=GL_NO_ERROR) {
|
|
fprintf(stderr, "OPENGL ERROR #%i: in file %s on line %i :: %s\n",errCode,file, line, GLcall);
|
|
}
|
|
}
|
|
#define GLERR(call) glError(call, __FILE__, __LINE__)
|
|
|
|
void init_glfont(int size) {
|
|
if(glfont[size]) return;
|
|
DEBB(DF_INIT, (debugfile,"init GL font: %d\n", size));
|
|
|
|
glfont[size] = new glfont_t;
|
|
|
|
glfont_t& f(*(glfont[size]));
|
|
|
|
f.textures = new GLuint[128+NUMEXTRA];
|
|
//f.list_base = glGenLists(128);
|
|
glGenTextures( 128+NUMEXTRA, f.textures );
|
|
|
|
loadfont(size);
|
|
if(!font[size]) return;
|
|
|
|
char str[2]; str[1] = 0;
|
|
|
|
SDL_Color white;
|
|
white.r = white.g = white.b = 255;
|
|
|
|
glListBase(0);
|
|
|
|
for(unsigned char ch=1;ch<128+NUMEXTRA;ch++) {
|
|
// printf("init size=%d ch=%d\n", size, ch);
|
|
|
|
SDL_Surface *txt;
|
|
|
|
if(ch < 128) {
|
|
str[0] = ch;
|
|
txt = TTF_RenderText_Blended(font[size], str, white);
|
|
}
|
|
else {
|
|
txt = TTF_RenderUTF8_Blended(font[size], natchars[ch-128], white);
|
|
}
|
|
if(txt == NULL) continue;
|
|
// printf("a\n");
|
|
|
|
int twidth = next_p2( txt->w );
|
|
int theight = next_p2( txt->h );
|
|
|
|
Uint16 expanded_data[twidth * theight];
|
|
|
|
for(int j=0; j <theight;j++) for(int i=0; i < twidth; i++) {
|
|
expanded_data[(i+j*twidth)] =
|
|
(i>=txt->w || j>=txt->h) ? 0 : ((qpixel(txt, i, j)>>24)&0xFF) * 0x101;
|
|
}
|
|
|
|
// printf("b\n");
|
|
f.widths[ch] = txt->w;
|
|
f.heights[ch] = txt->h;
|
|
|
|
glBindTexture( GL_TEXTURE_2D, f.textures[ch]);
|
|
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
|
|
|
|
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, twidth, theight, 0,
|
|
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expanded_data );
|
|
|
|
// printf("c\n");
|
|
|
|
float x=(float)txt->w / (float)twidth;
|
|
float y=(float)txt->h / (float)theight;
|
|
f.tx[ch] = x;
|
|
f.ty[ch] = y;
|
|
|
|
/* glNewList(f.list_base+ch,GL_COMPILE);
|
|
glBindTexture(GL_TEXTURE_2D, f.textures[ch]);
|
|
|
|
//glPushMatrix();
|
|
|
|
// glTranslatef(bitmap_glyph->left,0,0);
|
|
// glTranslatef(0,bitmap_glyph->top-bitmap.rows,0);
|
|
|
|
// printf("d\n");
|
|
|
|
glBegin(GL_QUADS);
|
|
float eps=0;
|
|
glTexCoord2d(eps,eps); glVertex2f(0, txt->h);
|
|
glTexCoord2d(eps,y-0); glVertex2f(0, 0);
|
|
glTexCoord2d(x-eps,y-0); glVertex2f(txt->w, 0);
|
|
glTexCoord2d(x-eps,0); glVertex2f(txt->w, txt->h);
|
|
glEnd();
|
|
glEndList(); */
|
|
//glPopMatrix();
|
|
|
|
SDL_FreeSurface(txt);
|
|
}
|
|
|
|
//printf("init size=%d ok\n", size);
|
|
GLERR("initfont");
|
|
}
|
|
|
|
int getnext(const char* s, int& i) {
|
|
for(int k=0; k<NUMEXTRA; k++)
|
|
if(s[i] == natchars[k][0] && s[i+1] == natchars[k][1]) {
|
|
i += 2; return 128+k;
|
|
}
|
|
if(s[i] < 0 && s[i+1] < 0) {
|
|
printf("Unknown character: '%c%c'\n", s[i], s[i+1]);
|
|
i += 2; return '?';
|
|
}
|
|
return s[i++];
|
|
}
|
|
|
|
bool gl_print(int x, int y, int shift, int size, const char *s, int color, int align) {
|
|
|
|
// printf("gl_print: %s\n", s.c_str());
|
|
|
|
// We Want A Coordinate System Where Distance Is Measured In Window Pixels.
|
|
|
|
/*
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
gluOrtho2D(0, 0, vid.xscr, vid.yscr); */
|
|
|
|
init_glfont(size);
|
|
if(!font[size]) return false;
|
|
|
|
glfont_t& f(*glfont[size]);
|
|
|
|
glDisable(GL_LIGHTING);
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
glcolor(color);
|
|
|
|
int tsize = 0;
|
|
for(int i=0; s[i];) tsize += f.widths[getnext(s,i)];
|
|
x -= tsize * align / 16;
|
|
y += f.heights[32]/2;
|
|
|
|
bool clicked = (mousex >= x && mousey <= y && mousex <= x+tsize && mousey >= y-f.heights[32]);
|
|
|
|
for(int i=0; s[i];) {
|
|
|
|
// glListBase(f.list_base);
|
|
// glCallList(s[i]); // s[i]);
|
|
|
|
int tabid = getnext(s,i);
|
|
float fx=f.tx[tabid];
|
|
float fy=f.ty[tabid];
|
|
int wi = f.widths[tabid];
|
|
int hi = f.heights[tabid];
|
|
|
|
GLERR("pre-print");
|
|
|
|
for(int ed = (vid.goteyes && shift)?-1:0; ed<2; ed+=2) {
|
|
glPushMatrix();
|
|
glTranslatef(x-ed*shift-vid.xcenter,y-vid.ycenter, vid.scrdist);
|
|
selectEyeMask(ed);
|
|
glBindTexture(GL_TEXTURE_2D, f.textures[tabid]);
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2d(0,0); glVertex2f(0, -hi);
|
|
glTexCoord2d(0,fy); glVertex2f(0, 0);
|
|
glTexCoord2d(fx,fy); glVertex2f(wi, 0);
|
|
glTexCoord2d(fx,0); glVertex2f(wi, -hi);
|
|
glEnd();
|
|
glPopMatrix();
|
|
}
|
|
|
|
if(vid.goteyes) selectEyeMask(0);
|
|
|
|
GLERR("print");
|
|
|
|
// int tabid = s[i];
|
|
x += f.widths[tabid];
|
|
|
|
/*
|
|
printf("point %d,%d\n", x, y);
|
|
glBegin(GL_POINTS);
|
|
glVertex3f(rand() % 100 - rand() % 100, rand() % 100 - rand() % 100, 100);
|
|
glEnd(); */
|
|
|
|
}
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
return clicked;
|
|
// printf("gl_print ok\n");
|
|
}
|
|
#endif
|
|
|
|
void resetGL() {
|
|
DEBB(DF_INIT, (debugfile,"reset GL\n"));
|
|
GL_initialized = false;
|
|
#ifndef MOBILE
|
|
for(int i=0; i<128; i++) if(glfont[i]) {
|
|
delete glfont[i];
|
|
glfont[i] = NULL;
|
|
}
|
|
#endif
|
|
buildpolys();
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
bool displaystr(int x, int y, int shift, int size, const char *str, int color, int align) {
|
|
|
|
if(strlen(str) == 0) return false;
|
|
|
|
if(size <= 0 || size > 255) {
|
|
// printf("size = %d\n", size);
|
|
return false;
|
|
}
|
|
|
|
#ifdef GL
|
|
if(vid.usingGL) return gl_print(x, y, shift, size, str, color, align);
|
|
#endif
|
|
|
|
SDL_Color col;
|
|
col.r = (color >> 16) & 255;
|
|
col.g = (color >> 8 ) & 255;
|
|
col.b = (color >> 0 ) & 255;
|
|
|
|
col.r >>= darken; col.g >>= darken; col.b >>= darken;
|
|
|
|
loadfont(size);
|
|
|
|
SDL_Surface *txt = (vid.usingAA?TTF_RenderUTF8_Blended:TTF_RenderUTF8_Solid)(font[size], str, col);
|
|
|
|
if(txt == NULL) return false;
|
|
|
|
SDL_Rect rect;
|
|
|
|
rect.w = txt->w;
|
|
rect.h = txt->h;
|
|
|
|
rect.x = x - rect.w * align / 16;
|
|
rect.y = y - rect.h/2;
|
|
|
|
bool clicked = (mousex >= rect.x && mousey >= rect.y && mousex <= rect.x+rect.w && mousey <= rect.y+rect.h);
|
|
|
|
if(shift) {
|
|
SDL_Surface* txt2 = SDL_DisplayFormat(txt);
|
|
SDL_LockSurface(txt2);
|
|
SDL_LockSurface(s);
|
|
int c0 = qpixel(txt2, 0, 0);
|
|
for(int yy=0; yy<rect.h; yy++)
|
|
for(int xx=0; xx<rect.w; xx++) if(qpixel(txt2, xx, yy) != c0)
|
|
qpixel(s, rect.x+xx-shift, rect.y+yy) |= color & 0xFF0000,
|
|
qpixel(s, rect.x+xx+shift, rect.y+yy) |= color & 0x00FFFF;
|
|
SDL_UnlockSurface(s);
|
|
SDL_UnlockSurface(txt2);
|
|
SDL_FreeSurface(txt2);
|
|
}
|
|
else {
|
|
SDL_BlitSurface(txt, NULL, s,&rect);
|
|
}
|
|
SDL_FreeSurface(txt);
|
|
|
|
return clicked;
|
|
}
|
|
|
|
bool displaystr(int x, int y, int shift, int size, const string &s, int color, int align) {
|
|
return displaystr(x, y, shift, size, s.c_str(), color, align);
|
|
}
|
|
|
|
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align) {
|
|
displaystr(x-b, y, 0, size, s, 0, align);
|
|
displaystr(x+b, y, 0, size, s, 0, align);
|
|
displaystr(x, y-b, 0, size, s, 0, align);
|
|
displaystr(x, y+b, 0, size, s, 0, align);
|
|
return displaystr(x, y, 0, size, s, color, align);
|
|
}
|
|
|
|
bool displaychr(int x, int y, int shift, int size, char chr, int col) {
|
|
|
|
char buf[2];
|
|
buf[0] = chr; buf[1] = 0;
|
|
return displaystr(x, y, shift, size, buf, col, 8);
|
|
}
|
|
|
|
#else
|
|
|
|
vector<int> graphdata;
|
|
|
|
void gdpush(int t) {
|
|
graphdata.push_back(t);
|
|
}
|
|
|
|
bool displaychr(int x, int y, int shift, int size, char chr, int col) {
|
|
gdpush(2); gdpush(x); gdpush(y); gdpush(8);
|
|
gdpush(col); gdpush(size); gdpush(0);
|
|
gdpush(1); gdpush(chr);
|
|
return false;
|
|
}
|
|
|
|
void gdpush_utf8(const string& s) {
|
|
int g = (int) graphdata.size(), q = 0;
|
|
gdpush((int) s.size()); for(int i=0; i<s.size(); i++) {
|
|
#ifdef ANDROID
|
|
unsigned char uch = (unsigned char) s[i];
|
|
if(uch >= 192 && uch < 224) {
|
|
int u = ((s[i] - 192)&31) << 6;
|
|
i++;
|
|
u += (s[i] - 128) & 63;
|
|
gdpush(u); q++;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
gdpush(s[i]); q++;
|
|
}
|
|
}
|
|
graphdata[g] = q;
|
|
}
|
|
|
|
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align) {
|
|
gdpush(2); gdpush(x); gdpush(y); gdpush(align);
|
|
gdpush(color); gdpush(size); gdpush(b);
|
|
gdpush_utf8(s);
|
|
int mx = mousex - x;
|
|
int my = mousey - y;
|
|
int len = (int) s.size();
|
|
return
|
|
mx >= -len*size*align/32 && mx <= +len*size*(16-align)/32 &&
|
|
my >= -size*3/4 && my <= +size*3/4;
|
|
}
|
|
|
|
bool displaystr(int x, int y, int shift, int size, const string &s, int color, int align) {
|
|
return displayfr(x,y,0,size,s,color,align);
|
|
}
|
|
|
|
bool displaystr(int x, int y, int shift, int size, char const *s, int color, int align) {
|
|
return displayfr(x,y,0,size,s,color,align);
|
|
}
|
|
|
|
#endif
|
|
|
|
bool displaynum(int x, int y, int shift, int size, int col, int val, string title) {
|
|
char buf[64];
|
|
sprintf(buf, "%d", val);
|
|
bool b1 = displayfr(x-8, y, 1, size, buf, col, 16);
|
|
bool b2 = displayfr(x, y, 1, size, title, col, 0);
|
|
if((b1 || b2) && gtouched) {
|
|
col ^= 0x00FFFF;
|
|
displayfr(x-8, y, 1, size, buf, col, 16);
|
|
displayfr(x, y, 1, size, title, col, 0);
|
|
}
|
|
return b1 || b2;
|
|
}
|
|
|
|
struct msginfo {
|
|
int stamp;
|
|
char flashout;
|
|
char spamtype;
|
|
string msg;
|
|
};
|
|
|
|
vector<msginfo> msgs;
|
|
|
|
vector<string> gamelog;
|
|
|
|
void flashMessages() {
|
|
for(int i=0; i<size(msgs); i++)
|
|
if(msgs[i].stamp < ticks - 1000 && !msgs[i].flashout) {
|
|
msgs[i].flashout = true;
|
|
msgs[i].stamp = ticks;
|
|
}
|
|
}
|
|
|
|
void addMessage(string s, char spamtype) {
|
|
DEBB(DF_MSG, (debugfile,"addMessage: %s\n", s.c_str()));
|
|
if(gamelog.size() == 20) {
|
|
for(int i=0; i<19; i++) gamelog[i] = gamelog[i+1];
|
|
gamelog[19] = s;
|
|
}
|
|
else gamelog.push_back(s);
|
|
msginfo m;
|
|
m.msg = s; m.spamtype = spamtype; m.flashout = false; m.stamp = ticks;
|
|
msgs.push_back(m);
|
|
// printf("%s\n", s.c_str());
|
|
}
|
|
|
|
void drawmessages() {
|
|
DEBB(DF_GRAPH, (debugfile,"draw messages\n"));
|
|
int i = 0;
|
|
int t = ticks;
|
|
for(int j=0; j<size(msgs); j++) {
|
|
int age = msgs[j].flashout * (t - msgs[j].stamp);
|
|
if(msgs[j].spamtype) {
|
|
for(int i=j+1; i<size(msgs); i++) if(msgs[i].spamtype == msgs[j].spamtype)
|
|
msgs[j].flashout = 2;
|
|
}
|
|
if(age < 256*vid.flashtime) {
|
|
int x = vid.xres / 2;
|
|
int y = vid.yres - vid.fsize * (size(msgs) - j) - (ISIOS ? 4 : 0);
|
|
displayfr(x, y, 1, vid.fsize, msgs[j].msg, 0x10101 * (255 - age/vid.flashtime), 8);
|
|
msgs[i++] = msgs[j];
|
|
}
|
|
}
|
|
msgs.resize(i);
|
|
}
|
|
|
|
int pmodel = 0;
|
|
|
|
ld ghx, ghy, ghgx, ghgy;
|
|
hyperpoint ghpm = C0;
|
|
|
|
void xybound(int& x, int &y) {
|
|
if(x<-vid.xres) x=-vid.xres; if(x>2*vid.xres) x=2*vid.xres;
|
|
if(y<-vid.yres) y=-vid.yres; if(y>2*vid.yres) y=2*vid.yres;
|
|
}
|
|
|
|
void ghcheck(int& x, int &y, const hyperpoint &H) {
|
|
xybound(x,y);
|
|
if(hypot(x-ghx, y-ghy) < hypot(ghgx-ghx, ghgy-ghy)) {
|
|
ghpm = H; ghgx = x; ghgy = y;
|
|
}
|
|
}
|
|
|
|
hyperpoint gethyper(ld x, ld y) {
|
|
|
|
if(pmodel) {
|
|
ghx = x, ghy = y;
|
|
return ghpm;
|
|
}
|
|
|
|
ld hx = (x - vid.xcenter) / vid.radius;
|
|
ld hy = (y - vid.ycenter) / vid.radius;
|
|
|
|
if(euclid)
|
|
return hpxy(hx * (EUCSCALE + vid.alphax), hy * (EUCSCALE + vid.alphax));
|
|
|
|
ld hr = hx*hx+hy*hy;
|
|
|
|
if(hr > .9999) return Hypc;
|
|
|
|
// hz*hz-(hx/(hz+alpha))^2 - (hy/(hz+alpha))^2 =
|
|
|
|
// hz*hz-hr*(hz+alpha)^2 == 1
|
|
// hz*hz - hr*hr*hz*Hz
|
|
|
|
ld A = 1-hr;
|
|
ld B = 2*hr*vid.alphax;
|
|
ld C = 1 + hr*vid.alphax*vid.alphax;
|
|
|
|
// Az^2 - Bz = C
|
|
B /= A; C /= A;
|
|
|
|
// z^2 - Bz = C
|
|
// z^2 - Bz + (B^2/4) = C + (B^2/4)
|
|
// z = (B/2) + sqrt(C + B^2/4)
|
|
|
|
ld hz = B / 2 + sqrt(C + B*B/4);
|
|
hyperpoint H;
|
|
H[0] = hx * (hz+vid.alphax);
|
|
H[1] = hy * (hz+vid.alphax);
|
|
H[2] = hz;
|
|
|
|
return H;
|
|
}
|
|
|
|
void getcoord(const hyperpoint& H, int& x, int& y, int &shift) {
|
|
|
|
if(H[2] < 0.999) {
|
|
// printf("error: %s\n", display(H));
|
|
// exit(1);
|
|
}
|
|
ld tz = euclid ? (EUCSCALE+vid.alphax) : vid.alphax+H[2];
|
|
if(tz < 1e-3 && tz > -1e-3) tz = 1000;
|
|
|
|
if(pmodel == 0) {
|
|
x = vid.xcenter + int(vid.radius * H[0] / tz);
|
|
y = vid.ycenter + int(vid.radius * H[1] / tz);
|
|
#ifndef MOBILE
|
|
shift = vid.goteyes ? int(vid.eye * vid.radius * (1 - vid.beta / tz)) : 0;
|
|
#endif
|
|
xybound(x,y);
|
|
return;
|
|
}
|
|
|
|
if(pmodel == 3 || pmodel == 4) {
|
|
pair<long double, long double> p = polygonal::compute(H[0]/tz, H[1]/tz);
|
|
x = vid.xcenter + int(vid.radius * p.first);
|
|
y = vid.ycenter + int(vid.radius * p.second);
|
|
shift = 0; ghcheck(x,y,H);
|
|
return;
|
|
}
|
|
|
|
// Poincare to half-plane
|
|
tz = H[2]+vid.alphax;
|
|
|
|
ld x0, y0;
|
|
x0 = H[0] / tz;
|
|
y0 = H[1] / tz;
|
|
y0 += 1;
|
|
double rad = x0*x0 + y0*y0;
|
|
y0 /= rad;
|
|
x0 /= rad;
|
|
y0 -= .5;
|
|
|
|
if(pmodel == 1) {
|
|
x = vid.xcenter + int(x0 * vid.radius);
|
|
y = vid.ycenter*2 - int(y0 * vid.radius);
|
|
shift = 0; ghcheck(x,y,H);
|
|
return;
|
|
}
|
|
|
|
// center
|
|
x0 *= 2; y0 *= 2;
|
|
|
|
// half-plane to band
|
|
double tau = (log((x0+1)*(x0+1) + y0*y0) - log((x0-1)*(x0-1) + y0*y0)) / 2;
|
|
double u=(1-x0*x0-y0*y0);
|
|
u = (1 - x0*x0 - y0*y0 + sqrt(u*u+4*y0*y0));
|
|
double sigma = 2 * atan(2*y0 / u) - M_PI/2;
|
|
|
|
x0 = tau; y0 = sigma;
|
|
|
|
x = vid.xcenter + int(x0 * vid.radius/M_PI*2);
|
|
y = vid.ycenter - int(y0 * vid.radius/M_PI*2);
|
|
shift = 0; ghcheck(x,y,H);
|
|
}
|
|
|
|
int dlit;
|
|
|
|
void drawline(const hyperpoint& H1, int x1, int y1, int s1, const hyperpoint& H2, int x2, int y2, int col) {
|
|
dlit++; if(dlit>500) return;
|
|
|
|
int dst = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
|
|
|
|
#ifdef GL
|
|
if(vid.usingGL && dst <= (ISMOBILE ? 100 : 20)) {
|
|
if(pmodel) {
|
|
glcoords[qglcoords][0] = x1 - vid.xcenter;
|
|
glcoords[qglcoords][1] = y1 - vid.ycenter;
|
|
glcoords[qglcoords][2] = vid.scrdist;
|
|
}
|
|
else if(euclid) {
|
|
for(int i=0; i<2; i++) glcoords[qglcoords][i] = H1[i]; glcoords[qglcoords][2] = EUCSCALE;
|
|
}
|
|
else {
|
|
for(int i=0; i<3; i++) glcoords[qglcoords][i] = H1[i];
|
|
}
|
|
qglcoords++;
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
#ifdef MOBILE
|
|
if(dst <= 400 && !vid.usingGL) {
|
|
if(polyi >= POLYMAX) return;
|
|
polyx[polyi] = x1;
|
|
polyy[polyi] = y1;
|
|
polyi++;
|
|
return;
|
|
}
|
|
#else
|
|
#ifdef GFX
|
|
if(dst <= 20 && col == -1) {
|
|
if(polyi >= POLYMAX) return;
|
|
polyx[polyi] = x1-s1;
|
|
polyxr[polyi] = x1+s1;
|
|
polyy[polyi] = y1;
|
|
polyi++;
|
|
return;
|
|
}
|
|
if(dst <= 20 && !vid.usingGL) {
|
|
(vid.usingAA?aalineColor:lineColor) (s, x1, y1, x2, y2, col);
|
|
return;
|
|
}
|
|
#endif
|
|
if(dst <= 2) {
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
hyperpoint H3 = mid(H1, H2);
|
|
int x3, y3, s3; getcoord(H3, x3, y3, s3);
|
|
#ifndef GFX
|
|
if(!vid.usingGL) {
|
|
qpixel(s, x3-s3, y3) |= col & 0xFF0000;
|
|
qpixel(s, x3+s3, y3) |= col & 0x00FFFF;
|
|
}
|
|
#endif
|
|
|
|
drawline(H1, x1, y1, s1, H3, x3, y3, col);
|
|
drawline(H3, x3, y3, s3, H2, x2, y2, col);
|
|
}
|
|
|
|
void fixcolor(int& col) {
|
|
if(col != -1) {
|
|
col = (col << 8) + lalpha;
|
|
if(col == -1) col = -2;
|
|
polyi = 0;
|
|
#ifndef GFX
|
|
if(!vid.usingGL) {
|
|
SDL_LockSurface(s);
|
|
col >>= 8;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void drawline(const hyperpoint& H1, const hyperpoint& H2, int col) {
|
|
if(vid.usingGL && !pmodel) {
|
|
qglcoords = 0;
|
|
}
|
|
|
|
dlit = 0;
|
|
int x1, y1, s1; getcoord(H1, x1, y1, s1);
|
|
int x2, y2, s2; getcoord(H2, x2, y2, s2);
|
|
drawline(H1, x1, y1, s1, H2, x2, y2, col);
|
|
|
|
if(vid.usingGL) {
|
|
|
|
// EUCLIDEAN
|
|
if(pmodel) {
|
|
glcoords[qglcoords][0] = x2 - vid.xcenter;
|
|
glcoords[qglcoords][1] = y2 - vid.ycenter;
|
|
glcoords[qglcoords][2] = vid.scrdist;
|
|
}
|
|
else if(euclid) {
|
|
for(int i=0; i<2; i++) glcoords[qglcoords][i] = H2[i]; glcoords[qglcoords][2] = EUCSCALE;
|
|
}
|
|
else {
|
|
for(int i=0; i<3; i++) glcoords[qglcoords][i] = H2[i];
|
|
}
|
|
qglcoords++;
|
|
|
|
if(pmodel) return;
|
|
|
|
glVertexPointer(3, GL_FLOAT, 0, glcoords);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glcolor(col >> 8);
|
|
|
|
if(vid.goteyes) {
|
|
selectEyeGL(-1);
|
|
selectEyeMask(-1);
|
|
glDrawArrays(GL_LINE_STRIP, 0, qglcoords);
|
|
selectEyeGL(+1);
|
|
selectEyeMask(+1);
|
|
glDrawArrays(GL_LINE_STRIP, 0, qglcoords);
|
|
selectEyeGL(0);
|
|
selectEyeMask(0);
|
|
}
|
|
else glDrawArrays(GL_LINE_STRIP, 0, qglcoords);
|
|
}
|
|
|
|
#ifdef MOBILE
|
|
else if(col != -1) {
|
|
gdpush(3); gdpush(col);
|
|
gdpush(polyi+1);
|
|
for(int i=0; i<polyi; i++) gdpush(polyx[i]), gdpush(polyy[i]);
|
|
gdpush(x2), gdpush(y2);
|
|
}
|
|
#endif
|
|
#ifndef GFX
|
|
if(col != -1) {
|
|
SDL_UnlockSurface(s);
|
|
}
|
|
#endif
|
|
// printf("ok\n");
|
|
}
|
|
|
|
// game-related graphics
|
|
|
|
transmatrix View; // current rotation, relative to viewctr
|
|
transmatrix cwtV; // player-relative view
|
|
heptspin viewctr; // heptagon and rotation where the view is centered at
|
|
bool playerfound; // has player been found in the last drawing?
|
|
|
|
ld spina(cell *c, int dir) {
|
|
return 2 * M_PI * dir / c->type;
|
|
}
|
|
|
|
int gradient(int c0, int c1, ld v0, ld v, ld v1) {
|
|
int vv = int(256 * ((v-v0) / (v1-v0)));
|
|
int c = 0;
|
|
for(int a=0; a<3; a++) {
|
|
int p0 = (c0 >> (8*a)) & 255;
|
|
int p1 = (c1 >> (8*a)) & 255;
|
|
int p = (p0*(256-vv) + p1*vv + 127) >> 8;
|
|
c += p << (8*a);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// cloak color
|
|
int cloakcolor(int rtr) {
|
|
rtr -= 28;
|
|
rtr /= 2;
|
|
rtr %= 10;
|
|
if(rtr < 0) rtr += 10;
|
|
// rtr = time(NULL) % 10;
|
|
int cc[10] = {
|
|
0x8080FF, 0x80FFFF, 0x80FF80, 0xFF8080, 0xFF80FF, 0xFFFF80,
|
|
0xFFFFC0, 0xFFD500, 0x421C52, 0
|
|
};
|
|
return cc[rtr];
|
|
}
|
|
|
|
int firecolor(int phase) {
|
|
return gradient(0xFFFF00, 0xFF0000, -1, sin((phase + ticks)/100.0), 1);
|
|
}
|
|
|
|
int watercolor(int phase) {
|
|
return 0x0080C0FF + 256 * int(63 * sin((ticks + phase) / 50.));
|
|
}
|
|
|
|
int aircolor(int phase) {
|
|
return 0x8080FF00 | int(32 + 32 * sin(ticks/200.0 + 2 * phase * M_PI / 21.));
|
|
}
|
|
|
|
int weakfirecolor(int phase) {
|
|
return gradient(0xFF8000, 0xFF0000, -1, sin((phase + ticks)/500.0), 1);
|
|
}
|
|
|
|
int fc(int ph, int col, int z) {
|
|
if(items[itOrbFire]) col = darkena(firecolor(ph), 0, 0xFF);
|
|
if(items[itOrbGhost]) col = (col &~0XFF) | (col&0xFF) / 2;
|
|
if(items[itOrbFish] && isWatery(cwt.c) && z != 3) return watercolor(ph);
|
|
if(invismove)
|
|
col =
|
|
shmup::on ?
|
|
(col &~0XFF) | (int((col&0xFF) * .25))
|
|
: (col &~0XFF) | (int((col&0xFF) * (100+100*sin(ticks / 500.)))/200);
|
|
return col;
|
|
}
|
|
|
|
int flashat, bigflashat, lightat, safetyat;
|
|
cell *flashcell;
|
|
|
|
void drawFlash(cell *c) { flashat = ticks; flashcell = c; }
|
|
void drawBigFlash(cell *c) { bigflashat = ticks; flashcell = c; }
|
|
void drawLightning() { lightat = ticks; }
|
|
void drawSafety() { safetyat = ticks; }
|
|
|
|
double eurad = 0.52;
|
|
|
|
bool outofmap(hyperpoint h) {
|
|
if(euclid)
|
|
return h[0] * h[0] + h[1] * h[1] > 15 * eurad;
|
|
else
|
|
return h[2] < .5;
|
|
}
|
|
|
|
void drawShield(const transmatrix& V, eItem it) {
|
|
float ds = ticks / 300.;
|
|
int col = darkened(iinf[it].color);
|
|
if(it == itOrbShield && items[itOrbPreserve] && !orbused[it])
|
|
col = (col & 0xFEFEFE) / 2;
|
|
double d = it == itOrbShield ? hexf : hexf - .1;
|
|
for(int a=0; a<84*5; a++)
|
|
queueline(V*ddi(a, d + sin(ds + M_PI*2*a/20)*.1)*C0, V*ddi((a+1), d + sin(ds + M_PI*2*(a+1)/20)*.1)*C0, col);
|
|
}
|
|
|
|
void drawShell(const transmatrix& V) {
|
|
float ds = ticks / 300.;
|
|
int col = darkened(iinf[itOrbShell].color);
|
|
for(int a=0; a<84*5; a++)
|
|
queueline(V*ddi(a, hexf + sin(ds + M_PI*2*a/20)*.1)*C0, V*ddi((a+1), hexf + sin(ds + M_PI*2*(a+1)/20)*.1)*C0, col);
|
|
}
|
|
|
|
void drawSpeed(const transmatrix& V) {
|
|
ld ds = ticks / 10.;
|
|
int col = darkened(iinf[itOrbSpeed].color);
|
|
for(int b=0; b<84; b+=14)
|
|
for(int a=0; a<84; a++)
|
|
queueline(V*ddi(ds+b+a, hexf*a/84)*C0, V*ddi(ds+b+(a+1), hexf*(a+1)/84)*C0, col);
|
|
}
|
|
|
|
void drawSafety(const transmatrix& V, int ct) {
|
|
ld ds = ticks / 50.;
|
|
int col = darkened(iinf[itOrbSafety].color);
|
|
for(int a=0; a<ct; a++)
|
|
queueline(V*ddi(ds+a*84/ct, 2*hexf)*C0, V*ddi(ds+(a+(ct-1)/2)*84/ct, 2*hexf)*C0, col);
|
|
}
|
|
|
|
void drawFlash(const transmatrix& V) {
|
|
float ds = ticks / 300.;
|
|
int col = darkened(iinf[itOrbFlash].color);
|
|
col &= ~1;
|
|
for(int u=0; u<5; u++) {
|
|
ld rad = hexf * (2.5 + .5 * sin(ds+u*.3));
|
|
for(int a=0; a<84; a++)
|
|
queueline(V*ddi(a, rad)*C0, V*ddi(a+1, rad)*C0, col);
|
|
}
|
|
}
|
|
|
|
void drawLove(const transmatrix& V, int hdir) {
|
|
float ds = ticks / 300.;
|
|
int col = darkened(iinf[itOrbLove].color);
|
|
col &= ~1;
|
|
for(int u=0; u<5; u++) {
|
|
for(int a=0; a<84; a++) {
|
|
double d = (1 + cos(a * M_PI/42)) / 2;
|
|
int z = a; if(z>42) z = 84-z;
|
|
if(z <= 10) d += (10-z) * (10-z) * (10-z) / 3000.;
|
|
|
|
ld rad = hexf * (2.5 + .5 * sin(ds+u*.3)) * d;
|
|
queueline(V*ddi(hdir+a-1, rad)*C0, V*ddi(hdir+a+1, rad)*C0, col);
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawWinter(const transmatrix& V, int hdir) {
|
|
float ds = ticks / 300.;
|
|
int col = darkened(iinf[itOrbWinter].color);
|
|
for(int u=0; u<20; u++) {
|
|
ld rad = 6 * sin(ds+u * 2 * M_PI / 20);
|
|
queueline(V*ddi(hdir+rad, hexf*.5)*C0, V*ddi(hdir+rad, hexf*3)*C0, col);
|
|
}
|
|
}
|
|
|
|
void drawLightning(const transmatrix& V) {
|
|
int col = iinf[itOrbLightning].color;
|
|
for(int u=0; u<20; u++) {
|
|
ld leng = 0.5 / (0.1 + (rand() % 100) / 100.0);
|
|
ld rad = rand() % 84;
|
|
queueline(V*ddi(rad, hexf*0.3)*C0, V*ddi(rad, hexf*leng)*C0, col);
|
|
}
|
|
}
|
|
|
|
int displaydir(cell *c, int d) {
|
|
if(euclid)
|
|
return - d * 84 / c->type;
|
|
else
|
|
return 42 - d * 84 / c->type;
|
|
}
|
|
|
|
#include "shmup.cpp"
|
|
#include "rug.cpp"
|
|
#include "conformal.cpp"
|
|
|
|
void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
|
|
if(!onplayer && !items[itOrbEmpathy]) return;
|
|
if(items[itOrbShield] > (shmup::on ? 0 : 1)) drawShield(V, itOrbShield);
|
|
if(items[itOrbShell] > (shmup::on ? 0 : 1)) drawShield(V, itOrbShell);
|
|
|
|
if(items[itOrbSpeed]) drawSpeed(V);
|
|
|
|
int ct = c->type;
|
|
|
|
if(onplayer && items[itOrbSafety]) drawSafety(V, ct);
|
|
|
|
if(onplayer && items[itOrbFlash]) drawFlash(V);
|
|
if(onplayer && items[itOrbLove]) drawLove(V, displaydir(c, cwt.spin));
|
|
|
|
if(items[itOrbWinter])
|
|
drawWinter(V, displaydir(c, cwt.spin));
|
|
|
|
if(onplayer && items[itOrbLightning] > 1) 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;
|
|
ld rad = hexf * u / 250;
|
|
int col = iinf[itOrbSafety].color;
|
|
for(int a=0; a<84; a++)
|
|
queueline(V*ddi(a, rad)*C0, V*ddi(a+1, rad)*C0, col);
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawStunStars(const transmatrix& V, int t) {
|
|
for(int i=0; i<3*t; i++) {
|
|
transmatrix V2 = V * spin(M_PI * 2 * i / (3*t) + M_PI * ticks/600.);
|
|
queuepoly(V2, shFlailBall, 0xFFFFFFFF);
|
|
}
|
|
}
|
|
|
|
bool drawUserShape(transmatrix V, int group, int id, int color) {
|
|
#ifdef MOBILE
|
|
return false;
|
|
#else
|
|
usershape *us = usershapes[group][id];
|
|
if(!us) return false;
|
|
|
|
for(int i=0; i<USERLAYERS; i++) {
|
|
usershapelayer& ds(us->d[i]);
|
|
hpcshape& sh(ds.sh);
|
|
if(sh.s != sh.e)
|
|
queuepoly(V, sh, ds.color ? darkena(ds.color, 0, 0xFF) : color);
|
|
}
|
|
|
|
if(cmode == emDraw && mapeditor::editingShape(group, id)) {
|
|
|
|
usershapelayer &ds(usershapes[group][id]->d[mapeditor::dslayer]);
|
|
|
|
/* for(int a=0; a<size(ds.list); a++) {
|
|
hyperpoint P2 = V * ds.list[a];
|
|
|
|
int xc, yc, sc;
|
|
getcoord(P2, xc, yc, sc);
|
|
queuechr(xc, yc, sc, 10, 'x',
|
|
a == 0 ? 0x00FF00 :
|
|
a == size(ds.list)-1 ? 0xFF0000 :
|
|
0xFFFF00);
|
|
} */
|
|
|
|
hyperpoint mh = inverse(mapeditor::drawtrans) * mouseh;
|
|
|
|
for(int a=0; a<ds.rots; a++)
|
|
for(int b=0; b<(ds.sym?2:1); b++) {
|
|
|
|
if(outofmap(mouseh)) break;
|
|
|
|
hyperpoint P2 = V * spin(2*M_PI*a/ds.rots) * (b?Mirror*mh:mh);
|
|
|
|
int xc, yc, sc;
|
|
getcoord(P2, xc, yc, sc);
|
|
queuechr(xc, yc, sc, 10, 'x', 0xFF00FF);
|
|
|
|
/* if(crad > 0 && c->cpdist <= 3) {
|
|
lalpha = 0x80;
|
|
transmatrix movtocc = V2 * inverse(cwtV) * rgpushxto0(ccenter);
|
|
for(int d=0; d<84; d++)
|
|
queueline(movtocc * ddi(d+1, crad) * C0, movtocc * ddi(d, crad) * C0, 0xC00000);
|
|
lalpha = 0xFF;
|
|
} */
|
|
}
|
|
}
|
|
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
string csnameid(int id) {
|
|
if(id == 0) return XLAT("male");
|
|
if(id == 1) return XLAT("female");
|
|
if(id == 2) return XLAT("Prince");
|
|
if(id == 3) return XLAT("Princess");
|
|
if(id == 4 || id == 5) return XLAT("cat");
|
|
if(id == 6 || id == 7) return XLAT("dog");
|
|
return XLAT("none");
|
|
}
|
|
|
|
string csname(charstyle& cs) {
|
|
return csnameid(cs.charid);
|
|
}
|
|
|
|
namespace tortoise {
|
|
|
|
// small is 0 or 2
|
|
void draw(const transmatrix& V, int bits, int small, int stuntime) {
|
|
|
|
int eyecolor = getBit(bits, tfEyeHue) ? 0xFF0000 : 0xC0C0C0;
|
|
int shellcolor = getBit(bits, tfShellHue) ? 0x00C040 : 0xA06000;
|
|
int scutecolor = getBit(bits, tfScuteHue) ? 0x00C040 : 0xA06000;
|
|
int skincolor = getBit(bits, tfSkinHue) ? 0x00C040 : 0xA06000;
|
|
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);
|
|
|
|
for(int i=0; i<12; i++) {
|
|
int col =
|
|
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;
|
|
|
|
queuepoly(V, shTortoise[i][b+small], d);
|
|
if((i >= 5 && i <= 7) || (i >= 9 && i <= 10))
|
|
queuepoly(V * Mirror, shTortoise[i][b+small], d);
|
|
|
|
if(i == 8) {
|
|
for(int k=0; k<stuntime; k++) {
|
|
eyecolor &= 0xFEFEFE;
|
|
eyecolor >>= 1;
|
|
}
|
|
queuepoly(V, shTortoise[12][b+small], darkena(eyecolor, 0, 0xFF));
|
|
queuepoly(V * Mirror, shTortoise[12][b+small], darkena(eyecolor, 0, 0xFF));
|
|
}
|
|
}
|
|
}
|
|
|
|
int getMatchColor(int bits) {
|
|
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));
|
|
/* poly_outline = 0;
|
|
queuepoly(V, shHeptaMarker, darkena(mcol, 0, dd));
|
|
poly_outline = OUTLINE_NONE; */
|
|
return gradient(0x487830, mcol, 0, dd, 0xFF);
|
|
}
|
|
};
|
|
|
|
bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col) {
|
|
|
|
char xch = minf[m].glyph;
|
|
|
|
#ifndef MOBILE
|
|
if(where == mapeditor::drawcell)
|
|
mapeditor::drawtrans = V;
|
|
#endif
|
|
|
|
if(m == moTortoise && where->stuntime >= 3)
|
|
drawStunStars(V, where->stuntime-2);
|
|
else if (m == moTortoise || m == moPlayer || !where->stuntime) ;
|
|
else if(!(isMetalBeast(m) && where->stuntime == 1))
|
|
drawStunStars(V, where->stuntime);
|
|
|
|
if(m == moTortoise) {
|
|
int bits = tortoise::getb(where);
|
|
tortoise::draw(V, bits, 0, where->stuntime);
|
|
if(tortoise::seek() && !tortoise::diff(bits))
|
|
queuepoly(V, shRing, darkena(0xFFFFFF, 0, 0x80 + 0x70 * sin(ticks / 200.0)));
|
|
}
|
|
|
|
else if(m == moPlayer) {
|
|
|
|
charstyle& cs = getcs();
|
|
|
|
bool havus = drawUserShape(V, 0, cs.charid, cs.skincolor);
|
|
|
|
if(mapeditor::drawplayer && !havus) {
|
|
|
|
if(cs.charid >= 6) {
|
|
queuepoly(V, shWolf, fc(0, cs.skincolor, 0));
|
|
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
|
|
queuepoly(V, shWolf1, fc(314, cs.swordcolor, 3));
|
|
queuepoly(V, shWolf2, fc(314, cs.swordcolor, 3));
|
|
queuepoly(V, shWolf3, fc(314, cs.swordcolor, 3));
|
|
}
|
|
}
|
|
else if(cs.charid >= 4) {
|
|
queuepoly(V, shCatBody, fc(0, cs.skincolor, 0));
|
|
queuepoly(V, shCatHead, fc(150, cs.haircolor, 2));
|
|
queuepoly(V, shCatLegs, fc(500, cs.dresscolor, 4));
|
|
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
|
|
queuepoly(V * xpush(.04), shWolf1, fc(314, cs.swordcolor, 3));
|
|
queuepoly(V * xpush(.04), shWolf2, fc(314, cs.swordcolor, 3));
|
|
}
|
|
}
|
|
else {
|
|
|
|
queuepoly(V, (cs.charid&1) ? shFemaleBody : shPBody, fc(0, cs.skincolor, 0));
|
|
|
|
if(items[itOrbThorns])
|
|
queuepoly(V, shHedgehogBladePlayer, items[itOrbDiscord] ? watercolor(0) : 0x00FF00FF);
|
|
else if(!shmup::on && items[itOrbDiscord])
|
|
queuepoly(V, shPSword, watercolor(0));
|
|
else if(items[itRevolver])
|
|
queuepoly(V, shGunInHand, fc(314, cs.swordcolor, 3)); // 3 not colored
|
|
else if(!shmup::on)
|
|
queuepoly(V, cs.charid >= 2 ? shSabre : shPSword, fc(314, cs.swordcolor, 3)); // 3 not colored
|
|
else if(shmup::curtime >= shmup::getPlayer()->nextshot)
|
|
queuepoly(V, shPKnife, fc(314, cs.swordcolor, 3)); // 3 not colored
|
|
|
|
if(where->land == laWildWest) {
|
|
queuepoly(V, shWestHat1, darkena(cs.swordcolor, 1, 0XFF));
|
|
queuepoly(V, shWestHat2, darkena(cs.swordcolor, 0, 0XFF));
|
|
}
|
|
|
|
if(cheater) {
|
|
queuepoly(V, (cs.charid&1) ? shGoatHead : shDemon, darkena(0xFFFF00, 0, 0xFF));
|
|
// queuepoly(V, shHood, darkena(0xFF00, 1, 0xFF));
|
|
}
|
|
else {
|
|
queuepoly(V, shPFace, fc(500, cs.skincolor, 1));
|
|
queuepoly(V, (cs.charid&1) ? shFemaleHair : shPHead, fc(150, cs.haircolor, 2));
|
|
}
|
|
if(cs.charid&1)
|
|
queuepoly(V, shFemaleDress, fc(500, cs.dresscolor, 4));
|
|
|
|
if(cs.charid == 2)
|
|
queuepoly(V, shPrinceDress, fc(400, cs.dresscolor, 5));
|
|
if(cs.charid == 3)
|
|
queuepoly(V, shPrincessDress, fc(400, cs.dresscolor2, 5));
|
|
|
|
}
|
|
|
|
if(knighted)
|
|
queuepoly(V, shKnightCloak, darkena(cloakcolor(knighted), 1, 0xFF));
|
|
|
|
if(items[itOrbFish])
|
|
queuepoly(V, shFishTail, watercolor(100));
|
|
|
|
if(tortoise::seek())
|
|
tortoise::draw(V * ypush(-crossf*.25), tortoise::seekbits, 4, 0);
|
|
|
|
}
|
|
}
|
|
|
|
else if(drawUserShape(V, 1, m, darkena(col, 0, 0xFF))) return false;
|
|
|
|
else if(isMimic(m) || m == moShadow || m == moIllusion) {
|
|
charstyle& cs = getcs();
|
|
if(drawUserShape(V, 0, (cs.charid&1)?1:0, darkena(col, 0, 0x80))) return false;
|
|
|
|
if(cs.charid >= 6) {
|
|
queuepoly(V, shWolf, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shWolf1, darkena(col, 1, 0xC0));
|
|
queuepoly(V, shWolf2, darkena(col, 1, 0xC0));
|
|
queuepoly(V, shWolf3, darkena(col, 1, 0xC0));
|
|
}
|
|
else if(cs.charid >= 4) {
|
|
queuepoly(V, shCatBody, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shCatHead, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shCatLegs, darkena(col, 0, 0xC0));
|
|
queuepoly(V * xpush(.04), shWolf1, darkena(col, 1, 0xC0));
|
|
queuepoly(V * xpush(.04), shWolf2, darkena(col, 1, 0xC0));
|
|
}
|
|
else {
|
|
queuepoly(V, (cs.charid&1) ? shFemaleBody : shPBody, darkena(col, 0, 0X80));
|
|
|
|
if(!shmup::on)
|
|
queuepoly(V, (cs.charid >= 2 ? shSabre : shPSword), darkena(col, 0, 0XC0));
|
|
else if(shmup::curtime >= shmup::getPlayer()->nextshot)
|
|
queuepoly(V, shPKnife, darkena(col, 0, 0XC0));
|
|
|
|
queuepoly(V, (cs.charid&1) ? shFemaleHair : shPHead, darkena(col, 1, 0XC0));
|
|
queuepoly(V, shPFace, darkena(col, 0, 0XC0));
|
|
if(cs.charid&1)
|
|
queuepoly(V, shFemaleDress, darkena(col, 1, 0XC0));
|
|
if(cs.charid == 2)
|
|
queuepoly(V, shPrinceDress, darkena(col, 1, 0XC0));
|
|
if(cs.charid == 3)
|
|
queuepoly(V, shPrincessDress, darkena(col, 1, 0XC0));
|
|
}
|
|
}
|
|
|
|
/* else if(m == moShadow) {
|
|
charstyle& cs = getcs();
|
|
queuepoly(V, (cs.charid&1) ? shFemaleBody : shPBody, darkena(col, 0, 0X80));
|
|
queuepoly(V, (cscharid >= 2 ? shSabre : shPSword), darkena(col, 0, 0XC0));
|
|
queuepoly(V, (cs.charid&1) ? shFemaleHair : shPHead, darkena(col, 1, 0XC0));
|
|
queuepoly(V, shPFace, darkena(col, 0, 0XC0));
|
|
|
|
if(cs.charid&1)
|
|
queuepoly(V, shFemaleDress, darkena(col, 1, 0xC0));
|
|
if(cs.charid == 2)
|
|
queuepoly(V, shPrinceDress, darkena(col, 1, 0XC0));
|
|
if(cs.charid == 3)
|
|
queuepoly(V, shPrincessDress, darkena(col, 1, 0XC0));
|
|
}
|
|
|
|
else if(m == moIllusion) {
|
|
charstyle& cs = getcs();
|
|
if(drawUserShape(V, 0, (cs.charid&1)?1:0, darkena(col, 0, 0x80))) return false;
|
|
queuepoly(V, (cs.charid&1) ? shFemaleBody : shPBody, darkena(col, 0, 0X80));
|
|
queuepoly(V, (cscharid >= 2 ? shSabre : shPSword), darkena(col, 0, 0XC0));
|
|
queuepoly(V, (cs.charid&1) ? shFemaleHair : shPHead, darkena(col, 1, 0XC0));
|
|
queuepoly(V, shPFace, darkena(col, 0, 0XC0));
|
|
if(cs.charid&1)
|
|
queuepoly(V, shFemaleDress, darkena(col, 1, 0XC0));
|
|
if(cs.charid == 2)
|
|
queuepoly(V, shPrinceDress, darkena(col, 1, 0XC0));
|
|
if(cs.charid == 3)
|
|
queuepoly(V, shPrincessDress, darkena(col, 1, 0XC0));
|
|
} */
|
|
|
|
else if(m == moBullet) {
|
|
queuepoly(V * spin(-M_PI/4), shKnife, getcs().swordcolor);
|
|
}
|
|
|
|
else if(m == moKnight || m == moKnightMoved) {
|
|
queuepoly(V, shPBody, darkena(0xC0C0A0, 0, 0xC0));
|
|
queuepoly(V, shPSword, darkena(0xFFFF00, 0, 0xFF));
|
|
queuepoly(V, shKnightArmor, darkena(0xD0D0D0, 1, 0xFF));
|
|
int col;
|
|
if(!euclid && where->master->alt)
|
|
col = cloakcolor(roundTableRadius(where));
|
|
else
|
|
col = cloakcolor(newRoundTableRadius());
|
|
queuepoly(V, shKnightCloak, darkena(col, 1, 0xFF));
|
|
queuepoly(V, shPHead, darkena(0x703800, 1, 0XFF));
|
|
queuepoly(V, shPFace, darkena(0xC0C0A0, 0, 0XFF));
|
|
return false;
|
|
}
|
|
|
|
else if(m == moGolem) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0XC0));
|
|
queuepoly(V, shGolemhead, darkena(col, 1, 0XFF));
|
|
}
|
|
|
|
else if(isPrincess(m) || m == moFalsePrincess || m == moRoseLady || m == moRoseBeauty) {
|
|
|
|
bool girl = princessgender() == GEN_F;
|
|
bool evil = !isPrincess(m);
|
|
|
|
int facecolor = evil ? 0xC0B090FF : 0xD0C080FF;
|
|
|
|
queuepoly(V, girl ? shFemaleBody : shPBody, facecolor);
|
|
|
|
if(m == moPrincessArmed)
|
|
queuepoly(V, vid.cs.charid < 2 ? shSabre : shPSword, 0xFFFFFFFF);
|
|
|
|
if((m == moFalsePrincess || m == moRoseBeauty) && where->cpdist == 1)
|
|
queuepoly(V, shPKnife, 0xFFFFFFFF);
|
|
|
|
if(m == moRoseLady) {
|
|
queuepoly(V, shPKnife, 0xFFFFFFFF);
|
|
queuepoly(V * Mirror, shPKnife, 0xFFFFFFFF);
|
|
}
|
|
|
|
if(m == moRoseLady) {
|
|
// queuepoly(V, girl ? shGoatHead : shDemon, 0x800000FF);
|
|
queuepoly(V, girl ? shFemaleHair : shPHead, evil ? 0x500050FF : 0x332A22FF);
|
|
}
|
|
else if(m == moRoseBeauty) {
|
|
if(girl) {
|
|
queuepoly(V, shBeautyHair, 0xF0A0D0FF);
|
|
queuepoly(V, shFlowerHair, 0xC00000FF);
|
|
}
|
|
else {
|
|
queuepoly(V, shPHead, 0xF0A0D0FF);
|
|
queuepoly(V, shFlowerHand, 0xC00000FF);
|
|
queuepoly(V, shSuspenders, 0xC00000FF);
|
|
}
|
|
}
|
|
else {
|
|
queuepoly(V, girl ? shFemaleHair : shPHead,
|
|
evil ? 0xC00000FF : 0x332A22FF);
|
|
}
|
|
queuepoly(V, shPFace, facecolor);
|
|
|
|
if(girl) {
|
|
queuepoly(V, shFemaleDress, evil ? 0xC000C0FF : 0x00C000FF);
|
|
if(vid.cs.charid < 2)
|
|
queuepoly(V, shPrincessDress, evil ? 0xC040C0C0 : 0x8080FFC0);
|
|
}
|
|
else {
|
|
if(vid.cs.charid < 2)
|
|
queuepoly(V, shPrinceDress, evil ? 0x802080FF : 0x404040FF);
|
|
}
|
|
}
|
|
|
|
else if(m == moWolf || m == moRedFox) {
|
|
queuepoly(V, shWolfLegs, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shWolfBody, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shWolfHead, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shWolfEyes, darkena(col, 3, 0xFF));
|
|
}
|
|
else if(m == moVineBeast) {
|
|
queuepoly(V, shWolfLegs, 0x00FF00FF);
|
|
queuepoly(V, shWolfBody, darkena(col, 1, 0xFF));
|
|
queuepoly(V, shWolfHead, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shWolfEyes, 0xFF0000FF);
|
|
}
|
|
else if(m == moMouse || m == moMouseMoved) {
|
|
queuepoly(V, shMouse, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shMouseLegs, darkena(col, 1, 0xFF));
|
|
queuepoly(V, shMouseEyes, 0xFF);
|
|
}
|
|
else if(isBug(m)) {
|
|
queuepoly(V, shBugBody, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shBugArmor, darkena(col, 1, 0xFF));
|
|
}
|
|
else if(m == moRunDog) {
|
|
queuepoly(V, shWolf, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shWolf1, darkena(0x202020, 0, 0xFF));
|
|
queuepoly(V, shWolf2, darkena(0x202020, 0, 0xFF));
|
|
queuepoly(V, shWolf3, darkena(0x202020, 0, 0xFF));
|
|
}
|
|
else if(m == moOrangeDog) {
|
|
queuepoly(V, shWolf, darkena(0xFFFFFF, 0, 0xFF));
|
|
queuepoly(V, shWolf1, darkena(0x202020, 0, 0xFF));
|
|
queuepoly(V, shWolf2, darkena(0x202020, 0, 0xFF));
|
|
queuepoly(V, shWolf3, darkena(0x202020, 0, 0xFF));
|
|
queuepoly(V, shDogStripes, darkena(0x303030, 0, 0xFF));
|
|
}
|
|
else if(m == moShark || m == moGreaterShark || m == moCShark)
|
|
queuepoly(V, shShark, darkena(col, 0, 0xFF));
|
|
else if(m == moEagle || m == moParrot || m == moBomberbird || m == moAlbatross ||
|
|
m == moTameBomberbird || m == moWindCrow)
|
|
queuepoly(V, shEagle, darkena(col, 0, 0xFF));
|
|
else if(m == moNighthawk || m == moKestrel)
|
|
queuepoly(V, shHawk, darkena(col, 0, 0xFF));
|
|
else if(m == moGargoyle) {
|
|
queuepoly(V, shGargoyleWings, darkena(col, 0, 0xD0));
|
|
queuepoly(V, shGargoyleBody, darkena(col, 0, 0xFF));
|
|
}
|
|
else if(m == moZombie)
|
|
queuepoly(V, shPBody, darkena(col, 0, 0xFF));
|
|
else if(m == moDesertman) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPSword, 0xFFFF00FF);
|
|
queuepoly(V, shHood, 0xD0D000C0);
|
|
}
|
|
else if(m == moPalace || m == moFatGuard || m == moVizier || m == moSkeleton) {
|
|
queuepoly(V, shSabre, 0xFFFFFFFF);
|
|
if(m == moSkeleton) {
|
|
queuepoly(V, shSkeletonBody, darkena(0xFFFFFF, 0, 0xFF));
|
|
queuepoly(V, shSkull, darkena(0xFFFFFF, 0, 0xFF));
|
|
queuepoly(V, shSkullEyes, darkena(0, 0, 0xFF));
|
|
}
|
|
else {
|
|
if(m == moFatGuard) {
|
|
queuepoly(V, shFatBody, darkena(0xC06000, 0, 0xFF));
|
|
col = 0xFFFFFF;
|
|
if(where->hitpoints >= 3)
|
|
queuepoly(V, shKnightCloak, darkena(0xFFC0C0, 1, 0xFF));
|
|
}
|
|
else {
|
|
queuepoly(V, shPBody, darkena(0xFFD500, 0, 0xFF));
|
|
queuepoly(V, shKnightArmor, m == moVizier ? 0xC000C0FF :
|
|
darkena(0x00C000, 1, 0xFF));
|
|
if(where->hitpoints >= 3)
|
|
queuepoly(V, shKnightCloak, m == moVizier ? 0x800080Ff :
|
|
darkena(0x00FF00, 1, 0xFF));
|
|
}
|
|
queuepoly(V, shTurban1, darkena(col, 1, 0xFF));
|
|
if(where->hitpoints >= 2)
|
|
queuepoly(V, shTurban2, darkena(col, 0, 0xFF));
|
|
}
|
|
|
|
drawStunStars(V, where->stuntime);
|
|
}
|
|
else if(m == moCrystalSage) {
|
|
queuepoly(V, shPBody, 0xFFFFFFFF);
|
|
queuepoly(V, shPHead, 0xFFFFFFFF);
|
|
queuepoly(V, shPFace, 0xFFFFFFFF);
|
|
}
|
|
else if(m == moHedge) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shHedgehogBlade, 0xC0C0C0FF);
|
|
queuepoly(V, shPHead, 0x804000FF);
|
|
queuepoly(V, shPFace, 0xF09000FF);
|
|
}
|
|
else if(m == moYeti || m == moMonkey) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(col, 0, 0xFF));
|
|
}
|
|
else if(m == moLemur) {
|
|
queuepoly(V, shPBody, darkena(0xFFFF00, 0, 0xC0));
|
|
queuepoly(V, shAztecHead, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shAztecCap, darkena(0xC000C0, 0, 0xFF));
|
|
}
|
|
else if(m == moEdgeMonkey) {
|
|
queuepoly(V, shYeti, darkena(0xC04040, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(col, 0, 0xFF));
|
|
}
|
|
else if(m == moRanger) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPSword, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shArmor, darkena(col, 1, 0xFF));
|
|
}
|
|
else if(m == moGhost || m == moSeep || m == moFriendlyGhost) {
|
|
queuepoly(V, shGhost, darkena(col, 0, 0x80));
|
|
queuepoly(V, shEyes, 0xFF);
|
|
}
|
|
else if(m == moVineSpirit) {
|
|
queuepoly(V, shGhost, 0xD0D0D0C0);
|
|
queuepoly(V, shEyes, 0xFF0000FF);
|
|
}
|
|
else if(m == moFireFairy) {
|
|
col = firecolor(0);
|
|
queuepoly(V, shFemaleBody, darkena(col, 0, 0XC0));
|
|
queuepoly(V, shWitchHair, darkena(col, 1, 0xFF));
|
|
queuepoly(V, shPFace, darkena(col, 0, 0XFF));
|
|
}
|
|
else if(m == moSlime) {
|
|
queuepoly(V, shSlime, darkena(col, 0, 0x80));
|
|
queuepoly(V, shEyes, 0xFF);
|
|
}
|
|
else if(m == moCultist || m == moPyroCultist || m == moCultistLeader) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPSword, darkena(col, 2, 0xFF));
|
|
queuepoly(V, shHood, darkena(col, 1, 0xFF));
|
|
}
|
|
else if(m == moPirate) {
|
|
queuepoly(V, shPBody, darkena(0x404040, 0, 0xFF));
|
|
queuepoly(V, shPirateHook, darkena(0xD0D0D0, 0, 0xFF));
|
|
queuepoly(V, shPFace, darkena(0xFFFF80, 0, 0xFF));
|
|
queuepoly(V, shEyepatch, darkena(0, 0, 0xC0));
|
|
queuepoly(V, shPirateHood, darkena(col, 0, 0xFF));
|
|
}
|
|
else if(m == moRatling || m == moRatlingAvenger) {
|
|
queuepoly(V, shYeti, darkena(col, 1, 0xFF));
|
|
queuepoly(V, shRatHead, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shRatTail, darkena(col, 0, 0xFF));
|
|
|
|
float t = sin(ticks / 1000.0 + where->cpdist);
|
|
int eyecol = t > 0.92 ? 0xFF0000 : 0;
|
|
|
|
queuepoly(V, shWolf1, darkena(eyecol, 0, 0xFF));
|
|
queuepoly(V, shWolf2, darkena(eyecol, 0, 0xFF));
|
|
queuepoly(V, shWolf3, darkena(0x202020, 0, 0xFF));
|
|
|
|
if(m == moRatlingAvenger) {
|
|
queuepoly(V, shRatCape1, 0x303030FF);
|
|
queuepoly(V, shRatCape2, 0x484848FF);
|
|
}
|
|
}
|
|
else if(m == moViking) {
|
|
queuepoly(V, shPBody, darkena(0xE00000, 0, 0xFF));
|
|
queuepoly(V, shPSword, darkena(0xD0D0D0, 0, 0xFF));
|
|
queuepoly(V, shKnightCloak, darkena(0x404040, 0, 0xFF));
|
|
queuepoly(V, shVikingHelmet, darkena(0xC0C0C0, 0, 0XFF));
|
|
queuepoly(V, shPFace, darkena(0xFFFF80, 0, 0xFF));
|
|
}
|
|
else if(m == moOutlaw) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0xFF));
|
|
queuepoly(V, shKnightCloak, darkena(col, 1, 0xFF));
|
|
queuepoly(V, shWestHat1, darkena(col, 2, 0XFF));
|
|
queuepoly(V, shWestHat2, darkena(col, 1, 0XFF));
|
|
queuepoly(V, shPFace, darkena(0xFFFF80, 0, 0xFF));
|
|
queuepoly(V, shGunInHand, darkena(col, 1, 0XFF));
|
|
}
|
|
else if(m == moNecromancer) {
|
|
queuepoly(V, shPBody, 0xC00000C0);
|
|
queuepoly(V, shHood, darkena(col, 1, 0xFF));
|
|
}
|
|
else if(m == moGoblin) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shArmor, darkena(col, 1, 0XFF));
|
|
}
|
|
else if(m == moLancer || m == moFlailer || m == moMiner) {
|
|
transmatrix V2 = V;
|
|
if(m == moLancer)
|
|
V2 = V * spin(where->type == 6 ? -M_PI/3 : -M_PI/2 );
|
|
queuepoly(V2, shPBody, darkena(col, 0, 0xC0));
|
|
queuepoly(V2, m == moFlailer ? shArmor : shHood, darkena(col, 1, 0XFF));
|
|
if(m == moMiner)
|
|
queuepoly(V2, shPickAxe, darkena(0xC0C0C0, 0, 0XFF));
|
|
if(m == moLancer)
|
|
queuepoly(V2, shPike, darkena(col, 0, 0XFF));
|
|
if(m == moFlailer) {
|
|
queuepoly(V2, shFlailBall, darkena(col, 0, 0XFF));
|
|
queuepoly(V2, shFlailChain, darkena(col, 1, 0XFF));
|
|
queuepoly(V2, shFlailTrunk, darkena(col, 0, 0XFF));
|
|
}
|
|
}
|
|
else if(m == moTroll) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(col, 1, 0XFF));
|
|
queuepoly(V, shPFace, darkena(col, 2, 0XFF));
|
|
}
|
|
else if(m == moFjordTroll || m == moForestTroll || m == moStormTroll) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(col, 1, 0XFF));
|
|
queuepoly(V, shPFace, darkena(col, 2, 0XFF));
|
|
}
|
|
else if(m == moDarkTroll) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(col, 1, 0XFF));
|
|
queuepoly(V, shPFace, 0xFFFFFF80);
|
|
}
|
|
else if(m == moRedTroll) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(0xFF8000, 0, 0XFF));
|
|
queuepoly(V, shPFace, 0xFFFFFF80);
|
|
}
|
|
else if(m == moEarthElemental) {
|
|
queuepoly(V, shYeti, darkena(col, 0, 0xC0));
|
|
queuepoly(V, shPHead, darkena(col, 0, 0XFF));
|
|
queuepoly(V, shPFace, 0xF0000080);
|
|
}
|
|
else if(m == moWaterElemental) {
|
|
queuepoly(V, shWaterElemental, watercolor(0));
|
|
queuepoly(V, shFemaleHair, watercolor(100));
|
|
queuepoly(V, shPFace, watercolor(200));
|
|
}
|
|
else if(m == moFireElemental) {
|
|
queuepoly(V, shWaterElemental, darkena(firecolor(0), 0, 0xFF));
|
|
queuepoly(V, shFemaleHair, darkena(firecolor(100), 0, 0xFF));
|
|
queuepoly(V, shPFace, darkena(firecolor(200), 0, 0xFF));
|
|
}
|
|
else if(m == moAirElemental) {
|
|
queuepoly(V, shWaterElemental, darkena(col, 0, 0x80));
|
|
queuepoly(V, shFemaleHair, darkena(col, 0, 0x80));
|
|
queuepoly(V, shPFace, darkena(col, 0, 0x80));
|
|
}
|
|
else if(xch == 'd' || xch == 'D') {
|
|
queuepoly(V, shPBody, darkena(col, 1, 0xC0));
|
|
int acol = col;
|
|
if(xch == 'D') acol = 0xD0D0D0;
|
|
queuepoly(V, shDemon, darkena(acol, 0, 0xFF));
|
|
}
|
|
else if(isMetalBeast(m)) {
|
|
queuepoly(V, shTrylobite, darkena(col, 1, 0xC0));
|
|
int acol = col;
|
|
queuepoly(V, shTrylobiteHead, darkena(acol, 0, 0xFF));
|
|
}
|
|
else if(m == moEvilGolem) {
|
|
queuepoly(V, shPBody, darkena(col, 0, 0XC0));
|
|
queuepoly(V, shGolemhead, darkena(col, 1, 0XFF));
|
|
}
|
|
else if(isWitch(m)) {
|
|
int c = 0xFF;
|
|
if(m == moWitchGhost) c = 0x85 + 120 * sin(ticks / 160.0);
|
|
if(m == moWitchWinter) drawWinter(V, 42);
|
|
if(m == moWitchFlash) drawFlash(V);
|
|
if(m == moWitchSpeed) drawSpeed(V);
|
|
if(m == moWitchFire) col = firecolor(0);
|
|
queuepoly(V, shFemaleBody, darkena(col, 0, c));
|
|
// queuepoly(cV2, ct, shPSword, darkena(col, 0, 0XFF));
|
|
// queuepoly(V, shHood, darkena(col, 0, 0XC0));
|
|
if(m == moWitchFire) col = firecolor(100);
|
|
queuepoly(V, shWitchHair, darkena(col, 1, c));
|
|
if(m == moWitchFire) col = firecolor(200);
|
|
queuepoly(V, shPFace, darkena(col, 0, c));
|
|
if(m == moWitchFire) col = firecolor(300);
|
|
queuepoly(V, shWitchDress, darkena(col, 1, 0XC0));
|
|
}
|
|
|
|
else return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
#define OUTLINE_NONE 0x000000FF
|
|
#define OUTLINE_FRIEND 0x00FF00FF
|
|
#define OUTLINE_ENEMY 0xFF0000FF
|
|
#define OUTLINE_TREASURE 0xFFFF00FF
|
|
#define OUTLINE_ORB 0xFF8000FF
|
|
#define OUTLINE_OTHER 0xFFFFFFFF
|
|
#define OUTLINE_DEAD 0x800000FF
|
|
|
|
bool drawMonsterTypeDH(eMonster m, cell *where, const transmatrix& V, int col, bool dh) {
|
|
if(dh) {
|
|
poly_outline = OUTLINE_DEAD;
|
|
darken++;
|
|
}
|
|
bool b = drawMonsterType(m,where,V,col);
|
|
if(dh) {
|
|
poly_outline = OUTLINE_NONE;
|
|
darken--;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
bool drawMonster(const transmatrix& V, int ct, cell *c, int col) {
|
|
|
|
if(shmup::on) shmup::drawMonster(V, c);
|
|
|
|
bool darkhistory = conformal::includeHistory && eq(c->aitmp, sval);
|
|
|
|
if(doHighlight())
|
|
poly_outline =
|
|
(c == cwt.c || isFriendly(c)) ? OUTLINE_FRIEND : OUTLINE_ENEMY;
|
|
|
|
eMonster m = c->monst;
|
|
|
|
if(c == cwt.c && !shmup::on && mapeditor::drawplayer) {
|
|
transmatrix cV2 = cwtV;
|
|
// if(flipplayer) cV2 = cV2 * spin(M_PI);
|
|
if(flipplayer) cV2 = cV2 * spin(M_PI);
|
|
|
|
drawPlayerEffects(V, c, true);
|
|
if(vid.monmode > 1) {
|
|
drawMonsterType(moPlayer, c, cV2, col);
|
|
}
|
|
else return true;
|
|
}
|
|
|
|
if(isIvy(c) || isWorm(c) || isMutantIvy(c)) {
|
|
|
|
transmatrix V2 = V;
|
|
if(isDragon(c->monst) && c->stuntime == 0) col = 0xFF6000;
|
|
|
|
if(c->mondir != NODIR) {
|
|
int hdir = displaydir(c, c->mondir);
|
|
|
|
if(vid.monmode > 1) {
|
|
V2 = V2 * spin(hdir * M_PI / 42);
|
|
|
|
#ifndef MOBILE
|
|
if(c == mapeditor::drawcell) mapeditor::drawtrans = V2;
|
|
#endif
|
|
|
|
if(drawUserShape(V2, 1, c->monst, (col << 8) + 0xFF)) return false;
|
|
|
|
if(isIvy(c) || isMutantIvy(c))
|
|
queuepoly(V2, shIBranch, (col << 8) + 0xFF);
|
|
else if(c->monst < moTentacle) {
|
|
queuepoly(V2, shTentacleX, 0xFF);
|
|
queuepoly(V2, shTentacle, (col << 8) + 0xFF);
|
|
}
|
|
else if(c->monst == moDragonHead || c->monst == moDragonTail) {
|
|
char part = dragon::bodypart(c, dragon::findhead(c));
|
|
if(part != '2') queuepoly(V2, shDragonSegment, darkena(col, 0, 0xFF));
|
|
}
|
|
else {
|
|
if(c->monst == moTentacleGhost) {
|
|
hyperpoint V0 = conformal::on ? V*C0 : inverse(cwtV) * V * C0;
|
|
hyperpoint V1 = spintox(V0) * V0;
|
|
transmatrix VL = cwtV * rspintox(V0) * rpushxto0(V1) * spin(M_PI);
|
|
drawMonsterType(moGhost, c, VL, darkena(col, 0, 0xFF));
|
|
col = minf[moTentacletail].color;
|
|
}
|
|
queuepoly(V2, shTentacleX, 0xFFFFFFFF);
|
|
queuepoly(V2, shTentacle, (col << 8) + 0xFF);
|
|
}
|
|
}
|
|
|
|
else for(int u=-1; u<=1; u++)
|
|
queueline(V*ddi(hdir+21, u*crossf/5)*C0, V*ddi(hdir, crossf)*ddi(hdir+21, u*crossf/5)*C0, 0x606020 >> darken);
|
|
}
|
|
|
|
if(vid.monmode > 1) {
|
|
if(isIvy(c) || isMutantIvy(c))
|
|
queuepoly(V, shILeaf[ct-6], darkena(col, 0, 0xFF));
|
|
else if(m == moWorm || m == moWormwait || m == moHexSnake) {
|
|
queuepoly(V2 * spin(M_PI), shWormHead, darkena(col, 0, 0xFF));
|
|
queuepoly(V2 * spin(M_PI), shDragonEyes, 0xFF);
|
|
}
|
|
else if(m == moDragonHead) {
|
|
queuepoly(V2, shDragonHead, darkena(col, c->hitpoints?0:1, 0xFF));
|
|
queuepoly(V2/* * spin(M_PI) */, shDragonEyes, 0xFF);
|
|
|
|
int noscolor = (c->hitpoints == 1 && c->stuntime ==1) ? 0xFF0000FF : 0xFF;
|
|
queuepoly(V2/* * spin(M_PI) */, shDragonNostril, noscolor);
|
|
queuepoly(V2 * Mirror, shDragonNostril, noscolor);
|
|
}
|
|
else if(m == moTentacle || m == moTentaclewait || m == moTentacleEscaping)
|
|
queuepoly(V2 * spin(M_PI), shTentHead, darkena(col, 0, 0xFF));
|
|
else if(m == moDragonTail) {
|
|
cell *c2 = NULL;
|
|
for(int i=0; i<c->type; i++)
|
|
if(c->mov[i] && isDragon(c->mov[i]->monst) && c->mov[i]->mondir == c->spn[i])
|
|
c2 = c->mov[i];
|
|
int nd = neighborId(c, c2);
|
|
char part = dragon::bodypart(c, dragon::findhead(c));
|
|
if(part == 't') {
|
|
int hdir = displaydir(c, nd);
|
|
V2 = V * spin(hdir * M_PI / 42 + M_PI);
|
|
queuepoly(V2, shDragonTail, darkena(col, c->hitpoints?0:1, 0xFF));
|
|
}
|
|
else if(true) {
|
|
int hdir0 = displaydir(c, nd) + 42;
|
|
int hdir1 = displaydir(c, c->mondir);
|
|
while(hdir1 > hdir0 + 42) hdir1 -= 84;
|
|
while(hdir1 < hdir0 - 42) hdir1 += 84;
|
|
V2 = V * spin((hdir0 + hdir1)/2 * M_PI / 42 + M_PI);
|
|
if(part == 'l' || part == '2')
|
|
queuepoly(V2, shDragonLegs, darkena(col, c->hitpoints?0:1, 0xFF));
|
|
queuepoly(V2, shDragonWings, darkena(col, c->hitpoints?0:1, 0xFF));
|
|
}
|
|
}
|
|
else
|
|
queuepoly(V2, shJoint, darkena(col, 0, 0xFF));
|
|
}
|
|
|
|
return vid.monmode < 2;
|
|
}
|
|
|
|
else if(isMimic(c)) {
|
|
|
|
int hdir = displaydir(c, c->mondir);
|
|
|
|
transmatrix V2 = V * spin(M_PI*hdir/42);
|
|
if(c->monst == moMirror) V2 = V2 * Mirror;
|
|
|
|
if(flipplayer) V2 = V2 * spin(M_PI);
|
|
|
|
if(vid.monmode > 1) {
|
|
drawMonsterType(c->monst, c, V2, col);
|
|
drawPlayerEffects(V2, c, false);
|
|
}
|
|
|
|
if(flipplayer) V2 = V2 * spin(M_PI);
|
|
|
|
if(!outofmap(mouseh)) {
|
|
// transmatrix invxy = Id; invxy[0][0] = invxy[1][1] = -1;
|
|
|
|
hyperpoint P2 = V2 * inverse(cwtV) * mouseh;
|
|
int xc, yc, sc;
|
|
getcoord(P2, xc, yc, sc);
|
|
queuechr(xc, yc, sc, 10, 'x', 0xFF00);
|
|
}
|
|
|
|
return vid.monmode < 2;
|
|
}
|
|
|
|
else if(c->monst && vid.monmode < 2) return true;
|
|
|
|
// illusions face randomly
|
|
|
|
else if(c->monst == moIllusion) {
|
|
drawMonsterType(c->monst, c, V, col);
|
|
drawPlayerEffects(V, c, false);
|
|
}
|
|
|
|
// wolves face the heat
|
|
|
|
else if(c->monst == moWolf && c->cpdist > 1) {
|
|
int d = 0;
|
|
double bheat = -999;
|
|
for(int i=0; i<c->type; i++) if(c->mov[i] && HEAT(c->mov[i]) > bheat) {
|
|
bheat = HEAT(c->mov[i]);
|
|
d = i;
|
|
}
|
|
int hdir = displaydir(c, d);
|
|
transmatrix V2 = V * spin(hdir * M_PI / 42);
|
|
return drawMonsterTypeDH(m, c, V2, col, darkhistory);
|
|
}
|
|
|
|
// golems, knights, and hyperbugs don't face the player (mondir-controlled)
|
|
// also whatever in the lineview mode
|
|
|
|
else if(isFriendly(c) || isBug(c) || (c->monst && conformal::on)) {
|
|
int hdir = displaydir(c, c->mondir) + 42;
|
|
transmatrix V2 = V * spin(hdir * M_PI / 42);
|
|
if(!isBug(c)) drawPlayerEffects(V2, c, false);
|
|
return drawMonsterTypeDH(m, c, V2, col, darkhistory);
|
|
}
|
|
|
|
else if(c->monst) {
|
|
// other monsters face the player
|
|
transmatrix VL;
|
|
|
|
if(false) {
|
|
// hyperpoint V0 = cwtV * C0;
|
|
hyperpoint V1 = V * C0;
|
|
VL = V * spin(hypot(V1[0], V1[1]));
|
|
}
|
|
else {
|
|
hyperpoint V0 = inverse(cwtV) * V * C0;
|
|
hyperpoint V1 = spintox(V0) * V0;
|
|
|
|
VL = cwtV * rspintox(V0) * rpushxto0(V1) * spin(M_PI);
|
|
}
|
|
|
|
return drawMonsterTypeDH(m, c, VL, col, darkhistory);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool showPirateX;
|
|
cell *keycell, *pirateTreasureSeek, *pirateTreasureFound;
|
|
transmatrix pirateCoords;
|
|
|
|
double downspin;
|
|
cell *straightDownSeek;
|
|
|
|
int keycelldist;
|
|
|
|
void drawCircle(int x, int y, int size, int color) {
|
|
#ifdef GL
|
|
if(vid.usingGL) {
|
|
qglcoords = 0;
|
|
glcolor(color);
|
|
x -= vid.xcenter; y -= vid.ycenter;
|
|
int pts = size * 4;
|
|
if(pts > 1500) pts = 1500;
|
|
if(ISMOBILE && pts > 72) pts = 72;
|
|
for(int r=0; r<pts; r++) {
|
|
float rr = (M_PI * 2 * r) / pts;
|
|
glcoords[r][0] = x + size * sin(rr);
|
|
glcoords[r][1] = y + size * cos(rr);
|
|
glcoords[r][2] = vid.scrdist;
|
|
}
|
|
|
|
glVertexPointer(3, GL_FLOAT, 0, glcoords);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glDrawArrays(GL_LINE_LOOP, 0, pts);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
#ifdef MOBILE
|
|
gdpush(4); gdpush(color); gdpush(x); gdpush(y); gdpush(size);
|
|
#else
|
|
#ifdef GFX
|
|
(vid.usingAA?aacircleColor:circleColor) (s, x, y, size, (color << 8) | 0x80);
|
|
#else
|
|
int pts = size * 4;
|
|
if(pts > 1500) pts = 1500;
|
|
for(int r=0; r<pts; r++)
|
|
qpixel(s, x + int(size * sin(r)), y + int(size * cos(r))) = color;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
int fnt[100][7];
|
|
|
|
bool bugsNearby(cell *c, int dist = 2) {
|
|
if(!havebugs) return false;
|
|
if(isBug(c)) return true;
|
|
if(dist) for(int t=0; t<c->type; t++) if(c->mov[t] && bugsNearby(c->mov[t], dist-1)) return true;
|
|
return false;
|
|
}
|
|
|
|
int minecolors[8] = {
|
|
0xFFFFFF, 0xF0, 0xF060, 0xF00000,
|
|
0x60, 0x600000, 0x00C0C0, 0
|
|
};
|
|
|
|
const char* minetexts[8] = {
|
|
"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!"
|
|
};
|
|
|
|
int countMinesAround(cell *c) {
|
|
int mines = 0;
|
|
for(int i=0; i<c->type; i++)
|
|
if(c->mov[i] && c->mov[i]->wall == waMineMine)
|
|
mines++;
|
|
return mines;
|
|
}
|
|
|
|
transmatrix movecell[7], curcell;
|
|
|
|
transmatrix applyPatterndir(cell *c, char patt = mapeditor::whichPattern) {
|
|
int hdir = displaydir(c, mapeditor::patterndir(c, patt));
|
|
transmatrix V = spin((42+hdir) * M_PI / 42);
|
|
|
|
if(mapeditor::reflectPatternAt(c, patt))
|
|
return V * Mirror;
|
|
|
|
return V;
|
|
}
|
|
|
|
transmatrix applyDowndir(cell *c, cellfunction *cf) {
|
|
int hdir = displaydir(c, mapeditor::downdir(c, cf));
|
|
return spin((42+hdir) * M_PI / 42);
|
|
}
|
|
|
|
void drawTowerFloor(const transmatrix& V, cell *c, int col, cellfunction *cf = coastvalEdge) {
|
|
int j = -1;
|
|
|
|
if(euclid) j = 10;
|
|
else if((*cf)(c) > 1) {
|
|
int i = towerval(c, cf);
|
|
if(i == 4) j = 0;
|
|
if(i == 5) j = 1;
|
|
if(i == 6) j = 2;
|
|
if(i == 8) j = 3;
|
|
if(i == 9) j = 4;
|
|
if(i == 10) j = 5;
|
|
if(i == 13) j = 6;
|
|
if(purehepta) {
|
|
if(i == 7) j = 7;
|
|
if(i == 11) j = 8;
|
|
if(i == 15) j = 9;
|
|
}
|
|
}
|
|
|
|
if(j >= 0)
|
|
queuepoly(V * applyDowndir(c, cf), shTower[j], col);
|
|
else if(c->wall != waLadder)
|
|
queuepoly(V, shMFloor[c->type-6], col);
|
|
}
|
|
|
|
void drawZebraFloor(const transmatrix& V, cell *c, int col) {
|
|
|
|
if(euclid) { queuepoly(V, shTower[10], col); return; }
|
|
|
|
int i = zebra40(c);
|
|
i &= ~3;
|
|
|
|
int j;
|
|
|
|
if(purehepta) j = 4;
|
|
else if(i >=4 && i < 16) j = 2;
|
|
else if(i >= 16 && i < 28) j = 1;
|
|
else if(i >= 28 && i < 40) j = 3;
|
|
else j = 0;
|
|
|
|
queuepoly(V * applyPatterndir(c, 'z'), shZebra[j], col);
|
|
}
|
|
|
|
#define ECT (euclid?2:ct-6)
|
|
|
|
void drawEmeraldFloor(const transmatrix& V, cell *c, int col) {
|
|
int j = -1;
|
|
|
|
if(!euclid && !purehepta) {
|
|
int i = emeraldval(c) & ~3;
|
|
if(i == 8) j = 0;
|
|
else if(i == 12) j = 1;
|
|
else if(i == 16) j = 2;
|
|
else if(i == 20) j = 3;
|
|
else if(i == 28) j = 4;
|
|
else if(i == 36) j = 5;
|
|
}
|
|
|
|
if(j >= 0)
|
|
queuepoly(V * applyPatterndir(c, 'f'), shEmeraldFloor[j], col);
|
|
else
|
|
queuepoly(V, shCaveFloor[euclid?2:c->type-6], col);
|
|
}
|
|
|
|
double fanframe;
|
|
|
|
void viewBuggyCells(cell *c, transmatrix V) {
|
|
for(int i=0; i<size(buggycells); i++)
|
|
if(c == buggycells[i]) {
|
|
queuepoly(V, shPirateX, 0xC000C080);
|
|
return;
|
|
}
|
|
|
|
for(int i=0; i<size(buggycells); i++) {
|
|
cell *c1 = buggycells[i];
|
|
cell *cf = cwt.c;
|
|
|
|
while(cf != c1) {
|
|
cf = pathTowards(cf, c1);
|
|
if(cf == c) {
|
|
queuepoly(V, shMineMark[1], 0xC000C0D0);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawcell(cell *c, const transmatrix& V, int spinv) {
|
|
|
|
#ifdef BUILDZEBRA
|
|
if(c->type == 6 && c->tmp > 0) {
|
|
int i = c->tmp;
|
|
zebra(cellwalker(c, i&15), 1, i>>4, "", 0);
|
|
}
|
|
|
|
c->item = eItem(c->heat / 4);
|
|
buildAutomatonRule(c);
|
|
#endif
|
|
|
|
viewBuggyCells(c,V);
|
|
|
|
// todo: fix when scrolling
|
|
if(!buggyGeneration && c->land != laCanvas && sightrange < 10) {
|
|
// not yet created
|
|
if(c->mpdist > 7 && !cheater) return;
|
|
// in the Yendor Challenge, scrolling back is forbidden
|
|
if(c->cpdist > 7 && (yendor::on && !cheater)) return;
|
|
// (incorrect comment) too far, no bugs nearby
|
|
if(playermoved && c->cpdist > sightrange) return;
|
|
}
|
|
|
|
if(conformal::on || inHighQual) checkTide(c);
|
|
|
|
if(!euclid) {
|
|
// draw a web-like map
|
|
if(webdisplay & 1) {
|
|
if(c->type == 6) {
|
|
for(int a=0; a<3; a++)
|
|
queueline(V*Crad[a*7], V*Crad[a*7+21], 0xd0d0 >> darken);
|
|
}
|
|
else {
|
|
for(int a=0; a<7; a++)
|
|
queueline(V*C0, V*Crad[(21+a*6)%42], 0xd0d0 >> darken);
|
|
}
|
|
}
|
|
|
|
if(webdisplay & 2) if(c->type == 7) {
|
|
queueline(V*C0, V*xpush(tessf)*C0, 0xd0d0 >> darken);
|
|
}
|
|
|
|
if(webdisplay & 4) if(c->type == 7 && !euclid && c->master->alt) {
|
|
for(int i=0; i<7; i++)
|
|
if(c->master->move[i] && c->master->move[i]->alt == c->master->alt->move[0])
|
|
queueline(V*C0, V*spin(-2*M_PI*i/7)*xpush(tessf)*C0, 0xd000d0 >> darken);
|
|
}
|
|
}
|
|
|
|
// save the player's view center
|
|
if(c == cwt.c && !shmup::on) {
|
|
playerfound = true;
|
|
|
|
/* if(euclid)
|
|
return d * 84 / c->type;
|
|
else
|
|
return 42 - d * 84 / c->type;
|
|
cwtV = V * spin(-cwt.spin * 2*M_PI/c->type) * spin(M_PI); */
|
|
|
|
cwtV = V * spin(displaydir(c, cwt.spin) * M_PI/42);
|
|
}
|
|
|
|
/* if(cwt.c->land == laEdge) {
|
|
if(c == chosenDown(cwt.c, 1, 0))
|
|
playerfoundL = c, cwtVL = V;
|
|
if(c == chosenDown(cwt.c, -1, 0))
|
|
playerfoundR = c, cwtVR = V;
|
|
} */
|
|
|
|
if(1) {
|
|
|
|
hyperpoint VC0 = V*C0;
|
|
|
|
if(intval(mouseh, VC0) < modist) {
|
|
modist2 = modist; mouseover2 = mouseover;
|
|
modist = intval(mouseh, VC0);
|
|
mouseover = c;
|
|
}
|
|
else if(intval(mouseh, VC0) < modist2) {
|
|
modist2 = intval(mouseh, VC0);
|
|
mouseover2 = c;
|
|
}
|
|
|
|
double dfc = euclid ? intval(VC0, C0) : VC0[2];
|
|
|
|
if(dfc < centdist) {
|
|
centdist = dfc;
|
|
centerover = c;
|
|
}
|
|
|
|
int xc, yc, sc, xs, ys, ss;
|
|
getcoord(VC0, xc, yc, sc);
|
|
getcoord(V*xpush(.5)*C0, xs, ys, ss);
|
|
// int col = 0xFFFFFF - 0x20 * c->maxdist - 0x2000 * c->cpdist;
|
|
|
|
if(!buggyGeneration && c->mpdist > 8 && !cheater) return; // not yet generated
|
|
|
|
if(c->land == laNone && cmode == emMapEditor) {
|
|
queuepoly(V, shTriangle, 0xFF0000FF);
|
|
}
|
|
|
|
char ch = winf[c->wall].glyph;
|
|
int col = winf[c->wall].color;
|
|
|
|
if(c->land == laAlchemist && c->wall == waNone) col = 0x202020;
|
|
if(c->land == laCrossroads && c->wall == waNone) col = (vid.goteyes2 ? 0xFF3030 : 0xFF0000);
|
|
if(c->land == laCrossroads2 && c->wall == waNone)
|
|
col = linf[laCrossroads2].color;
|
|
|
|
if(c->land == laCrossroads3 && c->wall == waNone)
|
|
col = linf[laCrossroads3].color;
|
|
|
|
if(c->land == laCrossroads4 && c->wall == waNone)
|
|
col = linf[laCrossroads4].color;
|
|
|
|
if(isElemental(c->land) && c->wall == waNone)
|
|
col = linf[c->land].color;
|
|
|
|
if(c->land == laElementalWall && c->wall == waNone)
|
|
col = (linf[c->barleft].color>>1) + (linf[c->barright].color>>1);
|
|
|
|
if(c->land == laZebra && c->wall == waNone) {
|
|
col = 0xE0E0E0;
|
|
}
|
|
|
|
if(c->land == laZebra && c->wall == waTrapdoor)
|
|
col = 0x808080;
|
|
|
|
if(c->land == laDesert && c->wall == waNone) col = 0xEDC9AF;
|
|
if(c->land == laCaves && c->wall == waNone) col = 0x202020;
|
|
if(c->land == laEmerald && c->wall == waNone) col = 0x202020;
|
|
if(c->land == laDeadCaves && c->wall == waNone) col = 0x202020;
|
|
|
|
if(c->land == laNone && c->wall == waNone) {
|
|
col = 0x101010;
|
|
queuepoly(V, shTriangle, 0xFFFF0000);
|
|
}
|
|
|
|
if(isHive(c->land) && !isWateryOrBoat(c) && c->wall != waCloud && c->wall != waMirror && c->wall != waMineMine) {
|
|
col = linf[c->land].color;
|
|
if(c->wall == waWaxWall) col = c->landparam;
|
|
}
|
|
if(c->land == laJungle && c->wall == waNone) col = (vid.goteyes2 ? 0x408040 : 0x008000);
|
|
if(c->land == laPower && c->wall == waNone)
|
|
col = linf[c->land].color;
|
|
/* if(c->land == laEmerald && c->wall == waNone) {
|
|
col = 0x50A020;
|
|
}
|
|
if(c->land == laEmerald && c->wall == waLake) {
|
|
col = 0x202080;
|
|
int i = 0;
|
|
for(int k=0; k<c->type; k++) if(c->mov[k] && c->mov[k]->wall != waLake)
|
|
i++;
|
|
if(i > 0) {
|
|
col = gradient(col, 0xFFFFFF, 0, i-fabs(sin(ticks/1500.0)), 7);
|
|
}
|
|
} */
|
|
if(c->land == laWineyard && c->wall == waNone) {
|
|
col = 0x006000;
|
|
}
|
|
if(c->land == laTortoise && (c->wall == waNone || c->wall == waBigTree || c->wall == waSmallTree)) {
|
|
|
|
if(c->wall == waBigTree) col = 0x709000;
|
|
else if(c->wall == waSmallTree) col = 0x905000;
|
|
else col = tortoise::getMatchColor(getBits(c));
|
|
}
|
|
|
|
if(c->land == laDryForest && c->wall == waNone) {
|
|
/*if(c->wall == waBigTree)
|
|
col = (vid.goteyes ? 0xC0C060 : 0xC0C000);
|
|
else if(c->wall == waSmallTree)
|
|
col = (vid.goteyes ? 0x60C060 : 0x00C000);
|
|
else*/ if(c->wall == waNone) {
|
|
col = gradient(0x008000, 0x800000, 0, c->landparam, 10);
|
|
}
|
|
}
|
|
if(c->land == laMirror && c->wall == waNone) col = 0x808080;
|
|
if(c->land == laMotion && c->wall == waNone) col = 0xF0F000;
|
|
if(c->land == laGraveyard && c->wall == waNone) col = 0x107010;
|
|
if(c->land == laCamelot && c->wall == waNone) {
|
|
int d = showoff ? 0 : ((euclid||c->master->alt) ? celldistAltRelative(c) : 0);
|
|
if(d < 0)
|
|
col = 0xA0A0A0;
|
|
else {
|
|
// a nice floor pattern
|
|
int v = emeraldval(c);
|
|
int v0 = (v&~3);
|
|
bool sw = (v&1);
|
|
if(v0 == 8 || v0 == 12 || v0 == 20 || v0 == 40 || v0 == 36 || v0 == 24)
|
|
sw = !sw;
|
|
if(sw)
|
|
col = 0xC0C0C0;
|
|
else
|
|
col = 0xA0A0A0;
|
|
}
|
|
}
|
|
if(c->land == laRlyeh && c->wall == waNone) col = (vid.goteyes2 ? 0x4080C0 : 0x004080);
|
|
if(c->land == laTemple) {
|
|
int d = showoff ? 0 : (euclid||c->master->alt) ? celldistAlt(c) : 99;
|
|
if(chaosmode)
|
|
col = c->wall == waColumn ? winf[waColumn].color : 0x405090;
|
|
else if(d % TEMPLE_EACH == 0)
|
|
col = c->wall == waColumn ? winf[waColumn].color :
|
|
gradient(0x304080, winf[waColumn].color, 0, 0.5, 1);
|
|
// else if(c->type == 7)
|
|
// col = 0x707070;
|
|
else if(d% 2 == -1)
|
|
col = 0x304080;
|
|
else
|
|
col = 0x405090;
|
|
}
|
|
if(c->land == laHell && c->wall == waNone) col = (vid.goteyes2 ? 0xC03030 : 0xC00000);
|
|
|
|
if(c->land == laPalace && (c->wall == waNone || c->wall == waClosePlate || c->wall == waOpenPlate ||
|
|
c->wall == waTrapdoor) && (c->wall == waNone || vid.wallmode != 0))
|
|
col = 0x806020;
|
|
|
|
if(c->land == laPalace && c->wall == waCamelot)
|
|
col = 0xFFD500;
|
|
|
|
if(isIcyLand(c) && isIcyWall(c)) {
|
|
float h = HEAT(c);
|
|
bool showcoc = c->land == laCocytus && chaosmode && vid.wallmode < 3;
|
|
if(h < -0.4)
|
|
col = gradient(showcoc ? 0x4080FF : 0x4040FF, 0x0000FF, -0.4, h, -1);
|
|
else if(h < 0)
|
|
col = gradient(showcoc ? 0x80C0FF : 0x8080FF, showcoc ? 0x4080FF : 0x4040FF, 0, h, -0.4);
|
|
else if(h < 0.2)
|
|
col = gradient(showcoc ? 0x80C0FF : 0x8080FF, 0xFFFFFF, 0, h, 0.2);
|
|
// else if(h < 0.4)
|
|
// col = gradient(0xFFFFFF, 0xFFFF00, 0.2, h, 0.4);
|
|
else if(h < 0.6)
|
|
col = gradient(0xFFFFFF, 0xFF0000, 0.2, h, 0.6);
|
|
else if(h < 0.8)
|
|
col = gradient(0xFF0000, 0xFFFF00, 0.6, h, 0.8);
|
|
else
|
|
col = 0xFFFF00;
|
|
if(c->wall == waNone)
|
|
col = (col & 0xFEFEFE) >> 1;
|
|
if(c->wall == waLake)
|
|
col = (col & 0xFCFCFC) >> 2;
|
|
}
|
|
|
|
/* if(c->wall == waBonfireOff)
|
|
col = 0x404040; */
|
|
|
|
if(isFire(c))
|
|
col = c->wall == waEternalFire ? weakfirecolor(1500) : firecolor(100);
|
|
|
|
/* if(c->wall == waThumperOff)
|
|
col = 0xEDC9AF; */
|
|
|
|
if(c->wall == waThumperOn) {
|
|
int ds = ticks;
|
|
for(int u=0; u<5; u++) {
|
|
ld rad = hexf * (.3 * u + (ds%1000) * .0003);
|
|
int col = gradient(0xFFFFFF, 0, 0, rad, 1.5 * hexf);
|
|
for(int a=0; a<84; a++)
|
|
queueline(V*ddi(a, rad)*C0, V*ddi(a+1, rad)*C0, col);
|
|
}
|
|
}
|
|
|
|
if(c->land == laEmerald && c->wall == waCavefloor) {
|
|
col = gradient(col, 0xFF00, 0, 0.5, 1);
|
|
// col |= 0xFF00; // col += 0x300060; // col += 0x2F18; col -= 0x100000;
|
|
}
|
|
|
|
if(c->land == laOcean && (c->wall == waNone || c->wall == waStrandedBoat)) {
|
|
if(chaosmode)
|
|
col = gradient(0xD0A090, 0xD0D020, 0, c->CHAOSPARAM, 30);
|
|
else
|
|
col = gradient(0xD0D090, 0xD0D020, -1, sin((double) c->landparam), 1);
|
|
}
|
|
|
|
if(c->land == laLivefjord && (c->wall == waNone || c->wall == waStrandedBoat))
|
|
col = 0x306030;
|
|
|
|
if(c->land == laEmerald && c->wall == waCavewall) {
|
|
col = 0xC0FFC0;
|
|
// col |= 0xFF00; // col += 0x300060; // col += 0x2F18; col -= 0x100000;
|
|
}
|
|
|
|
if(c->land == laHive && items[itOrbInvis] && c->wall == waNone && c->landparam)
|
|
col = gradient(col, 0xFF0000, 0, c->landparam, 100);
|
|
|
|
if(c->land == laStorms && (c->wall == waNone))
|
|
col = linf[c->land].color;
|
|
|
|
if(c->land == laWhirlwind && (c->wall == waNone)) {
|
|
int wcol[4] = {0x404040, 0x404080, 0x2050A0, 0x5050C0};
|
|
col = wcol[whirlwind::fzebra3(c)];
|
|
}
|
|
|
|
if(c->land == laOvergrown || c->land == laClearing) {
|
|
if(c->wall == waSmallTree) col = 0x008060;
|
|
else if(c->wall == waBigTree) col = 0x0080C0;
|
|
else if(c->wall == waNone)
|
|
col = (c->land == laOvergrown/* || (celldistAlt(c)&1)*/) ? 0x00C020 : 0x60E080;
|
|
}
|
|
|
|
if(c->land == laGridCoast && c->wall == waSmallTree) col = 0x608000;
|
|
|
|
if(isHaunted(c->land)) {
|
|
if(c->wall == waSmallTree) col = 0x004000;
|
|
else if(c->wall == waBigTree) col = 0x008000;
|
|
else if(c->wall == waNone) {
|
|
int itcolor = 0;
|
|
for(int i=0; i<c->type; i++) if(c->mov[i] && c->mov[i]->item)
|
|
itcolor = 1;
|
|
if(c->item) itcolor |= 2;
|
|
col = 0x609F60 + 0x202020 * itcolor;
|
|
}
|
|
}
|
|
|
|
if(c->land == laWildWest && (c->wall == waNone))
|
|
col = linf[c->land].color;
|
|
|
|
if(c->land == laCaribbean && (c->wall == waCIsland || c->wall == waCIsland2))
|
|
col = winf[c->wall].color;
|
|
|
|
if(c->wall == waBoat && !vid.wallmode) {
|
|
col = 0xC06000;
|
|
}
|
|
|
|
if(c->land == laMinefield && c->wall == waMineMine && (cmode == emMapEditor || !canmove))
|
|
col = 0xFF4040;
|
|
|
|
if(c->wall == waMineMine && c->land != laMinefield)
|
|
col = gradient(col, 0xFF4040, -1, sin(ticks/100.0), 1);
|
|
|
|
if(c->land == laMinefield && c->wall == waNone)
|
|
col = 0x80A080;
|
|
|
|
if(c->land == laCaribbean && c->wall == waNone)
|
|
col = 0x006000;
|
|
|
|
if(c->land == laRose && c->wall == waNone) {
|
|
col = linf[c->land].color;
|
|
}
|
|
|
|
if(isWarped(c->land) && c->wall == waNone)
|
|
col = pseudohept(c) ? 0x80C080 : 0xA06020;
|
|
|
|
if(c->land == laRedRock && (c->wall == waNone || snakelevel(c)) && c->wall != waDeadfloor2) {
|
|
col = linf[c->land].color;
|
|
}
|
|
|
|
if(c->land == laDragon && (c->wall == waNone || snakelevel(c)) && c->wall != waDeadfloor2) {
|
|
col = linf[c->land].color;
|
|
}
|
|
|
|
if(c->land == laCanvas && c->wall == waNone) {
|
|
col = c->landparam;
|
|
}
|
|
|
|
if(pseudohept(c)) {
|
|
if(vid.darkhepta)
|
|
col = gradient(0, col, 0, 0.75, 1);
|
|
}
|
|
|
|
int rd = rosedist(c);
|
|
if(rd == 1) col = gradient(0x804060, col, 0,1,3);
|
|
if(rd == 2) col = gradient(0x804060, col, 0,2,3);
|
|
|
|
int ycol = col;
|
|
|
|
if(c->land == laHive && c->bardir == NOBARRIERS && c->barleft) {
|
|
col = minf[moBug0+c->barright].color;
|
|
}
|
|
|
|
if(items[itRevolver] && c->pathdist > GUNRANGE && !shmup::on)
|
|
col = gradient(col, 0, 0, 25, 100);
|
|
|
|
int xcol = col;
|
|
|
|
eItem it = c->item;
|
|
|
|
bool hidden = itemHidden(c);
|
|
bool hiddens = itemHiddenFromSight(c);
|
|
|
|
if(conformal::includeHistory && eq(c->aitmp, sval)) {
|
|
hidden = true;
|
|
hiddens = false;
|
|
}
|
|
|
|
if(hiddens && cmode != emMapEditor)
|
|
it = itNone;
|
|
|
|
if(it)
|
|
ch = iinf[it].glyph, col = iinf[it].color;
|
|
|
|
int icol = col;
|
|
|
|
if(it && c->land == laAlchemist)
|
|
if(!(conformal::includeHistory && eq(c->aitmp, sval)))
|
|
xcol = col;
|
|
|
|
if(c->monst) {
|
|
ch = minf[c->monst].glyph, col = minf[c->monst].color;
|
|
if(c->monst == moMutant) {
|
|
// root coloring
|
|
if(c->stuntime != mutantphase)
|
|
col = gradient(0xC00030, 0x008000, 0, (c->stuntime-mutantphase) & 15, 15);
|
|
}
|
|
if(isMetalBeast(c->monst) && c->stuntime)
|
|
col >>= 1;
|
|
}
|
|
|
|
if(c->cpdist == 0 && mapeditor::drawplayer) {
|
|
ch = '@';
|
|
if(vid.monmode == 0) col = cheater ? 0xFF3030 : 0xD0D0D0;
|
|
}
|
|
|
|
if(c->monst == moSlime) {
|
|
col = winf[c->wall].color;
|
|
col |= (col>>1);
|
|
}
|
|
|
|
if(c->ligon) {
|
|
int tim = ticks - lightat;
|
|
if(tim > 1000) tim = 800;
|
|
if(elec::havecharge && tim > 400) tim = 400;
|
|
for(int t=0; t<7; t++) if(c->mov[t] && c->mov[t]->ligon) {
|
|
int hdir = displaydir(c, t);
|
|
int col = gradient(iinf[itOrbLightning].color, 0, 0, tim, 1100);
|
|
queueline(V*ddi(ticks, hexf/2)*C0, V*ddi(hdir, crossf)*C0, col);
|
|
}
|
|
}
|
|
|
|
int ct = c->type;
|
|
|
|
bool error = false;
|
|
|
|
if(c->land == laIvoryTower && (c->wall == waNone || c->wall == waLadder))
|
|
// xcol = (c->landparam&1) ? 0xD00000 : 0x00D000;
|
|
xcol = 0x10101 * (32 + (c->landparam&1) * 32) - 0x000010;
|
|
|
|
if(c->land == laEndorian && c->wall == waNone) {
|
|
int clev = cwt.c->land == laEndorian ? edgeDepth(cwt.c) : 0;
|
|
// xcol = (c->landparam&1) ? 0xD00000 : 0x00D000;
|
|
xcol = 0x10101 * (32 + (c->landparam&1) * 32) - 0x000010;
|
|
xcol = gradient(xcol, 0x0000D0, clev-10, edgeDepth(c), clev+10);
|
|
}
|
|
|
|
if(c->wall == waTrunk) xcol = winf[waTrunk].color;
|
|
|
|
if(c->wall == waCanopy || c->wall == waSolidBranch || c->wall == waWeakBranch) {
|
|
xcol = winf[waCanopy].color;
|
|
if(c->landparam & 1) xcol = gradient(0, xcol, 0, .75, 1);
|
|
}
|
|
|
|
if(c->wall == waSea || c->wall == waBoat) {
|
|
if(c->land == laOcean)
|
|
xcol = (c->landparam > 25 && !chaosmode) ? 0x000090 :
|
|
0x1010C0 + int(32 * sin(ticks / 500. + (chaosmode ? c->CHAOSPARAM : c->landparam)*1.5));
|
|
else if(c->land == laOceanWall)
|
|
xcol = 0x2020FF;
|
|
else if(c->land == laAlchemist)
|
|
xcol = 0x900090;
|
|
else if(c->land == laWhirlpool)
|
|
xcol = 0x0000C0 + int(32 * sin(ticks / 200. + ((euclid||c->master->alt) ? celldistAlt(c) : 0)*1.5));
|
|
else if(c->land == laLivefjord)
|
|
xcol = 0x000080;
|
|
else if(isWarped(c->land))
|
|
xcol = 0x0000C0 + int((pseudohept(c)?30:-30) * sin(ticks / 600.));
|
|
}
|
|
|
|
if(vid.wallmode) {
|
|
|
|
poly_outline = OUTLINE_NONE;
|
|
|
|
// floor
|
|
|
|
int fd =
|
|
c->land == laRedRock ? 0 :
|
|
(c->land == laOcean || c->land == laLivefjord || c->land == laWhirlpool) ? 1 :
|
|
c->land == laAlchemist || c->land == laIce || c->land == laGraveyard ||
|
|
c->land == laRlyeh || c->land == laTemple || c->land == laWineyard ||
|
|
c->land == laDeadCaves || c->land == laPalace ? 1 :
|
|
c->land == laCanvas ? 0 :
|
|
c->land == laIvoryTower ? 1 :
|
|
c->land == laEndorian ? 1 :
|
|
c->land == laCaribbean ? 1 :
|
|
c->land == laWhirlwind ? 1 :
|
|
c->land == laRose ? 1 :
|
|
c->land == laGridSea ? 1 :
|
|
c->land == laTortoise ? 1 :
|
|
c->land == laDragon ? 1 :
|
|
2;
|
|
|
|
#ifndef MOBILE
|
|
transmatrix Vpdir = V * applyPatterndir(c);
|
|
#endif
|
|
|
|
// printf("ql\n");
|
|
// queueline(Vpdir * C0, Vpdir * xpush(crossf/3) * C0, 0xFFFFFF);
|
|
|
|
bool eoh = euclid || purehepta;
|
|
|
|
#ifndef MOBILE
|
|
if(c == mapeditor::drawcell && c != cwt.c && !c->monst && !c->item) {
|
|
mapeditor::drawtrans = Vpdir;
|
|
}
|
|
#endif
|
|
|
|
if(c->wall == waChasm) ;
|
|
|
|
/* else if(purehepta)
|
|
queuepoly(V * spin(M_PI), shBigHepta, darkena(xcol, fd, 0xFF)); */
|
|
|
|
|
|
#ifndef MOBILE
|
|
else if(drawUserShape(Vpdir, mapeditor::cellShapeGroup(), mapeditor::realpattern(c),
|
|
darkena(xcol, fd, cmode == emDraw ? 0xC0 : 0xFF)));
|
|
|
|
else if(mapeditor::whichShape == '7') {
|
|
if(ishept(c))
|
|
queuepoly(V, vid.wallmode == 1 ? shBFloor[ct-6] :
|
|
euclid ? shBigHex :
|
|
shBigHepta, darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(mapeditor::whichShape == '8') {
|
|
if(euclid)
|
|
queuepoly(V, shTriheptaEuc[ishept(c) ? 1 : ishex1(c) ? 0 : 2], darkena(xcol, fd, 0xFF));
|
|
else
|
|
queuepoly(V, shTriheptaFloor[ishept(c) ? 1 : 0], darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(mapeditor::whichShape == '6') {
|
|
if(!ishept(c))
|
|
queuepoly(V,
|
|
vid.wallmode == 1 ? shBFloor[ct-6] :
|
|
euclid ? (ishex1(c) ? shBigHexTriangle : shBigHexTriangleRev) :
|
|
shBigTriangle, darkena(xcol, fd, 0xFF));
|
|
}
|
|
#endif
|
|
|
|
else if(c->land == laWineyard && (c->wall == waVineHalfA || c-> wall == waVineHalfB)) {
|
|
|
|
int i =-1;
|
|
for(int t=0;t<6; t++) if(c->mov[t] && c->mov[t]->wall == c->wall)
|
|
i = t;
|
|
|
|
int hdir = 14 + displaydir(c, i);
|
|
|
|
transmatrix V2 = V * spin(M_PI*hdir/42);
|
|
|
|
hpcshape *shar = shSemiFeatherFloor;
|
|
|
|
if(vid.wallmode == 1) shar = shSemiBFloor;
|
|
if(vid.wallmode == 2) shar = shSemiFloor;
|
|
|
|
int dk = vid.wallmode == 1 ? 0 : vid.wallmode == 2 ? 1 : 1;
|
|
|
|
queuepoly(V2, shar[0], darkena(winf[waVinePlant].color, dk, 0xFF));
|
|
queuepoly(V2, shar[1], darkena(xcol, dk, 0xFF));
|
|
}
|
|
|
|
else if(vid.wallmode == 1 && c->land == laAlchemist)
|
|
queuepoly(V, shFloor[ct-6], darkena(xcol, 1, 0xFF));
|
|
|
|
else if(vid.wallmode == 1 && c->wall == waMineOpen)
|
|
;
|
|
|
|
else if(vid.wallmode == 1)
|
|
queuepoly(V, shBFloor[ct-6], darkena(xcol, 0, 0xFF));
|
|
|
|
else if(isWarped(c) && euclid)
|
|
queuepoly(V, shTriheptaEuc[ishept(c)?1:ishex1(c)?0:2], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(isWarped(c) && !purehepta && !shmup::on) {
|
|
transmatrix V2 = V * applyPatterndir(c);
|
|
int np = mapeditor::nopattern(c);
|
|
if(c->landparam == 1337) np = 0; // for the achievement screenshot
|
|
if(np < 11)
|
|
queuepoly(V2, shTriheptaFloor[np], darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(vid.wallmode == 2) {
|
|
queuepoly(V, shFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(randomPatternsMode && c->land != laBarrier && !isWarped(c->land)) {
|
|
int j = (randompattern[c->land]/5) % 15;
|
|
int col = darkena(xcol, fd, 0xFF);
|
|
int k = randompattern[c->land] % RPV_MODULO;
|
|
int k7 = randompattern[c->land] % 7;
|
|
|
|
if(k == RPV_ZEBRA && k7 < 2) drawZebraFloor(V, c, col);
|
|
else if(k == RPV_EMERALD && k7 == 0) drawEmeraldFloor(V, c, col);
|
|
else if(k == RPV_CYCLE && k7 < 4) drawTowerFloor(V, c, col, celldist);
|
|
|
|
else switch(j) {
|
|
case 0: queuepoly(V, shCloudFloor[ct-6], col); break;
|
|
case 1: queuepoly(V, shFeatherFloor[ECT], col); break;
|
|
case 2: queuepoly(V, shStarFloor[ct-6], col); break;
|
|
case 3: queuepoly(V, shTriFloor[ct-6], col); break;
|
|
case 4: queuepoly(V, shSStarFloor[ct-6], col); break;
|
|
case 5: queuepoly(V, shOverFloor[ECT], col); break;
|
|
case 6: queuepoly(V, shFeatherFloor[ECT], col); break;
|
|
case 7: queuepoly(V, shDemonFloor[ct-6], col); break;
|
|
case 8: queuepoly(V, shCrossFloor[ct-6], col); break;
|
|
case 9: queuepoly(V, shMFloor[ct-6], col); break;
|
|
case 10: queuepoly(V, shCaveFloor[ECT], col); break;
|
|
case 11: queuepoly(V, shPowerFloor[ct-6], col); break;
|
|
case 12: queuepoly(V, shDesertFloor[ct-6], col); break;
|
|
case 13: queuepoly(V, purehepta ? shChargedFloor[3] : shChargedFloor[ct-6], col); break;
|
|
case 14: queuepoly(V, ct==6?shChargedFloor[2]:shFloor[1], col); break;
|
|
}
|
|
}
|
|
|
|
else if(c->land == laWineyard) {
|
|
queuepoly(V, shFeatherFloor[euclid?2:ct-6], darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(c->land == laZebra)
|
|
drawZebraFloor(V, c, darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->wall == waTrunk)
|
|
queuepoly(V, shFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->wall == waCanopy || c->wall == waSolidBranch || c->wall == waWeakBranch)
|
|
queuepoly(V, shFeatherFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(isGravityLand(c->land))
|
|
drawTowerFloor(V, c, darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laEmerald)
|
|
drawEmeraldFloor(V, c, darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laRlyeh)
|
|
queuepoly(V, (eoh ? shFloor: shTriFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laTemple)
|
|
queuepoly(V, (eoh ? shFloor: shTriFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laAlchemist)
|
|
queuepoly(V, shCloudFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laRose)
|
|
queuepoly(V, shRoseFloor[purehepta ? 2 : ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laTortoise)
|
|
queuepoly(V, shTurtleFloor[purehepta ? 2 : ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laDragon && !purehepta)
|
|
queuepoly(V, shDragonFloor[euclid?2:ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if((isElemental(c->land) || c->land == laElementalWall) && !eoh)
|
|
queuepoly(V, shNewFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laJungle)
|
|
queuepoly(V, shFeatherFloor[euclid?2:ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laGraveyard)
|
|
queuepoly(V, (eoh ? shFloor : shCrossFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laDeadCaves) {
|
|
queuepoly(V, shCaveFloor[euclid?2:ct-6], darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(c->land == laMotion)
|
|
queuepoly(V, shMFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laWhirlwind)
|
|
// drawZebraFloor(V, c, darkena(xcol, fd, 0xFF));
|
|
queuepoly(V, (eoh ? shCloudFloor : shNewFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laHell)
|
|
queuepoly(V, (euclid ? shStarFloor : shDemonFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laIce)
|
|
// queuepoly(V, shFloor[ct-6], darkena(xcol, 2, 0xFF));
|
|
queuepoly(V, shStarFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laCocytus)
|
|
queuepoly(V, (eoh ? shCloudFloor : shDesertFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laStorms) {
|
|
if(euclid)
|
|
queuepoly(ishex1(c) ? V*spin(M_PI) : V,
|
|
ishept(c) ? shFloor[0] : shChargedFloor[2], darkena(xcol, fd, 0xFF));
|
|
else
|
|
queuepoly(V, (purehepta ? shChargedFloor[3] : ct==6 ? shChargedFloor[2] : shFloor[1]), darkena(xcol, fd, 0xFF));
|
|
}
|
|
|
|
else if(c->land == laWildWest)
|
|
queuepoly(V, (eoh ? shCloudFloor : shSStarFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laPower)
|
|
queuepoly(V, (eoh ? shStarFloor : shPowerFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laHive && !isWateryOrBoat(c) && c->wall != waFloorB && c->wall != waFloorA &&
|
|
c->wall != waMirror && c->wall != waCloud) {
|
|
queuepoly(V, shFloor[ct-6], darkena(xcol, 1, 0xFF));
|
|
if(!snakelevel(c) && c->wall != waMirror && c->wall != waCloud)
|
|
queuepoly(V, shMFloor[ct-6], darkena(xcol, 2, 0xFF));
|
|
if(c->wall != waWaxWall && c->wall != waDeadTroll && c->wall != waDeadTroll2 && c->wall != waVinePlant &&
|
|
!snakelevel(c) && c->wall != waMirror && c->wall != waCloud &&
|
|
c->wall != waStrandedBoat)
|
|
queuepoly(V, shMFloor2[ct-6], darkena(xcol, xcol==ycol ? 1 : 2, 0xFF));
|
|
}
|
|
|
|
else if(c->land == laCaves)
|
|
queuepoly(V, shCaveFloor[ECT], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laDesert)
|
|
queuepoly(V, (eoh ? shCloudFloor : shDesertFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laOvergrown || c->land == laClearing || isHaunted(c->land))
|
|
queuepoly(V, shOverFloor[ECT], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laRose)
|
|
queuepoly(V, shOverFloor[ECT], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laDryForest)
|
|
queuepoly(V, (eoh ? shStarFloor : shDesertFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laCaribbean || c->land == laOcean || c->land == laOceanWall || c->land == laWhirlpool)
|
|
queuepoly(V, shCloudFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laLivefjord)
|
|
queuepoly(V, shCaveFloor[ECT], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laRedRock)
|
|
queuepoly(V, eoh ? shFloor[ct-6] : shDesertFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else if(c->land == laPalace)
|
|
queuepoly(V, (eoh?shFloor:shPalaceFloor)[ct-6], darkena(xcol, fd, 0xFF));
|
|
|
|
else {
|
|
queuepoly(V, shFloor[ct-6], darkena(xcol, fd, 0xFF));
|
|
}
|
|
// walls
|
|
|
|
#ifndef MOBILE
|
|
if(cmode == emMapEditor && mapeditor::displaycodes) {
|
|
|
|
int labeli = mapeditor::displaycodes == 1 ? mapeditor::realpattern(c) : mapeditor::subpattern(c);
|
|
|
|
string label = its(labeli);
|
|
int siz = int(sqrt(squar(xc-xs)+squar(yc-ys))) / 5;
|
|
queuestr(xc, yc, sc, siz, label, 0xFFFFFFFF);
|
|
|
|
/* transmatrix V2 = V * applyPatterndir(c);
|
|
queuepoly(V2, shNecro, 0x80808080);
|
|
queuepoly(V2, shStatue, 0x80808080); */
|
|
}
|
|
#endif
|
|
|
|
if(realred(c->wall)) {
|
|
int s = snakelevel(c);
|
|
if(s >= 1)
|
|
queuepoly(V, shRedRockFloor[0][ct-6], darkena(winf[waRed1].color, 0, 0xFF));
|
|
if(s >= 2)
|
|
queuepoly(V, shRedRockFloor[1][ct-6], darkena(winf[waRed2].color, 0, 0xFF));
|
|
if(s >= 3)
|
|
queuepoly(V, shRedRockFloor[2][ct-6], darkena(winf[waRed3].color, 0, 0xFF));
|
|
}
|
|
|
|
if(pseudohept(c) && (c->land == laRedRock || (purehepta && (c->land == laClearing || isWarped(c))))) {
|
|
queuepoly(V, shHeptaMarker, 0x00000080);
|
|
}
|
|
|
|
if(conformal::includeHistory && eq(c->aitmp, sval-1))
|
|
queuepoly(V, shHeptaMarker, 0x000000C0);
|
|
|
|
/* if(c->land == laBarrier || c->land == laCrossroads2) {
|
|
int siz = int(sqrt(squar(xc-xs)+squar(yc-ys))) / 5;
|
|
displaystr(xc, yc, sc, siz, its(int(c->heat + .5)), 0xFFFFFFFF, 8);
|
|
} */
|
|
|
|
char xch = winf[c->wall].glyph;
|
|
|
|
if(c->wall == waSolidBranch) {
|
|
queuepoly(V, shSolidBranch, 0x804000FF);
|
|
}
|
|
|
|
else if(c->wall == waWeakBranch) {
|
|
queuepoly(V, shWeakBranch, 0x804000FF);
|
|
}
|
|
|
|
else if(c->wall == waLadder) {
|
|
if(euclid) {
|
|
queuepoly(V, shMFloor[ct-6], 0x804000FF);
|
|
queuepoly(V, shMFloor2[ct-6], 0x000000FF);
|
|
}
|
|
else {
|
|
queuepoly(V, shFloor[ct-6], 0x804000FF);
|
|
queuepoly(V, shMFloor[ct-6], 0x000000FF);
|
|
}
|
|
}
|
|
|
|
if(c->wall == waBoat || c->wall == waStrandedBoat) {
|
|
int hdir = displaydir(c, c->mondir);
|
|
transmatrix V2 = V * spin((42+hdir) * M_PI / 42);
|
|
if(items[itOrbWater] && (c == cwt.c || (isFriendly(c) && items[itOrbEmpathy]))) {
|
|
queuepoly(V2, shBoatOuter, watercolor(0));
|
|
queuepoly(V2, shBoatInner, 0x0060C0FF);
|
|
}
|
|
else {
|
|
queuepoly(V2, shBoatOuter, 0xC06000FF);
|
|
queuepoly(V2, shBoatInner, 0x804000FF);
|
|
}
|
|
}
|
|
|
|
else if(c->wall == waBigStatue)
|
|
queuepoly(V, shStatue,
|
|
darkena(winf[c->wall].color, 0, 0xFF)
|
|
);
|
|
|
|
else if(c->wall == waSulphurC) {
|
|
bool drawStar = true;
|
|
for(int t=0; t<c->type; t++)
|
|
if(c->mov[t] && c->mov[t]->wall != waSulphur && c->mov[t]->wall != waSulphurC &&
|
|
c->mov[t]->wall != waBarrier)
|
|
drawStar = false;
|
|
if(drawStar) queuepoly(V, shGiantStar[ct-6], darkena(xcol, 0, 0xFF));
|
|
}
|
|
|
|
else if(c->wall == waClosePlate || c->wall == waOpenPlate || (c->wall == waTrapdoor && c->land != laZebra)) {
|
|
transmatrix V2 = V;
|
|
if(ct == 7 && vid.wallmode == 3) V2 = V * spin(M_PI);
|
|
queuepoly(V2, shMFloor[ct-6], darkena(winf[c->wall].color, 0, 0xFF));
|
|
queuepoly(V2, shMFloor2[ct-6], vid.wallmode >= 2 ? darkena(xcol, 1, 0xFF) : darkena(0,1,0xFF));
|
|
}
|
|
|
|
else if(c->wall == waFrozenLake || c->wall == waLake || c->wall == waCamelotMoat ||
|
|
c->wall == waRoundTable || c->wall == waSea || c->wall == waClosePlate || c->wall == waOpenPlate ||
|
|
c->wall == waOpenGate || c->wall == waTrapdoor)
|
|
;
|
|
|
|
else if(c->wall == waRose) {
|
|
xcol <<= 1;
|
|
if(c->cpdist > 5)
|
|
xcol = 0xC0C0C0;
|
|
else if(rosephase == 7)
|
|
xcol = 0xFF0000;
|
|
else
|
|
xcol = gradient(xcol, 0xC00000, 0, rosephase, 6);
|
|
queuepoly(V, shThorns, 0xC080C0FF);
|
|
|
|
for(int u=0; u<4; u+=2)
|
|
queuepoly(V * spin(2*M_PI / 3 / 4 * u), shRose, darkena(xcol, 0, 0xC0));
|
|
}
|
|
|
|
else if(xch == '#') {
|
|
if(c->wall == waVinePlant)
|
|
xcol = 0x60C000;
|
|
if(c->wall != waPlatform && c->wall != waWarpGate)
|
|
queuepoly(V, shWall[ct-6], darkena(xcol, 0, 0xFF));
|
|
}
|
|
|
|
else if(c->wall == waFan) {
|
|
queuepoly(V * spin(M_PI/6 - fanframe * M_PI / 3), shFan, darkena(xcol, 0, 0xFF));
|
|
}
|
|
|
|
else if(xch == '%') {
|
|
if(doHighlight())
|
|
poly_outline = (c->land == laMirror) ? OUTLINE_TREASURE : OUTLINE_ORB;
|
|
queuepoly(V, shMirror, darkena(xcol, 0, 0xC0));
|
|
poly_outline = OUTLINE_NONE;
|
|
}
|
|
|
|
else if(isFire(c) || isThumper(c) || c->wall == waBonfireOff) {
|
|
ld sp = 0;
|
|
if(hasTimeout(c)) sp = ticks / (c->land == laPower ? 5000. : 500.);
|
|
queuepoly(V * spin(sp), shStar, darkena(col, 0, 0xF0));
|
|
}
|
|
|
|
else if(xch == '+' && (c->land == laGraveyard || isHaunted(c->land)) && c->wall != waFloorB && c->wall != waFloorA &&
|
|
c->wall != waFloorC && c->wall != waFloorD)
|
|
queuepoly(V, shCross, darkena(xcol, 0, 0xFF));
|
|
|
|
else if(xch == '+' && c->wall == waClosedGate) {
|
|
int hdir = 0;
|
|
for(int i=0; i<c->type; i++) if(c->mov[i]->wall == waClosedGate)
|
|
hdir = i;
|
|
hdir = displaydir(c, hdir);
|
|
transmatrix V2 = V * spin((42+hdir) * M_PI / 42);
|
|
queuepoly(V2, shPalaceGate, darkena(xcol, 0, 0xFF));
|
|
}
|
|
|
|
else if(xch == '+' && c->wall == waGiantRug) {
|
|
queuepoly(V, shBigCarpet1, darkena(0xC09F00, 0, 0xFF));
|
|
queuepoly(V, shBigCarpet2, darkena(0x600000, 0, 0xFF));
|
|
queuepoly(V, shBigCarpet3, darkena(0xC09F00, 0, 0xFF));
|
|
}
|
|
|
|
else if(xch != '.' && xch != '+' && xch != '>' && xch != ':' && xch != ';' && c->wall != waSulphur && xch != ',')
|
|
error = true;
|
|
|
|
/* if(c->master->alt) {
|
|
int d = celldistAlt(c);
|
|
int siz = int(sqrt(squar(xc-xs)+squar(yc-ys))) / 5;
|
|
if(d != ALTDIST_UNKNOWN && d != ALTDIST_BOUNDARY)
|
|
displaystr(xc, yc, sc, siz, its(d), 0xFFFFFFFF, 8);
|
|
} */
|
|
}
|
|
else if(!(it || c->monst || c->cpdist == 0)) error = true;
|
|
|
|
if(c->wall == waMineOpen) {
|
|
int mines = countMinesAround(c);
|
|
|
|
if(vid.wallmode == 0) {
|
|
if(ch == '.') {
|
|
if(mines == 0) ch = ' ';
|
|
else ch = '0' + mines, col = minecolors[mines];
|
|
}
|
|
else if(ch == '@') col = minecolors[mines];
|
|
}
|
|
else if(mines > 0)
|
|
queuepoly(V, shMineMark[c->type-6], (minecolors[mines] << 8) | 0xFF);
|
|
}
|
|
|
|
// treasure
|
|
|
|
char xch = iinf[it].glyph;
|
|
hpcshape *xsh =
|
|
it == itPirate ? &shPirateX :
|
|
(it == itBuggy || it == itBuggy2) ? &shPirateX :
|
|
it == itHolyGrail ? &shGrail :
|
|
isElementalShard(it) ? &shElementalShard :
|
|
xch == '*' ? &shGem[ct-6] : xch == '%' ? &shDaisy : xch == '$' ? &shStar : xch == ';' ? &shTriangle :
|
|
xch == '!' ? &shTriangle : it == itBone ? &shNecro : it == itStatue ? &shStatue :
|
|
it == itEdge ? &shFigurine :
|
|
xch == '?' ? &shBookCover :
|
|
it == itKey ? &shKey :
|
|
it == itRevolver ? &shGun :
|
|
NULL;
|
|
|
|
if(doHighlight()) {
|
|
int k = itemclass(it);
|
|
if(k == IC_TREASURE)
|
|
poly_outline = OUTLINE_TREASURE;
|
|
else if(k == IC_ORB)
|
|
poly_outline = OUTLINE_ORB;
|
|
else
|
|
poly_outline = OUTLINE_OTHER;
|
|
}
|
|
|
|
if(conformal::includeHistory && eq(c->aitmp, sval)) poly_outline = OUTLINE_DEAD;
|
|
|
|
#ifndef MOBILE
|
|
if(c == mapeditor::drawcell && mapeditor::drawcellShapeGroup() == 2)
|
|
mapeditor::drawtrans = V;
|
|
#endif
|
|
|
|
if(vid.monmode == 0 && it)
|
|
error = true;
|
|
|
|
else if(it == itBabyTortoise) {
|
|
int bits = tortoise::babymap[c];
|
|
tortoise::draw(V * spin(ticks / 5000.) * ypush(crossf*.15), bits, 2, 0);
|
|
// queuepoly(V, shHeptaMarker, darkena(tortoise::getMatchColor(bits), 0, 0xC0));
|
|
}
|
|
|
|
else if(it == itCompass) {
|
|
transmatrix V2 = V;
|
|
if(euclid) V2 = V2 * spin(M_PI/2);
|
|
else V2 = V2 * rspintox(inverse(V) * pirateCoords * C0);
|
|
V2 = V2 * spin(M_PI * sin(ticks/100.) / 30);
|
|
queuepoly(V2, shCompass1, 0xFF8080FF);
|
|
queuepoly(V2, shCompass2, 0xFFFFFFFF);
|
|
queuepoly(V2, shCompass3, 0xFF0000FF);
|
|
queuepoly(V2 * spin(M_PI), shCompass3, 0x000000FF);
|
|
xsh = NULL;
|
|
}
|
|
|
|
else if(it == itPalace) {
|
|
transmatrix V2 = V * spin(ticks / 1500.);
|
|
queuepoly(V2, shMFloor3[ct-6], 0xFFD500FF);
|
|
queuepoly(V2, shMFloor4[ct-6], darkena(icol, 0, 0xFF));
|
|
queuepoly(V2, shGem[ct-6], 0xFFD500FF);
|
|
xsh = NULL;
|
|
}
|
|
|
|
else if(drawUserShape(V, 2, it, darkena(icol, 0, 0xFF))) ;
|
|
|
|
else if(it == itRose) {
|
|
for(int u=0; u<4; u++)
|
|
queuepoly(V * spin(ticks / 1500.) * spin(2*M_PI / 3 / 4 * u), shRose, darkena(icol, 0, hidden ? 0x30 : 0xA0));
|
|
}
|
|
|
|
else if(xsh) {
|
|
if(it == itFireShard) icol = firecolor(100);
|
|
if(it == itWaterShard) icol = watercolor(100) >> 8;
|
|
|
|
if(it == itZebra) icol = 0x202020;
|
|
if(it == itLotus) icol = 0x101010;
|
|
|
|
queuepoly(V * spin(ticks / 1500.), *xsh, darkena(icol, 0, hidden ? 0x40 : 0xF0));
|
|
|
|
if(xsh == &shBookCover && vid.monmode)
|
|
queuepoly(V * spin(ticks / 1500.), shBook, 0x805020FF);
|
|
if(it == itZebra)
|
|
queuepoly(V * spin(ticks / 1500. + M_PI/c->type), *xsh, darkena(0xFFFFFF, 0, hidden ? 0x40 : 0xF0));
|
|
}
|
|
|
|
else if(xch == 'o') {
|
|
if(it == itOrbFire) icol = firecolor(100);
|
|
queuepoly(V, shDisk, darkena(icol, 0, hidden ? 0x20 : 0xC0));
|
|
if(it == itOrbFire) icol = firecolor(200);
|
|
if(it == itOrbFriend || it == itOrbDiscord) icol = 0xC0C0C0;
|
|
if(it == itOrbFrog) icol = 0xFF0000;
|
|
if(it == itOrbFreedom) icol = 0xC0FF00;
|
|
if(it == itOrbAir) icol = 0xFFFFFF;
|
|
if(it == itOrbUndeath) icol = minf[moFriendlyGhost].color;
|
|
hpcshape& sh =
|
|
isRangedOrb(it) ? shTargetRing :
|
|
isOffensiveOrb(it) ? shSawRing :
|
|
isFriendOrb(it) ? shPeaceRing :
|
|
isUtilityOrb(it) ? shGearRing :
|
|
it == itOrb37 ? shHeptaRing :
|
|
shRing;
|
|
queuepoly(V * spin(ticks / 1500.), sh, darkena(icol, 0, int(0x80 + 0x70 * sin(ticks / 300.))));
|
|
}
|
|
|
|
else if(it) error = true;
|
|
|
|
|
|
|
|
// monsters
|
|
|
|
if(flashat > 0 && c == flashcell) {
|
|
int tim = ticks - flashat;
|
|
if(tim > 1000) flashat = 0;
|
|
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 *= hexf;
|
|
int col = iinf[itOrbFlash].color;
|
|
if(u > 500) col = gradient(col, 0, 500, u, 1100);
|
|
for(int a=0; a<84; a++)
|
|
queueline(V*ddi(a, rad)*C0, V*ddi(a+1, rad)*C0, col);
|
|
}
|
|
}
|
|
|
|
if(bigflashat > 0 && c == flashcell) {
|
|
int tim = ticks - bigflashat;
|
|
if(tim > 2000) bigflashat = 0;
|
|
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 *= hexf;
|
|
int col = 0xC0FF00;
|
|
if(u > 1000) col = gradient(col, 0, 1000, u, 2200);
|
|
for(int a=0; a<84; a++)
|
|
queueline(V*ddi(a, rad)*C0, V*ddi(a+1, rad)*C0, col);
|
|
}
|
|
}
|
|
|
|
error |= drawMonster(V, ct, c, col);
|
|
|
|
int ad = airdist(c);
|
|
if(ad == 1 || ad == 2) {
|
|
|
|
for(int i=0; i<c->type; i++) {
|
|
cell *c2 = c->mov[i];
|
|
if(airdist(c2) < airdist(c)) {
|
|
calcAirdir(c2); // printf("airdir = %d\n", airdir);
|
|
int hdir = displaydir(c, i);
|
|
transmatrix V0 = spin((42+hdir) * M_PI / 42);
|
|
|
|
double ph = ticks / 75.0 + airdir * M_PI / 21.;
|
|
|
|
int aircol = 0x8080FF00 | int(32 + 32 * -cos(ph));
|
|
|
|
double ph0 = ph/2;
|
|
ph0 -= floor(ph0/M_PI)*M_PI;
|
|
|
|
poly_outline = 0;
|
|
queuepoly(V*V0*ddi(0, hexf*-cos(ph0)), shDisk, aircol);
|
|
poly_outline = OUTLINE_NONE;
|
|
}
|
|
}
|
|
|
|
// queuepoly(V*ddi(rand() % 84, hexf*(rand()%100)/100), shDisk, aircolor(airdir));
|
|
}
|
|
|
|
/* int rd = rosedist(c);
|
|
if(rd > 0 && ((rd&7) == (turncount&7))) {
|
|
|
|
for(int i=0; i<c->type; i++) {
|
|
cell *c2 = c->mov[i];
|
|
if(rosedist(c2) == rosedist(c)-1) {
|
|
int hdir = displaydir(c, i);
|
|
transmatrix V0 = spin((42+hdir) * M_PI / 42);
|
|
|
|
double ph = ticks / 75.0; // + airdir * M_PI / 21.;
|
|
|
|
int rosecol = 0x764e7c00 | int(32 + 32 * -cos(ph));
|
|
|
|
double ph0 = ph/2;
|
|
ph0 -= floor(ph0/M_PI)*M_PI;
|
|
|
|
poly_outline = 0;
|
|
queuepoly(V*V0*ddi(0, hexf*-cos(ph0)), shDisk, rosecol);
|
|
poly_outline = 0xFF;
|
|
}
|
|
}
|
|
} */
|
|
|
|
if(c->land == laWhirlwind) {
|
|
whirlwind::calcdirs(c);
|
|
|
|
for(int i=0; i<whirlwind::qdirs; i++) {
|
|
int hdir0 = displaydir(c, whirlwind::dfrom[i]) + 42;
|
|
int hdir1 = displaydir(c, whirlwind::dto[i]);
|
|
|
|
double ph1 = fanframe;
|
|
|
|
int aircol = 0xC0C0FF40;
|
|
|
|
ph1 -= floor(ph1);
|
|
|
|
if(hdir1 < hdir0-42) hdir1 += 84;
|
|
if(hdir1 >= hdir0+42) hdir1 -= 84;
|
|
|
|
int hdir = (hdir1*ph1+hdir0*(1-ph1));
|
|
|
|
transmatrix V0 = spin((hdir) * M_PI / 42);
|
|
|
|
double ldist = purehepta ? crossf : c->type == 6 ? .2840 : 0.3399;
|
|
|
|
poly_outline = 0;
|
|
queuepoly(V*V0*ddi(0, ldist*(2*ph1-1)), shDisk, aircol);
|
|
poly_outline = OUTLINE_NONE;
|
|
}
|
|
|
|
// queuepoly(V*ddi(rand() % 84, hexf*(rand()%100)/100), shDisk, aircolor(airdir));
|
|
}
|
|
|
|
/* if(ch == '.') {
|
|
col = darkened(col);
|
|
for(int t=0; t<ct; t++)
|
|
queueline(V*ddi(t*84/ct, hexf/3)*C0, V*ddi((t+1)*84/ct, hexf/3)*C0, col);
|
|
}
|
|
|
|
else if(ch == '#') {
|
|
col = darkened(col);
|
|
for(int u=1; u<6; u++)
|
|
for(int t=0; t<ct; t++)
|
|
queueline(V*ddi(0 + t*84/ct, u*hexf/6)*C0, V*ddi(0 + (t+1)*84/ct, u*hexf/6)*C0, col);
|
|
}
|
|
|
|
else */
|
|
|
|
if(error) {
|
|
int siz = int(sqrt(squar(xc-xs)+squar(yc-ys)));
|
|
|
|
if(c->wall == waSea) col = xcol;
|
|
|
|
queuechr(xc, yc, sc, siz, ch, col, 2);
|
|
}
|
|
|
|
if(c == dragon::target && getMount()) {
|
|
queuechr(xc, yc, sc, 2*vid.fsize, 'X',
|
|
gradient(0, iinf[itOrbDomination].color, -1, sin(ticks/(dragon::whichturn == turncount ? 75. : 150.)), 1));
|
|
}
|
|
|
|
if(c == keycell) {
|
|
queuechr(xc, yc, sc, 2*vid.fsize, 'X', 0x10101 * int(128 + 100 * sin(ticks / 150.)));
|
|
queuestr(xc, yc, sc, vid.fsize, its(keycelldist), 0x10101 * int(128 - 100 * sin(ticks / 150.)));
|
|
}
|
|
|
|
if(c == pirateTreasureFound) {
|
|
pirateCoords = V;
|
|
if(showPirateX) {
|
|
queuechr(xc, yc, sc, 2*vid.fsize, 'X', 0x10100 * int(128 + 100 * sin(ticks / 150.)));
|
|
if(cwt.c->master->alt)
|
|
queuestr(xc, yc, sc, vid.fsize, its(-celldistAlt(cwt.c)), 0x10101 * int(128 - 100 * sin(ticks / 150.)));
|
|
}
|
|
}
|
|
|
|
if(!euclid && (!pirateTreasureSeek || compassDist(c) < compassDist(pirateTreasureSeek)))
|
|
pirateTreasureSeek = c;
|
|
|
|
if(!euclid) {
|
|
bool usethis = false;
|
|
double spd = 1;
|
|
|
|
if(isGravityLand(cwt.c->land)) {
|
|
if(!straightDownSeek || edgeDepth(c) < edgeDepth(straightDownSeek)) {
|
|
usethis = true;
|
|
spd = cwt.c->landparam / 10.;
|
|
}
|
|
}
|
|
|
|
if(pmodel) {
|
|
if(c->master->alt && cwt.c->master->alt &&
|
|
(cwt.c->land == laTemple || cwt.c->land == laWhirlpool ||
|
|
(cheater && (cwt.c->land == laClearing || cwt.c->land == laCaribbean ||
|
|
cwt.c->land == laCamelot || cwt.c->land == laPalace)))
|
|
&& c->land == cwt.c->land && c->master->alt->alt == cwt.c->master->alt->alt) {
|
|
if(!straightDownSeek || celldistAlt(c) < celldistAlt(straightDownSeek)) {
|
|
usethis = true;
|
|
spd = .5;
|
|
}
|
|
}
|
|
|
|
if(cwt.c->land == laOcean && cwt.c->landparam < 25) {
|
|
if(!straightDownSeek || coastval(c, laOcean) < coastval(straightDownSeek, laOcean)) {
|
|
usethis = true;
|
|
spd = cwt.c->landparam / 10;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if(usethis) {
|
|
straightDownSeek = c;
|
|
downspin = atan2(VC0[1], VC0[0]) - M_PI/2;
|
|
downspin += M_PI/2 * (conformal::rotation%4);
|
|
while(downspin < -M_PI) downspin += 2*M_PI;
|
|
while(downspin > +M_PI) downspin -= 2*M_PI;
|
|
downspin = downspin * min(spd, (double)1);
|
|
// queuechr(xc, yc, sc, 2*vid.fsize, 'X', 0x10100 * int(128 + 100 * sin(ticks / 150.)));
|
|
}
|
|
}
|
|
|
|
|
|
if(!inHighQual) {
|
|
|
|
#if defined(ANDROID) || defined(PANDORA) || defined(IOS)
|
|
if(c == lmouseover && (mousepressed || ISANDROID || ISMOBILE)) {
|
|
queuecircle(xc, yc, int(sqrt(squar(xc-xs)+squar(yc-ys)) * .8), c->cpdist > 1 ? 0x00FFFF : 0xFF0000);
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
if(cmode == emMapEditor && !mapeditor::subscreen && lmouseover &&
|
|
(mapeditor::whichPattern ? mapeditor::subpattern(c) == mapeditor::subpattern(lmouseover) : c == lmouseover)) {
|
|
queuecircle(xc, yc, int(sqrt(squar(xc-xs)+squar(yc-ys)) * .8), 0x00FFFF);
|
|
}
|
|
#endif
|
|
|
|
if(joydir.d >= 0 && c == cwt.c->mov[(joydir.d+cwt.spin) % cwt.c->type])
|
|
queuecircle(xc, yc, int(sqrt(squar(xc-xs)+squar(yc-ys)) * (.78 - .02 * sin(ticks/199.0))), 0x00FF00);
|
|
|
|
#ifndef MOBILE
|
|
if(c == lcenterover && !playermoved && netgen::mode == 0 && !conformal::on)
|
|
queuecircle(xc, yc, int(sqrt(squar(xc-xs)+squar(yc-ys)) * (.70 - .06 * sin(ticks/200.0))), int(175 + 25 * sin(ticks / 200.0)));
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
mapeditor::drawGhosts(c, V, ct);
|
|
#endif
|
|
}
|
|
|
|
// process mouse
|
|
|
|
if(c == cwt.c) curcell = V;
|
|
for(int i=0; i<cwt.c->type; i++)
|
|
if(c == cwt.c->mov[i]) movecell[i] = V;
|
|
|
|
// drawline(V*C0, V*Crad[0], 0xC00000);
|
|
if(c->bardir != NODIR && c->bardir != NOBARRIERS && c->land != laHauntedWall &&
|
|
c->barleft != NOWALLSEP_USED) {
|
|
queueline(V*C0, V*heptmove[c->bardir]*C0, 0x505050 >> darken);
|
|
queueline(V*C0, V*hexmove[c->bardir]*C0, 0x505050 >> darken);
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
netgen::buildVertexInfo(c, V);
|
|
rug::buildVertexInfo(c, V);
|
|
#endif
|
|
|
|
#ifdef LOCAL
|
|
extern void localdraw (const transmatrix& V, cell *c);
|
|
localdraw(V, c);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
string buildCredits();
|
|
|
|
string buildHelpText() {
|
|
DEBB(DF_GRAPH, (debugfile,"buildHelpText\n"));
|
|
string h;
|
|
h += XLAT("Welcome to HyperRogue");
|
|
#ifdef ANDROID
|
|
h += XLAT(" for Android");
|
|
#endif
|
|
#ifdef IOS
|
|
h += XLAT(" for iOS");
|
|
#endif
|
|
h += XLAT("! (version %1)\n\n", VER);
|
|
|
|
h += XLAT(
|
|
"You have been trapped in a strange, non-Euclidean world. Collect as much treasure as possible "
|
|
"before being caught by monsters. The more treasure you collect, the more "
|
|
"monsters come to hunt you, as long as you are in the same land type. The "
|
|
"Orbs of Yendor are the ultimate treasure; get at least one of them to win the game!"
|
|
);
|
|
h += XLAT(" (press ESC for some hints about it).");
|
|
h += "\n\n";
|
|
|
|
h += XLAT(
|
|
"You can fight most monsters by moving into their location. "
|
|
"The monster could also kill you by moving into your location, but the game "
|
|
"automatically cancels all moves which result in that.\n\n"
|
|
);
|
|
#ifdef MOBILE
|
|
h += XLAT(
|
|
"Usually, you move by touching somewhere on the map; you can also touch one "
|
|
"of the four buttons on the map corners to change this (to scroll the map "
|
|
"or get information about map objects). You can also touch the "
|
|
"numbers displayed to get their meanings.\n"
|
|
);
|
|
#else
|
|
h += XLAT(
|
|
"Move with mouse, num pad, qweadzxc, or hjklyubn. Wait by pressing 's' or '.'. Spin the world with arrows, PageUp/Down, and Home/Space. "
|
|
"To save the game you need an Orb of Safety. Press 'v' for config, ESC for the quest status and menu.\n\n"
|
|
);
|
|
h += XLAT(
|
|
"You can right click any element to get more information about it.\n\n"
|
|
);
|
|
#endif
|
|
h += XLAT("See more on the website: ")
|
|
+ "http//roguetemple.com/z/hyper.php\n\n";
|
|
|
|
|
|
h += XLAT("Still confused? Read the FAQ on the HyperRogue website!\n\n");
|
|
|
|
#ifdef MOBILE
|
|
h += buildCredits();
|
|
#else
|
|
h += XLAT("Press 'c' for credits.");
|
|
#endif
|
|
return h;
|
|
}
|
|
|
|
string musiclicense;
|
|
|
|
string buildCredits() {
|
|
string h;
|
|
h += XLAT("game design, programming, texts and graphics by Zeno Rogue <zeno@attnam.com>\n\n");
|
|
if(lang() != 0)
|
|
h += XLAT("add credits for your translation here");
|
|
#ifndef NOLICENSE
|
|
h += XLAT(
|
|
"released under GNU General Public License version 2 and thus "
|
|
"comes with absolutely no warranty; see COPYING for details\n\n"
|
|
);
|
|
#endif
|
|
h += XLAT(
|
|
"special thanks to the following people for their bug reports, feature requests, porting, and other help:\n\n%1\n\n",
|
|
"Konstantin Stupnik, ortoslon, chrysn, Adam Borowski, Damyan Ivanov, Ryan Farnsley, mcobit, Darren Grey, tricosahedron, Maciej Chojecki, Marek Čtrnáct, "
|
|
"wonderfullizardofoz, Piotr Migdał, tehora, Michael Heerdegen, Sprite Guard, zelda0x181e, Vipul, snowyowl0, Patashu"
|
|
);
|
|
#ifdef EXTRALICENSE
|
|
h += EXTRALICENSE;
|
|
#endif
|
|
if(musiclicense != "") h += musiclicense;
|
|
return h;
|
|
}
|
|
|
|
string pushtext(stringpar p) {
|
|
string s = XLAT(
|
|
"\n\nNote: when pushing %the1 off a heptagonal cell, you can control the pushing direction "
|
|
"by clicking left or right half of the heptagon.", p);
|
|
#ifndef MOBILE
|
|
s += XLAT(" With the keyboard, you can rotate the view for a similar effect (Page Up/Down).");
|
|
#endif
|
|
return s;
|
|
}
|
|
|
|
string princedesc() {
|
|
if(princessgender() == GEN_M)
|
|
return XLAT("Apparently a prince is kept locked somewhere, but you won't ever find him in this hyperbolic palace. ");
|
|
else
|
|
return XLAT("Apparently a princess is kept locked somewhere, but you won't ever find her in this hyperbolic palace. ");
|
|
}
|
|
|
|
string generateHelpForItem(eItem it) {
|
|
string help = XLAT(iinf[it].help);
|
|
#ifdef ANDROID
|
|
if(it == itOrbSafety)
|
|
help += XLAT("This might be useful for Android devices with limited memory.");
|
|
#else
|
|
if(it == itOrbSafety)
|
|
help += XLAT("Thus, it is potentially useful for extremely long games, which would eat all the memory on your system otherwise.\n");
|
|
#endif
|
|
#ifndef MOBILE
|
|
if(isRangedOrb(it))
|
|
help += XLAT("You can also scroll to the desired location and then press 't'.");
|
|
#endif
|
|
#ifdef MOBILE
|
|
if(it == itGreenStone)
|
|
help += XLAT("You can touch the Dead Orb in your inventory to drop it.");
|
|
#else
|
|
if(it == itGreenStone)
|
|
help += XLAT("You can press 'g' or click them in the list to drop a Dead Orb.");
|
|
#endif
|
|
if(it == itOrbEmpathy) {
|
|
int cnt = 0;
|
|
for(int i=0; i<ittypes; i++) {
|
|
eItem it2 = eItem(i);
|
|
if(isEmpathyOrb(it2)) {
|
|
help += XLAT(cnt ? ", %1" : " %1", it2);
|
|
cnt++;
|
|
}
|
|
}
|
|
}
|
|
return help;
|
|
}
|
|
|
|
string generateHelpForWall(eWall w) {
|
|
string s = XLAT(winf[w].help);
|
|
if(isThumper(w)) s += pushtext(w);
|
|
if((w == waClosePlate || w == waOpenPlate) && purehepta)
|
|
s += "\n\n(For the heptagonal mode, the radius has been reduced to 2 for closing plates.)";
|
|
return s;
|
|
}
|
|
|
|
string generateHelpForMonster(eMonster m) {
|
|
string s = XLAT(minf[m].help);
|
|
if(m == moPalace || m == moSkeleton)
|
|
s += pushtext(m);
|
|
if(m == moTroll) s += XLAT(trollhelp2);
|
|
|
|
if(isMonsterPart(m))
|
|
s += XLAT("\n\nThis is a part of a monster. It does not count for your total kills.", m);
|
|
|
|
if(isFriendly(m))
|
|
s += XLAT("\n\nThis is a friendly being. It does not count for your total kills.", m);
|
|
|
|
if(m == moTortoise)
|
|
s += XLAT("\n\nTortoises are not monsters! They are just annoyed. They do not count for your total kills.", m);
|
|
|
|
if(isGhost(m))
|
|
s += XLAT("\n\nA Ghost never moves to a cell which is adjacent to another Ghost of the same kind.", m);
|
|
|
|
return s;
|
|
}
|
|
|
|
string generateHelpForLand(eLand l) {
|
|
string s = XLAT(linf[l].help);
|
|
|
|
if(l == laPalace) s = princedesc() + s;
|
|
|
|
s += "\n\n";
|
|
if(l == laIce || l == laCaves || l == laDesert || l == laMotion || l == laJungle ||
|
|
l == laCrossroads || l == laAlchemist)
|
|
s += XLAT("Always available.\n");
|
|
|
|
#define ACCONLY(z) s += XLAT("Accessible only from %the1.\n", z);
|
|
#define ACCONLY2(z,x) s += XLAT("Accessible only from %the1 or %the2.\n", z, x);
|
|
#define ACCONLYF(z) s += XLAT("Accessible only from %the1 (until finished).\n", z);
|
|
#define TREQ(z) s += XLAT("Treasure required: %1 $$$.\n", #z);
|
|
#define TREQ2(z,x) s += XLAT("Treasure required: %1 x %2.\n", #z, x);
|
|
|
|
if(l == laMirror || l == laMinefield || l == laPalace ||
|
|
l == laOcean || l == laLivefjord || l == laZebra || l == laGridCoast || l == laGridSea)
|
|
TREQ(30)
|
|
|
|
if(l == laCaribbean || l == laWhirlpool) ACCONLY(laOcean)
|
|
if(l == laRlyeh) ACCONLYF(laOcean)
|
|
if(l == laTemple) ACCONLY(laRlyeh)
|
|
if(l == laClearing) ACCONLY(laOvergrown)
|
|
if(l == laHaunted) ACCONLY(laGraveyard)
|
|
if(l == laPrincessQuest) ACCONLY(laPalace)
|
|
if(l == laCamelot) ACCONLY2(laCrossroads, laCrossroads3)
|
|
|
|
if(l == laDryForest || l == laWineyard || l == laDeadCaves || l == laHive || l == laRedRock ||
|
|
l == laOvergrown || l == laStorms || l == laWhirlwind || l == laRose)
|
|
TREQ(60)
|
|
|
|
if(l == laIvoryTower) TREQ(30)
|
|
if(l == laIvoryTower) TREQ2(10, itElixir)
|
|
if(l == laEndorian) TREQ2(10, itEdge)
|
|
|
|
if(l == laCrossroads4) TREQ(200)
|
|
|
|
if(l == laGraveyard || l == laHive)
|
|
s += XLAT("Kills required: %1.\n", "100");
|
|
|
|
if(l == laDragon)
|
|
s += XLAT("Different kills required: %1.\n", "20");
|
|
|
|
if(l == laTortoise) ACCONLY(laDragon)
|
|
if(l == laTortoise) s += XLAT("Find a %1 in %the2.", itBabyTortoise, laDragon);
|
|
|
|
if(l == laHell || l == laCrossroads3)
|
|
s += XLAT("Finished lands required: %1 (collect 10 treasure)\n", "9");
|
|
|
|
if(l == laCocytus || l == laPower) TREQ2(10, itHell)
|
|
if(l == laRedRock) TREQ2(10, itSpice)
|
|
if(l == laOvergrown) TREQ2(10, itRuby)
|
|
if(l == laClearing) TREQ2(5, itMutant)
|
|
if(l == laCocytus) TREQ2(10, itDiamond)
|
|
if(l == laDeadCaves) TREQ2(10, itGold)
|
|
if(l == laTemple) TREQ2(5, itStatue)
|
|
if(l == laHaunted) TREQ2(10, itBone)
|
|
if(l == laCamelot) TREQ2(5, itEmerald)
|
|
if(l == laEmerald) {
|
|
TREQ2(5, itFernFlower) TREQ2(5, itGold)
|
|
s += XLAT("Alternatively: kill a %1 in %the2.\n", moVizier, laPalace);
|
|
}
|
|
|
|
if(l == laPrincessQuest)
|
|
s += XLAT("Kills required: %1.\n", moVizier);
|
|
|
|
if(l == laElementalWall) {
|
|
s += XLAT("Kills required: %1 (%2).\n", moFireElemental, laDragon);
|
|
s += XLAT("Kills required: %1 (%2).\n", moEarthElemental, laDeadCaves);
|
|
s += XLAT("Kills required: %1 (%2).\n", moWaterElemental, laLivefjord);
|
|
s += XLAT("Kills required: %1 (%2).\n", moAirElemental, laWhirlwind);
|
|
}
|
|
|
|
if(l == laZebra) TREQ2(10, itFeather)
|
|
|
|
int rl = isRandland(l);
|
|
if(rl == 2)
|
|
s += XLAT("Variants of %the1 are always available in the Random Pattern Mode.", l);
|
|
else if(rl == 1)
|
|
s += XLAT(
|
|
"Variants of %the1 are available in the Random Pattern Mode after "
|
|
"getting a highscore of at least 10 %2.", l, treasureType(l));
|
|
|
|
return s;
|
|
}
|
|
|
|
void describeMouseover() {
|
|
DEBB(DF_GRAPH, (debugfile,"describeMouseover\n"));
|
|
|
|
#ifdef LOCAL
|
|
if(localDescribe()) return;
|
|
#endif
|
|
|
|
cell *c = mousing ? mouseover : playermoved ? NULL : centerover;
|
|
string out = mouseovers;
|
|
if(!c) { }
|
|
else if(cmode == emNormal || cmode == emQuit || cmode == emMapEditor) {
|
|
out = XLAT1(linf[c->land].name);
|
|
help = generateHelpForLand(c->land);
|
|
|
|
// Celsius
|
|
|
|
// if(c->land == laIce) out = "Icy Lands (" + fts(60 * (c->heat - .4)) + " C)";
|
|
if(c->land == laIce || c->land == laCocytus)
|
|
out += " (" + fts(heat::celsius(c)) + " °C)";
|
|
if(c->land == laDryForest && c->landparam)
|
|
out += " (" + its(c->landparam)+"/10)";
|
|
if(c->land == laOcean && chaosmode)
|
|
out += " (" + its(c->CHAOSPARAM)+"S"+its(c->SEADIST)+"L"+its(c->LANDDIST)+")";
|
|
else if(c->land == laOcean && c->landparam <= 25)
|
|
out += " (" + its(c->landparam)+")";
|
|
|
|
if(c->land == laTortoise && tortoise::seek()) out += " " + tortoise::measure(getBits(c));
|
|
|
|
/* if(c->land == laGraveyard || c->land == laHauntedBorder || c->land == laHaunted)
|
|
out += " (" + its(c->landparam)+")"; */
|
|
|
|
if(buggyGeneration) {
|
|
char buf[20]; sprintf(buf, " H=%d M=%d", c->landparam, c->mpdist); out += buf;
|
|
}
|
|
|
|
// if(c->land == laBarrier)
|
|
// out += "(" + string(linf[c->barleft].name) + " / " + string(linf[c->barright].name) + ")";
|
|
|
|
// out += "(" + its(c->bardir) + ":" + string(linf[c->barleft].name) + " / " + string(linf[c->barright].name) + ")";
|
|
|
|
// out += " MD"+its(c->mpdist);
|
|
|
|
// out += " WP:" + its(c->wparam);
|
|
// out += " rose:" + its(rosemap[c]/4) + "." + its(rosemap[c]%4);
|
|
// out += " MP:" + its(c->mpdist);
|
|
// out += " cda:" + its(celldistAlt(c));
|
|
|
|
/* out += " DP=" + its(celldistance(c, cwt.c));
|
|
out += " DO=" + its(celldist(c));
|
|
out += " PD=" + its(c->pathdist); */
|
|
if(webdisplay & 8) {
|
|
|
|
out += " LP:" + its(c->landparam)+"/"+its(turncount);
|
|
|
|
char zz[64]; sprintf(zz, " P%p", c); out += zz;
|
|
// out += " rv" + its(rosedist(c));
|
|
// if(rosemap.count(c))
|
|
// out += " rv " + its(rosemap[c]/8) + "." + its(rosemap[c]%8);
|
|
// out += " ai" + its(c->aitmp);
|
|
if(euclid) {
|
|
for(int i=0; i<4; i++) out += " " + its(getEuclidCdata(c->master)->val[i]);
|
|
out += " " + itsh(getBits(c));
|
|
}
|
|
else {
|
|
for(int i=0; i<4; i++) out += " " + its(getHeptagonCdata(c->master)->val[i]);
|
|
// out += " " + itsh(getHeptagonCdata(c->master)->bits);
|
|
out += " " + fts(tortoise::getScent(getBits(c)));
|
|
}
|
|
// itsh(getHeptagonCdata(c->master)->bits);
|
|
// out += " barleft: " + s0 + dnameof(c->barleft);
|
|
// out += " barright: " + s0 + dnameof(c->barright);
|
|
}
|
|
|
|
// char zz[64]; sprintf(zz, " P%p", c); out += zz;
|
|
|
|
/* whirlwind::calcdirs(c);
|
|
for(int i=0; i<whirlwind::qdirs; i++)
|
|
out += " " + its(whirlwind::dfrom[i]) + ":" + its(whirlwind::dto[i]); */
|
|
// out += " : " + its(whirlwinddir(c));
|
|
|
|
|
|
|
|
if(randomPatternsMode)
|
|
out += " " + describeRPM(c->land);
|
|
|
|
if(euclid && cheater) {
|
|
eucoord x, y;
|
|
decodeMaster(c->master, x, y);
|
|
out += " ("+its(short(x))+","+its(short(y))+")";
|
|
}
|
|
|
|
// char zz[64]; sprintf(zz, " P%d", princess::dist(c)); out += zz;
|
|
// out += " MD"+its(c->mpdist);
|
|
// out += " H "+its(c->heat);
|
|
// if(c->type == 7) out += " Z"+its(c->master->zebraval);
|
|
// out += " H"+its(c->heat);
|
|
|
|
/* // Hive debug
|
|
if(c->land == laHive) {
|
|
out += " [" + its(c->tmp) + " H" + its(int(c->heat));
|
|
if(c->tmp >= 0 && c->tmp < size(buginfo) && buginfo[c->tmp].where == c) {
|
|
buginfo_t b(buginfo[c->tmp]);
|
|
for(int k=0; k<3; k++) out += ":" + its(b.dist[k]);
|
|
for(int k=0; k<3; k++)
|
|
for(int i=0; i<size(bugqueue[k]); i++)
|
|
if(bugqueue[k][i] == c->tmp)
|
|
out += " B"+its(k)+":"+its(i);
|
|
}
|
|
out += "]";
|
|
} */
|
|
|
|
if(c->wall &&
|
|
!((c->wall == waFloorA || c->wall == waFloorB || c->wall == waFloorC || c->wall == waFloorD) && c->item)) {
|
|
out += ", "; out += XLAT1(winf[c->wall].name);
|
|
|
|
if(c->wall == waRose) out += " (" + its(7-rosephase) + ")";
|
|
|
|
if((c->wall == waBigTree || c->wall == waSmallTree) && c->land != laDryForest)
|
|
help =
|
|
"Trees in this forest can be cut down. Big trees take two turns to cut down.";
|
|
else if(c->wall != waSea && c->wall != waPalace)
|
|
if(!((c->wall == waCavefloor || c->wall == waCavewall) && c->land == laEmerald))
|
|
help = generateHelpForWall(c->wall);
|
|
}
|
|
|
|
if(isActivable(c)) out += XLAT(" (touch to activate)");
|
|
|
|
if(hasTimeout(c)) out += XLAT(" [%1 turns]", its(c->wparam));
|
|
|
|
if(c->monst) {
|
|
out += ", "; out += XLAT1(minf[c->monst].name);
|
|
if(hasHitpoints(c->monst))
|
|
out += " (" + its(c->hitpoints)+" HP)";
|
|
if(isMutantIvy(c))
|
|
out += " (" + its((c->stuntime - mutantphase) & 15) + "*)";
|
|
else if(c->stuntime)
|
|
out += " (" + its(c->stuntime) + "*)";
|
|
|
|
if(c->monst == moTortoise && tortoise::seek())
|
|
out += " " + tortoise::measure(tortoise::getb(c));
|
|
|
|
help = generateHelpForMonster(c->monst);
|
|
}
|
|
|
|
if(c->item && !itemHiddenFromSight(c)) {
|
|
out += ", ";
|
|
out += XLAT1(iinf[c->item].name);
|
|
if(c->item == itBabyTortoise && tortoise::seek())
|
|
out += " " + tortoise::measure(tortoise::babymap[c]);
|
|
if(!c->monst) help = generateHelpForItem(c->item);
|
|
}
|
|
|
|
if(c == cwt.c && !shmup::on) out += XLAT(", you");
|
|
|
|
if(shmup::mousetarget && intval(mouseh, shmup::mousetarget->pat*C0) < .1) {
|
|
out += ", "; out += XLAT1(minf[shmup::mousetarget->type].name);
|
|
help = XLAT(minf[shmup::mousetarget->type].help);
|
|
/* char buf[64];
|
|
sprintf(buf, "%Lf", intval(mouseh, shmup::mousetarget->pat*C0));
|
|
mouseovers = mouseovers + " D: " + buf;
|
|
printf("ms = %s\n", mouseovers.c_str());*/
|
|
}
|
|
|
|
if(rosedist(c) == 1)
|
|
out += ", wave of scent (front)";
|
|
|
|
if(rosedist(c) == 2)
|
|
out += ", wave of scent (back)";
|
|
|
|
if(rosedist(c) || c->land == laRose || c->wall == waRose)
|
|
help += s0 + "\n\n" + rosedesc;
|
|
|
|
if(isWarped(c) && !isWarped(c->land))
|
|
out += ", warped";
|
|
|
|
if(isWarped(c))
|
|
help += s0 + "\n\n" + warpdesc;
|
|
|
|
}
|
|
else if(cmode == emVisual1) {
|
|
if(getcstat == 'p') {
|
|
out = XLAT("0 = Klein model, 1 = Poincaré model");
|
|
if(vid.alpha < -0.5)
|
|
out = XLAT("you are looking through it!");
|
|
if(vid.alpha > 5)
|
|
out = XLAT("(press 'i' to approach infinity (Gans model)");
|
|
}
|
|
else if(getcstat == 'r') {
|
|
out = XLAT("simply resize the window to change resolution");
|
|
}
|
|
else if(getcstat == 'f') {
|
|
out = XLAT("[+] keep the window size, [-] use the screen resolution");
|
|
}
|
|
else if(getcstat == 'a' && vid.aspeed > -4.99)
|
|
out = XLAT("+5 = center instantly, -5 = do not center the map");
|
|
else if(getcstat == 'a')
|
|
out = XLAT("press Space or Home to center on the PC");
|
|
else if(getcstat == 'w')
|
|
out = XLAT("also hold Alt during the game to toggle high contrast");
|
|
else if(getcstat == 'w' || getcstat == 'm')
|
|
out = XLAT("You can choose one of the several modes");
|
|
else if(getcstat == 'c')
|
|
out = XLAT("The axes help with keyboard movement");
|
|
else if(getcstat == 'g')
|
|
out = XLAT("Affects looks and grammar");
|
|
#ifndef MOBILE
|
|
else if(getcstat == 's')
|
|
out = XLAT("Config file: %1", conffile);
|
|
#endif
|
|
else out = "";
|
|
}
|
|
else if(cmode == emVisual2) {
|
|
if(getcstat == 'p') {
|
|
if(autojoy)
|
|
out = XLAT("joystick mode: automatic (release the joystick to move)");
|
|
if(!autojoy)
|
|
out = XLAT("joystick mode: manual (press a button to move)");
|
|
}
|
|
else if(getcstat == 'e')
|
|
out = XLAT("You need special glasses to view the game in 3D");
|
|
else if(getcstat == 'f')
|
|
out = XLAT("Reduce the framerate limit to conserve CPU energy");
|
|
}
|
|
else if(cmode == emChangeMode) {
|
|
if(getcstat == 'h')
|
|
out = XLAT("One wrong move and it is game over!");
|
|
}
|
|
|
|
mouseovers = out;
|
|
|
|
int col = linf[cwt.c->land].color;
|
|
if(cwt.c->land == laRedRock) col = 0xC00000;
|
|
if(cmode != emPickScores)
|
|
#ifdef MOBILE
|
|
if(cmode != emNormal && cmode != emQuit)
|
|
#endif
|
|
displayfr(vid.xres/2, vid.fsize, 2, vid.fsize, out, col, 8);
|
|
if(mousey < vid.fsize * 3/2) getcstat = SDLK_F1;
|
|
|
|
if(false && shmup::mousetarget) {
|
|
char buf[64];
|
|
sprintf(buf, "%Lf", (long double) intval(mouseh, shmup::mousetarget->pat*C0));
|
|
mouseovers = mouseovers + " D: " + buf;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void drawrec(const heptspin& hs, int lev, hstate s, transmatrix V) {
|
|
|
|
shmup::calc_relative_matrix(cwt.c, hs.h);
|
|
|
|
cell *c = hs.h->c7;
|
|
|
|
drawcell(c, V * spin(hs.spin*2*M_PI/7 + (purehepta ? M_PI:0)), hs.spin);
|
|
|
|
if(lev <= 0) return;
|
|
|
|
if(!purehepta) for(int d=0; d<7; d++) {
|
|
int ds = fixrot(hs.spin + d);
|
|
// createMov(c, ds);
|
|
if(c->mov[ds] && c->spn[ds] == 0)
|
|
drawcell(c->mov[ds], V * hexmove[d], 0);
|
|
}
|
|
|
|
if(lev <= 1) return;
|
|
|
|
for(int d=0; d<7; d++) {
|
|
hstate s2 = transition(s, d);
|
|
if(s2 == hsError) continue;
|
|
heptspin hs2 = hsstep(hsspin(hs, d), 0);
|
|
drawrec(hs2, lev-2, s2, V * heptmove[d]);
|
|
}
|
|
|
|
}
|
|
|
|
int mindx=-7, mindy=-7, maxdx=7, maxdy=7;
|
|
|
|
|
|
void drawEuclidean() {
|
|
DEBB(DF_GRAPH, (debugfile,"drawEuclidean\n"));
|
|
eucoord px, py;
|
|
if(!lcenterover) lcenterover = cwt.c;
|
|
// printf("centerover = %p player = %p [%d,%d]-[%d,%d]\n", lcenterover, cwt.c,
|
|
// mindx, mindy, maxdx, maxdy);
|
|
decodeMaster(lcenterover->master, px, py);
|
|
|
|
int minsx = mindx-1, maxsx=maxdx+1, minsy=mindy-1, maxsy=maxdy+1;
|
|
mindx=maxdx=mindy=maxdy=0;
|
|
|
|
for(int dx=minsx; dx<=maxsx; dx++)
|
|
for(int dy=minsy; dy<=maxsy; dy++) {
|
|
eucoord x = dx+px;
|
|
eucoord y = dy+py;
|
|
cell *c = euclideanAt(x,y);
|
|
if(!c) continue;
|
|
transmatrix Mat = Id;
|
|
Mat[2][2] = 1;
|
|
Mat[0][2] += (x + y * .5) * eurad;
|
|
double q3 = sqrt(double(3));
|
|
Mat[1][2] += y * q3 /2 * eurad;
|
|
while(Mat[0][2] <= -16384 * eurad) Mat[0][2] += 32768 * eurad;
|
|
while(Mat[0][2] >= 16384 * eurad) Mat[0][2] -= 32768 * eurad;
|
|
while(Mat[1][2] <= -16384 * q3 * eurad) Mat[1][2] += 32768 * q3 * eurad;
|
|
while(Mat[1][2] >= 16384 * q3 * eurad) Mat[1][2] -= 32768 * q3 * eurad;
|
|
Mat = View * Mat;
|
|
|
|
// Mat[0][0] = -1;
|
|
// Mat[1][1] = -1;
|
|
|
|
// Mat[2][0] = x*x/10;
|
|
// Mat[2][1] = y*y/10;
|
|
// Mat = Mat * xpush(x-30) * ypush(y-30);
|
|
|
|
int cx, cy, shift;
|
|
getcoord(Mat * C0, cx, cy, shift);
|
|
if(cx >= 0 && cy >= 0 && cx < vid.xres && cy < vid.yres) {
|
|
if(dx < mindx) mindx = dx;
|
|
if(dy < mindy) mindy = dy;
|
|
if(dx > maxdx) maxdx = dx;
|
|
if(dy > maxdy) maxdy = dy;
|
|
}
|
|
|
|
drawcell(c, Mat, 0);
|
|
}
|
|
}
|
|
|
|
void drawthemap() {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"draw the map\n"));
|
|
fanframe = ticks / 150.0 / M_PI;
|
|
|
|
for(int m=0; m<motypes; m++) if(isPrincess(eMonster(m)))
|
|
minf[m].name = princessgender() ? "Princess" : "Prince";
|
|
|
|
iinf[itSavedPrincess].name = minf[moPrincess].name;
|
|
|
|
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;
|
|
}
|
|
|
|
keycell = NULL;
|
|
|
|
pirateTreasureFound = pirateTreasureSeek;
|
|
pirateTreasureSeek = NULL;
|
|
straightDownSeek = NULL; downspin = 0;
|
|
shmup::mousetarget = NULL;
|
|
showPirateX = cwt.c->item == itCompass;
|
|
|
|
using namespace yendor;
|
|
|
|
if(yii < size(yi)) {
|
|
if(!yi[yii].found)
|
|
for(int i=0; i<YDIST; i++)
|
|
if(yi[yii].path[i]->cpdist <= sightrange) {
|
|
keycell = yi[yii].path[i];
|
|
keycelldist = YDIST - i;
|
|
}
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
lmouseover = mouseover;
|
|
#endif
|
|
modist = 1e20; mouseover = NULL;
|
|
modist2 = 1e20; mouseover2 = NULL;
|
|
mouseovers = XLAT("Press F1 or right click for help");
|
|
centdist = 1e20; lcenterover = centerover; centerover = NULL;
|
|
#ifdef MOBILE
|
|
mouseovers = XLAT("No info about this...");
|
|
#endif
|
|
if(outofmap(mouseh))
|
|
modist = -5;
|
|
playerfound = false;
|
|
// playerfoundL = false;
|
|
// playerfoundR = false;
|
|
|
|
if(euclid)
|
|
drawEuclidean();
|
|
else
|
|
drawrec(viewctr,
|
|
conformal::on ? sightrange + 2:
|
|
(!playermoved) ? sightrange+1 : sightrange + 4,
|
|
hsOrigin, View);
|
|
|
|
if(shmup::on) {
|
|
if(shmup::players == 1)
|
|
cwtV = shmup::pc[0]->pat;
|
|
else if(shmup::centerplayer != -1)
|
|
cwtV = shmup::pc[shmup::centerplayer]->pat;
|
|
else if(shmup::players == 2) {
|
|
hyperpoint h0 = shmup::pc[0]->pat * C0;
|
|
hyperpoint h1 = shmup::pc[1]->pat * C0;
|
|
hyperpoint h2 = mid(h0, h1);
|
|
cwtV = rgpushxto0(h2);
|
|
}
|
|
else if(shmup::players == 3) {
|
|
hyperpoint h0 = shmup::pc[0]->pat * C0;
|
|
hyperpoint h1 = shmup::pc[1]->pat * C0;
|
|
hyperpoint h2 = shmup::pc[2]->pat * C0;
|
|
hyperpoint h3 = mid3(h0, h1, h2);
|
|
cwtV = rgpushxto0(h3);
|
|
}
|
|
else if(shmup::players == 4) {
|
|
hyperpoint h0 = shmup::pc[0]->pat * C0;
|
|
hyperpoint h1 = shmup::pc[1]->pat * C0;
|
|
hyperpoint h2 = shmup::pc[2]->pat * C0;
|
|
hyperpoint h3 = shmup::pc[3]->pat * C0;
|
|
hyperpoint h4 = mid4(h0, h1, h2, h3);
|
|
cwtV = rgpushxto0(h4);
|
|
}
|
|
}
|
|
|
|
#ifdef LOCAL
|
|
localDrawMap();
|
|
#endif
|
|
}
|
|
|
|
void spinEdge(ld aspd) {
|
|
if(downspin > aspd) downspin = aspd;
|
|
if(downspin < -aspd) downspin = -aspd;
|
|
View = spin(downspin) * View;
|
|
}
|
|
|
|
void centerpc(ld aspd) {
|
|
DEBB(DF_GRAPH, (debugfile,"center pc\n"));
|
|
hyperpoint H = cwtV * C0;
|
|
ld R = sqrt(H[0] * H[0] + H[1] * H[1]);
|
|
if(R < 1e-9) {
|
|
/* if(playerfoundL && playerfoundR) {
|
|
|
|
} */
|
|
spinEdge(aspd);
|
|
return;
|
|
}
|
|
|
|
if(euclid) {
|
|
// Euclidean
|
|
aspd *= (2+3*R*R);
|
|
if(aspd > R) aspd = R;
|
|
|
|
View[0][2] -= cwtV[0][2] * aspd / R;
|
|
View[1][2] -= cwtV[1][2] * aspd / R;
|
|
}
|
|
|
|
else {
|
|
aspd *= (1+R+(shmup::on?1:0));
|
|
|
|
if(R < aspd) {
|
|
View = gpushxto0(H) * View;
|
|
}
|
|
else
|
|
View = rspintox(H) * xpush(-aspd) * spintox(H) * View;
|
|
|
|
fixmatrix(View);
|
|
spinEdge(aspd);
|
|
}
|
|
}
|
|
|
|
void drawmovestar() {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"draw movestar\n"));
|
|
if(!playerfound) return;
|
|
|
|
if(shmup::on) return;
|
|
if(rug::rugged) return;
|
|
|
|
if(vid.axes == 0 || (vid.axes == 1 && mousing)) return;
|
|
|
|
hyperpoint H = cwtV * C0;
|
|
ld R = sqrt(H[0] * H[0] + H[1] * H[1]);
|
|
transmatrix Centered = Id;
|
|
|
|
if(euclid)
|
|
Centered = eupush(H[0], H[1]);
|
|
else if(R > 1e-9) Centered = rgpushxto0(H);
|
|
|
|
int starcol = (vid.goteyes2 ? 0xE08060 : 0xC00000);
|
|
|
|
if(vid.axes == 3 || (vid.wallmode == 2 && vid.axes == 1))
|
|
queuepoly(Centered, shMovestar, darkena(starcol, 0, 0xFF));
|
|
|
|
else for(int d=0; d<8; d++) {
|
|
int col = starcol;
|
|
#ifdef PANDORA
|
|
if(leftclick && (d == 2 || d == 6 || d == 1 || d == 7)) col >>= 2;
|
|
if(rightclick && (d == 2 || d == 6 || d == 3 || d == 5)) col >>= 2;
|
|
if(!leftclick && !rightclick && (d&1)) col >>= 2;
|
|
#endif
|
|
// EUCLIDEAN
|
|
if(euclid)
|
|
queueline(Centered * C0, Centered * ddi(d * 10.5, 0.5) * C0, col >> darken);
|
|
else
|
|
queueline(Centered * C0, Centered * spin(M_PI*d/4)* xpush(.5) * C0, col >> darken);
|
|
}
|
|
}
|
|
|
|
void optimizeview() {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"optimize view\n"));
|
|
int turn = 0;
|
|
ld best = INF;
|
|
|
|
transmatrix TB = Id;
|
|
|
|
for(int i=-1; i<7; i++) {
|
|
|
|
ld trot = -i * M_PI * 2 / 7.0;
|
|
transmatrix T = i < 0 ? Id : spin(trot) * xpush(tessf) * spin(M_PI);
|
|
hyperpoint H = View * T * C0;
|
|
if(H[2] < best) best = H[2], turn = i, TB = T;
|
|
}
|
|
|
|
if(turn >= 0) {
|
|
View = View * TB;
|
|
fixmatrix(View);
|
|
viewctr = hsspin(viewctr, turn);
|
|
viewctr = hsstep(viewctr, 0);
|
|
}
|
|
}
|
|
|
|
movedir vectodir(const hyperpoint& P) {
|
|
hyperpoint H = cwtV * C0;
|
|
ld R = sqrt(H[0] * H[0] + H[1] * H[1]);
|
|
transmatrix Centered = cwtV;
|
|
if(!euclid)
|
|
Centered = gpushxto0(H) * Centered;
|
|
else if(R > 1e-9)
|
|
Centered = eupush(-H[0], -H[1]) * Centered;
|
|
ld binv = 99;
|
|
|
|
ld dirdist[7];
|
|
for(int i=0; i<cwt.c->type; i++)
|
|
dirdist[i] = intval(Centered * spin(-i * 2 * M_PI /cwt.c->type) * xpush(1) * C0, P);
|
|
|
|
movedir res;
|
|
res.d = -1;
|
|
|
|
for(int i=0; i<cwt.c->type; i++) {
|
|
if(dirdist[i] < binv) {
|
|
binv = dirdist[i];
|
|
res.d = i;
|
|
res.subdir = dirdist[(i+1)%cwt.c->type] < dirdist[(i+cwt.c->type-1)%cwt.c->type] ? 1 : -1;
|
|
}
|
|
}
|
|
// if(euclid) bdir = (bdir + 3) % 6;
|
|
return res;
|
|
}
|
|
|
|
void movepckeydir(int d) {
|
|
DEBB(DF_GRAPH, (debugfile,"movepckeydir\n"));
|
|
// EUCLIDEAN
|
|
if(euclid)
|
|
movepcto(vectodir(spin(-d * M_PI/4) * eupush(1, 0) * C0));
|
|
else
|
|
movepcto(vectodir(spin(-d * M_PI/4) * xpush(1) * C0));
|
|
}
|
|
|
|
void calcMousedest() {
|
|
if(outofmap(mouseh)) return;
|
|
if(revcontrol == true) { mouseh[0] = -mouseh[0]; mouseh[1] = -mouseh[1]; }
|
|
ld mousedist = intval(mouseh, curcell * C0);
|
|
mousedest.d = -1;
|
|
|
|
ld dists[7];
|
|
|
|
for(int i=0; i<cwt.c->type; i++)
|
|
dists[i] = intval(mouseh, movecell[i] * C0);
|
|
|
|
/* printf("curcell = %Lf\n", mousedist);
|
|
for(int i=0; i<cwt.c->type; i++)
|
|
printf("d%d = %Lf\n", i, dists[i]); */
|
|
|
|
for(int i=0; i<cwt.c->type; i++) if(dists[i] < mousedist) {
|
|
mousedist = dists[i];
|
|
mousedest.d = fixdir(i - cwt.spin, cwt.c);
|
|
|
|
mousedest.subdir =
|
|
dists[(i+1)%cwt.c->type] < dists[(i+cwt.c->type-1)%cwt.c->type] ? 1 : -1;
|
|
}
|
|
|
|
}
|
|
|
|
void mousemovement() {
|
|
calcMousedest();
|
|
movepcto(mousedest);
|
|
}
|
|
|
|
long double sqr(long double x) { return x*x; }
|
|
|
|
void checkjoy() {
|
|
DEBB(DF_GRAPH, (debugfile,"check joy\n"));
|
|
if(shmup::on) return;
|
|
ld joyvalue1 = sqr(vid.joyvalue);
|
|
ld joyvalue2 = sqr(vid.joyvalue2);
|
|
|
|
ld jx = joyx;
|
|
ld jy = joyy;
|
|
ld sq = jx*jx+jy*jy;
|
|
|
|
if(autojoy) {
|
|
if(sq < joyvalue1) { if(joydir.d >= 0) movepcto(joydir); joydir.d = -1; return; }
|
|
if(sq < joyvalue2 && joydir.d == -1) return;
|
|
}
|
|
else {
|
|
if(sq < joyvalue1) { joydir.d = -1; return; }
|
|
}
|
|
|
|
joydir = vectodir(hpxy(jx, jy));
|
|
}
|
|
|
|
void checkpanjoy(double t) {
|
|
|
|
if(shmup::on) return;
|
|
|
|
if(vid.joypanspeed < 1e-7) return;
|
|
|
|
if(sqr(panjoyx) + sqr(panjoyy) < sqr(vid.joypanthreshold))
|
|
return;
|
|
|
|
ld jx = panjoyx * t * vid.joypanspeed;
|
|
ld jy = panjoyy * t * vid.joypanspeed;
|
|
|
|
playermoved = false;
|
|
View = gpushxto0(hpxy(jx, jy)) * View;
|
|
}
|
|
|
|
void calcparam() {
|
|
DEBB(DF_GRAPH, (debugfile,"calc param\n"));
|
|
vid.xcenter = vid.xres / 2;
|
|
vid.ycenter = vid.yres / 2;
|
|
vid.radius = int(vid.scale * vid.ycenter) - (ISANDROID ? 2 : ISIOS ? 40 : 40);
|
|
|
|
if(vid.xres < vid.yres) {
|
|
vid.radius = int(vid.scale * vid.xcenter) - (ISIOS ? 10 : 2);
|
|
vid.ycenter = vid.yres - vid.radius - vid.fsize - (ISIOS ? 10 : 0);
|
|
}
|
|
|
|
vid.beta = 1 + vid.alpha + vid.eye;
|
|
vid.alphax = vid.alpha + vid.eye;
|
|
vid.goteyes = vid.eye > 0.001 || vid.eye < -0.001;
|
|
vid.goteyes2 = vid.goteyes;
|
|
}
|
|
|
|
void displayStat(int y, const string& name, const string& val, char mkey) {
|
|
|
|
int dy = vid.fsize * y + vid.yres/4;
|
|
int dx = vid.xres/2 - 100;
|
|
|
|
bool xthis = (mousey >= dy-vid.fsize/2 && mousey <= dy + vid.fsize/2);
|
|
int xcol = 0x808080;
|
|
|
|
if(xthis) {
|
|
getcstat = mkey; getcshift = 0;
|
|
int mx = mousex - dx;
|
|
if(mx >= 0 && mx <= 100) {
|
|
if(mx < 20) getcshift = -1 , xcol = 0xFF0000;
|
|
else if(mx < 40) getcshift = -0.1 , xcol = 0x0000FF;
|
|
else if(mx < 50) getcshift = -0.01, xcol = 0x00FF00;
|
|
if(mx > 80) getcshift = +1 , xcol = 0xFF0000;
|
|
else if(mx > 60) getcshift = +0.1 , xcol = 0x0000FF;
|
|
else if(mx > 50) getcshift = +0.01, xcol = 0x00FF00;
|
|
}
|
|
}
|
|
|
|
if(val != "") {
|
|
if(val[0] != ' ') {
|
|
displaystr(dx, dy, 0, vid.fsize, val, xthis ? 0xFFFF00 : 0x808080, 16);
|
|
displaystr(dx+25, dy, 0, vid.fsize, "-", xthis && getcshift < 0 ? xcol : 0x808080, 8);
|
|
displaystr(dx+75, dy, 0, vid.fsize, "+", xthis && getcshift > 0 ? xcol : 0x808080, 8);
|
|
}
|
|
else
|
|
displaystr(dx+75, dy, 0, vid.fsize, val, xthis ? 0xFFFF00 : 0x808080, 16);
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
string mk = s0 + mkey;
|
|
int hkx = dx + 100;
|
|
if(mkey >= 1 && mkey <= 26) mk = s0 + "^", mk += (mkey+64), hkx -= vid.fsize;
|
|
// if(mkey >= 64+1 && mkey <= 64+26) mk = s0 + "Shift+", mk += mkey;
|
|
displaystr(hkx, dy, 0, vid.fsize, mk, xthis ? 0xFFFF00 : 0xC0F0C0, 0);
|
|
#endif
|
|
|
|
displaystr(dx+125, dy, 0, vid.fsize, name, xthis ? 0xFFFF00 : 0x808080, 0);
|
|
}
|
|
|
|
void displayStatHelp(int y, string name) {
|
|
|
|
int dy = vid.fsize * y + vid.yres/4;
|
|
int dx = vid.xres/2 - 100;
|
|
|
|
displaystr(dx+100, dy, 0, vid.fsize, name, 0xC0C0C0, 0);
|
|
}
|
|
|
|
void displayButton(int x, int y, const string& name, int key, int align, int rad) {
|
|
if(displayfr(x, y, rad, vid.fsize, name, 0x808080, align)) {
|
|
displayfr(x, y, rad, vid.fsize, name, 0xFFFF00, align);
|
|
getcstat = key;
|
|
}
|
|
}
|
|
|
|
void displayColorButton(int x, int y, const string& name, int key, int align, int rad, int color, int color2) {
|
|
if(displayfr(x, y, rad, vid.fsize, name, color, align)) {
|
|
if(color2) displayfr(x, y, rad, vid.fsize, name, color2, align);
|
|
getcstat = key;
|
|
}
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
void quitOrAgain() {
|
|
int y = vid.yres * (618) / 1000;
|
|
displayButton(vid.xres/2, y + vid.fsize*1/2,
|
|
(items[itOrbSafety] && havesave) ?
|
|
XLAT("Press Enter or F10 to save") :
|
|
XLAT("Press Enter or F10 to quit"),
|
|
SDLK_RETURN, 8, 2);
|
|
displayButton(vid.xres/2, y + vid.fsize*2, XLAT("or 'r' or F5 to restart"), 'r', 8, 2);
|
|
displayButton(vid.xres/2, y + vid.fsize*7/2, XLAT("or 't' to see the top scores"), 't', 8, 2);
|
|
displayButton(vid.xres/2, y + vid.fsize*10/2, XLAT("or 'v' to see the main menu"), 'v', 8, 2);
|
|
displayButton(vid.xres/2, y + vid.fsize*13/2, XLAT("or 'o' to see the world overview"), 'o', 8, 2);
|
|
if(canmove) displayButton(vid.xres/2, y + vid.fsize*16/2, XLAT("or another key to continue"), ' ', 8, 2);
|
|
else displayButton(vid.xres/2, y + vid.fsize*16/2, XLAT("or ESC to see how it ended"), SDLK_ESCAPE, 8, 2);
|
|
}
|
|
#endif
|
|
|
|
int calcfps() {
|
|
#define CFPS 30
|
|
static int last[CFPS], lidx = 0;
|
|
int ct = ticks;
|
|
int ret = ct - last[lidx];
|
|
last[lidx] = ct;
|
|
lidx++; lidx %= CFPS;
|
|
if(ret == 0) return 0;
|
|
return (1000 * CFPS) / ret;
|
|
}
|
|
|
|
int msgscroll = 0;
|
|
|
|
string timeline() {
|
|
int timespent = (int) (savetime + (timerstopped ? 0 : (time(NULL) - timerstart)));
|
|
char buf[20];
|
|
sprintf(buf, "%d:%02d", timespent/60, timespent % 60);
|
|
return
|
|
shmup::on ?
|
|
XLAT("%1 knives (%2)", its(turncount), buf)
|
|
:
|
|
XLAT("%1 turns (%2)", its(turncount), buf);
|
|
}
|
|
|
|
void showGameover() {
|
|
int y = vid.yres * (1000-618) / 1000 - vid.fsize * 7/2;
|
|
displayfr(vid.xres/2, y, 4, vid.fsize*2,
|
|
cheater ? XLAT("It is a shame to cheat!") :
|
|
showoff ? XLAT("Showoff mode") :
|
|
canmove && princess::challenge ? XLAT("%1 Challenge", moPrincess) :
|
|
canmove ? XLAT("Quest status") :
|
|
XLAT("GAME OVER"), 0xC00000, 8
|
|
);
|
|
displayfr(vid.xres/2, y + vid.fsize*2, 2, vid.fsize, XLAT("Your score: %1", its(gold())), 0xD0D0D0, 8);
|
|
displayfr(vid.xres/2, y + vid.fsize*3, 2, vid.fsize, XLAT("Enemies killed: %1", its(tkills())), 0xD0D0D0, 8);
|
|
|
|
if(!timerstopped && !canmove) {
|
|
savetime += time(NULL) - timerstart;
|
|
timerstopped = true;
|
|
}
|
|
if(canmove && !timerstart)
|
|
timerstart = time(NULL);
|
|
|
|
if(items[itOrbYendor]) {
|
|
displayfr(vid.xres/2, y + vid.fsize*4, 2, vid.fsize, XLAT("Orbs of Yendor found: %1", its(items[itOrbYendor])), 0xFF00FF, 8);
|
|
displayfr(vid.xres/2, y + vid.fsize*5, 2, vid.fsize, XLAT("CONGRATULATIONS!"), 0xFFFF00, 8);
|
|
}
|
|
else {
|
|
if(princess::challenge) ;
|
|
else if(gold() < 30)
|
|
displayfr(vid.xres/2, y+vid.fsize*5, 2, vid.fsize, XLAT("Collect 30 $$$ to access more worlds"), 0xC0C0C0, 8);
|
|
else if(gold() < 60)
|
|
displayfr(vid.xres/2, y+vid.fsize*5, 2, vid.fsize, XLAT("Collect 60 $$$ to access even more lands"), 0xC0C0C0, 8);
|
|
else if(!hellUnlocked())
|
|
displayfr(vid.xres/2, y+vid.fsize*5, 2, vid.fsize, XLAT("Collect at least 10 treasures in each of 9 types to access Hell"), 0xC0C0C0, 8);
|
|
else if(items[itHell] < 10)
|
|
displayfr(vid.xres/2, y+vid.fsize*5, 2, vid.fsize, XLAT("Collect at least 10 Demon Daisies to find the Orbs of Yendor"), 0xC0C0C0, 8);
|
|
else if(size(yendor::yi) == 0)
|
|
displayfr(vid.xres/2, y+vid.fsize*5, 2, vid.fsize, XLAT("Look for the Orbs of Yendor in Hell or in the Crossroads!"), 0xC0C0C0, 8);
|
|
else
|
|
displayfr(vid.xres/2, y+vid.fsize*5, 2, vid.fsize, XLAT("Unlock the Orb of Yendor!"), 0xC0C0C0, 8);
|
|
}
|
|
if(princess::challenge)
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize, XLAT("Follow the Mouse and escape with %the1!", moPrincess), 0xC0C0C0, 8);
|
|
else if(tkills() < 100)
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize, XLAT("Defeat 100 enemies to access the Graveyard"), 0xC0C0C0, 8);
|
|
else if(kills[moVizier] == 0 && (items[itFernFlower] < 5 || items[itGold] < 5)) {
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize, XLAT("Kill a Vizier in the Palace to access Emerald Mine"), 0xC0C0C0, 8);
|
|
}
|
|
else if(items[itEmerald] < 5)
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize, XLAT("Collect 5 Emeralds to access Camelot"), 0xC0C0C0, 8);
|
|
else if(hellUnlocked()) {
|
|
bool b = true;
|
|
for(int i=0; i<LAND_HYP; i++)
|
|
if(b && items[treasureType(land_hyp[i])] < 10) {
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize,
|
|
XLAT(
|
|
land_hyp[i] == laTortoise ? "Hyperstone Quest: collect at least 10 points in %the2" :
|
|
"Hyperstone Quest: collect at least 10 %1 in %the2",
|
|
treasureType(land_hyp[i]), land_hyp[i]),
|
|
0xC0C0C0, 8);
|
|
b = false;
|
|
}
|
|
if(b)
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize, XLAT("Hyperstone Quest completed!"), 0xC0C0C0, 8);
|
|
}
|
|
else {
|
|
displayfr(vid.xres/2, y+vid.fsize*6, 2, vid.fsize, XLAT("Some lands unlock at specific treasures or kills"), 0xC0C0C0, 8);
|
|
}
|
|
if((!canmove) && (!ISMOBILE))
|
|
displayfr(vid.xres/2, y+vid.fsize*7, 2, vid.fsize, XLAT("(press ESC during the game to review your quest)"), 0xB0B0B0, 8);
|
|
if(cheater)
|
|
displayfr(vid.xres/2, y+vid.fsize*9, 2, vid.fsize, XLAT("you have cheated %1 times", its(cheater)), 0xFF2020, 8);
|
|
if(!cheater) {
|
|
displayfr(vid.xres/2, y + vid.fsize*9, 2, vid.fsize, timeline(), 0xC0C0C0, 8);
|
|
}
|
|
|
|
msgs.clear();
|
|
if(msgscroll < 0) msgscroll = 0;
|
|
int gls = size(gamelog) - msgscroll;
|
|
int mnum = 0;
|
|
for(int i=gls-5; i<gls; i++)
|
|
if(i>=0) {
|
|
msginfo m;
|
|
m.spamtype = 0;
|
|
m.flashout = true;
|
|
m.stamp = ticks-128*vid.flashtime-128*(gls-i);
|
|
m.msg = gamelog[i];
|
|
mnum++,
|
|
msgs.push_back(m);
|
|
}
|
|
|
|
if(mnum)
|
|
displayfr(vid.xres/2, vid.yres-vid.fsize*(mnum+1), 2, vid.fsize/2, XLAT("last messages:"), 0xC0C0C0, 8);
|
|
|
|
#ifndef MOBILE
|
|
quitOrAgain();
|
|
#endif
|
|
}
|
|
|
|
string ifMousing(string key, string s) {
|
|
if(mousing) return XLAT(s);
|
|
else return key + " - " + XLAT(s);
|
|
}
|
|
|
|
#ifdef MOBILE
|
|
void displayabutton(int px, int py, string s, int col) {
|
|
// TMP
|
|
int siz = vid.yres > vid.xres ? vid.fsize*2 : vid.fsize * 3/2;
|
|
int x = vid.xcenter + px * (vid.radius);
|
|
int y = vid.ycenter + py * (vid.radius - siz/2);
|
|
if(gtouched && !mouseover
|
|
&& abs(mousex - vid.xcenter) < vid.radius
|
|
&& abs(mousey - vid.ycenter) < vid.radius
|
|
&& hypot(mousex-vid.xcenter, mousey-vid.ycenter) > vid.radius
|
|
&& px == (mousex > vid.xcenter ? 1 : -1)
|
|
&& py == (mousey > vid.ycenter ? 1 : -1)
|
|
) col = 0xFF0000;
|
|
if(displayfr(x, y, 0, siz, s, col, 8+8*px))
|
|
buttonclicked = true;
|
|
}
|
|
#endif
|
|
|
|
vector<score> scores;
|
|
|
|
int scoresort = 2;
|
|
int scoredisplay = 1;
|
|
int scorefrom = 0;
|
|
int scoremode = 0;
|
|
bool scorerev = false;
|
|
|
|
bool scorecompare(const score& s1, const score &s2) {
|
|
return s1.box[scoresort] > s2.box[scoresort];
|
|
}
|
|
|
|
bool fakescore() {
|
|
return fakebox[scoredisplay];
|
|
}
|
|
|
|
string displayfor(score* S) {
|
|
// printf("S=%p, scoredisplay = %d\n", S, scoredisplay);
|
|
if(S == NULL) {
|
|
return XLATN(boxname[scoredisplay]);
|
|
}
|
|
if(scoredisplay == 0) {
|
|
char buf[10];
|
|
snprintf(buf, 10, "%d:%02d", S->box[0]/60, S->box[0]%60);
|
|
return buf;
|
|
}
|
|
if(scoredisplay == 1) {
|
|
time_t tim = S->box[1];
|
|
char buf[128]; strftime(buf, 128, "%c", localtime(&tim));
|
|
return buf;
|
|
}
|
|
return its(S->box[scoredisplay]);
|
|
}
|
|
|
|
#ifndef ANDROID
|
|
void loadScores() {
|
|
scores.clear();
|
|
FILE *f = fopen(scorefile, "rt");
|
|
if(!f) {
|
|
printf("Could not open the score file '%s'!\n", scorefile);
|
|
addMessage(s0 + "Could not open the score file: " + scorefile);
|
|
return;
|
|
}
|
|
while(!feof(f)) {
|
|
char buf[120];
|
|
if(fgets(buf, 120, f) == NULL) break;
|
|
if(buf[0] == 'H' && buf[1] == 'y') {
|
|
score sc; bool ok = true;
|
|
if(fscanf(f, "%s", buf) <= 0) break; sc.ver = buf;
|
|
|
|
for(int i=0; i<MAXBOX; i++) {
|
|
if(fscanf(f, "%d", &sc.box[i]) <= 0) { boxid = i; break; }
|
|
}
|
|
|
|
for(int i=boxid; i<MAXBOX; i++) sc.box[i] = 0;
|
|
|
|
if(sc.ver >= "4.4") {
|
|
sc.box[0] = sc.box[65];
|
|
// the first executable on Steam included a corruption
|
|
if(sc.box[65] > 1420000000 && sc.box[65] < 1430000000) {
|
|
sc.box[0] = sc.box[65] - sc.box[1];
|
|
sc.box[65] = sc.box[0];
|
|
}
|
|
// do not include saves
|
|
if(sc.box[65 + 4 + itOrbSafety - itOrbLightning]) ok = false;
|
|
}
|
|
else
|
|
sc.box[0] = sc.box[1] - sc.box[0]; // could not save then
|
|
if(ok && boxid > 20) scores.push_back(sc);
|
|
}
|
|
}
|
|
fclose(f);
|
|
addMessage(its(size(scores))+" games have been recorded in "+scorefile);
|
|
cmode = emScores;
|
|
boxid = 0; applyBoxes();
|
|
scoresort = 2; reverse(scores.begin(), scores.end());
|
|
scoremode = 0;
|
|
if(shmup::on) scoremode = 1;
|
|
else if(hardcore) scoremode = 2;
|
|
scorefrom = 0;
|
|
stable_sort(scores.begin(), scores.end(), scorecompare);
|
|
}
|
|
|
|
bool notgl = false;
|
|
|
|
void showPickScores() {
|
|
|
|
int d = scoredisplay;
|
|
|
|
vector<pair<string, int> > v;
|
|
for(int i=0; i<POSSCORE; i++) {
|
|
scoredisplay = i;
|
|
if(!fakescore())
|
|
v.push_back(make_pair(displayfor(NULL), i));
|
|
}
|
|
sort(v.begin(), v.end());
|
|
|
|
int q = (int) v.size();
|
|
int percolumn = vid.yres / (vid.fsize+3) - 4;
|
|
int columns = 1 + (q-1) / percolumn;
|
|
|
|
for(int i=0; i<q; i++) {
|
|
int x = 16 + (vid.xres * (i/percolumn)) / columns;
|
|
int y = (vid.fsize+3) * (i % percolumn) + vid.fsize*2;
|
|
|
|
scoredisplay = v[i].second;
|
|
if(!fakescore())
|
|
displayButton(x, y, v[i].first, char(33+scoredisplay), 0);
|
|
}
|
|
|
|
scoredisplay = d;
|
|
}
|
|
|
|
void showScores() {
|
|
int y = vid.fsize * 7/2;
|
|
int bx = vid.fsize;
|
|
|
|
string modes =
|
|
scoremode == 0 ? XLAT(", m - mode: normal") :
|
|
scoremode == 1 ? XLAT(", m - mode: shoot'em up") :
|
|
scoremode == 2 ? XLAT(", m - mode: hardcore only") :
|
|
"?";
|
|
|
|
if(euclid) modes += XLAT(" (E:%1)", euclidland);
|
|
|
|
|
|
mouseovers = XLAT("t/left/right - change display, up/down - scroll, s - sort by") + modes;
|
|
|
|
displaystr(bx*4, vid.fsize*2, 0, vid.fsize, "#", 0xFFFFFF, 16);
|
|
displaystr(bx*8, vid.fsize*2, 0, vid.fsize, "$$$", 0xFFFFFF, 16);
|
|
displaystr(bx*12, vid.fsize*2, 0, vid.fsize, XLAT("kills"), 0xFFFFFF, 16);
|
|
displaystr(bx*18, vid.fsize*2, 0, vid.fsize, XLAT("time"), 0xFFFFFF, 16);
|
|
displaystr(bx*22, vid.fsize*2, 0, vid.fsize, XLAT("ver"), 0xFFFFFF, 16);
|
|
displaystr(bx*23, vid.fsize*2, 0, vid.fsize, displayfor(NULL), 0xFFFFFF, 0);
|
|
if(scorefrom < 0) scorefrom = 0;
|
|
int id = scorefrom;
|
|
while(y < (ISIOS ? vid.yres - 3*vid.fsize : vid.yres)) {
|
|
if(id >= size(scores)) break;
|
|
|
|
score& S(scores[id]);
|
|
|
|
bool wrongtype = false;
|
|
|
|
wrongtype |= (euclid && (!S.box[116] || S.box[120] != euclidland));
|
|
wrongtype |= (!euclid && S.box[116]);
|
|
|
|
wrongtype |= (scoremode == 1 && !S.box[119]);
|
|
wrongtype |= (scoremode != 1 && S.box[119]);
|
|
wrongtype |= (scoremode == 2 && (!S.box[117] || S.box[118] >= PUREHARDCORE_LEVEL));
|
|
|
|
if(wrongtype) { id++; continue; }
|
|
|
|
char buf[16];
|
|
|
|
sprintf(buf, "%d", id+1);
|
|
displaystr(bx*4, y, 0, vid.fsize, buf, 0xC0C0C0, 16);
|
|
|
|
sprintf(buf, "%d", S.box[2]);
|
|
displaystr(bx*8, y, 0, vid.fsize, buf, 0xC0C0C0, 16);
|
|
|
|
sprintf(buf, "%d", S.box[3]);
|
|
displaystr(bx*12, y, 0, vid.fsize, buf, 0xC0C0C0, 16);
|
|
|
|
sprintf(buf, "%d:%02d", S.box[0]/60, S.box[0] % 60);
|
|
displaystr(bx*18, y, 0, vid.fsize, buf, 0xC0C0C0, 16);
|
|
|
|
displaystr(bx*22, y, 0, vid.fsize, S.ver, 0xC0C0C0, 16);
|
|
|
|
displaystr(bx*23, y, 0, vid.fsize, displayfor(&S), 0xC0C0C0, 0);
|
|
|
|
y += vid.fsize*5/4; id++;
|
|
}
|
|
|
|
#ifdef IOS
|
|
buttonclicked = false;
|
|
displayabutton(-1, +1, XLAT("SORT"), BTON);
|
|
displayabutton(+1, +1, XLAT("PLAY"), BTON);
|
|
#endif
|
|
}
|
|
|
|
void sortScores() {
|
|
if(scorerev) reverse(scores.begin(), scores.end());
|
|
else {
|
|
scorerev = true;
|
|
scoresort = scoredisplay;
|
|
stable_sort(scores.begin(), scores.end(), scorecompare);
|
|
}
|
|
}
|
|
|
|
void shiftScoreDisplay(int delta) {
|
|
scoredisplay = (scoredisplay + POSSCORE + delta) % POSSCORE, scorerev = false;
|
|
if(fakescore()) shiftScoreDisplay(delta);
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
void handleScoreKeys(int sym, SDL_Event& ev) {
|
|
if(sym == SDLK_LEFT || sym == SDLK_KP4 || sym == 'h' || sym == 'a')
|
|
shiftScoreDisplay(-1);
|
|
else if(sym == SDLK_RIGHT || sym == SDLK_KP6 || sym == 'l' || sym == 'd')
|
|
shiftScoreDisplay(1);
|
|
else if(sym == 't') cmode = emPickScores;
|
|
else if(sym == SDLK_UP || sym == 'k' || sym == 'w')
|
|
scorefrom -= 5;
|
|
else if(sym == SDLK_DOWN || sym == 'j' || sym == 'x')
|
|
scorefrom += 5;
|
|
else if(sym == 's') sortScores();
|
|
else if(sym == 'm') { scoremode++; scoremode %= 3; }
|
|
else if(sym != 0 || ev.type == SDL_MOUSEBUTTONDOWN) cmode = emNormal;
|
|
}
|
|
|
|
void handlePickScoreKeys(int uni, SDL_Event& ev) {
|
|
if(uni != 0) {
|
|
int k = uni - '!';
|
|
if(k >= 0 && k < POSSCORE) scoredisplay = k;
|
|
cmode = emScores;
|
|
scorerev = false;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
void setAppropriateOverview() {
|
|
if(tactic::on)
|
|
cmode = emTactic;
|
|
else if(yendor::on)
|
|
cmode = emYendor;
|
|
else if(euclid)
|
|
cmode = emPickEuclidean;
|
|
else
|
|
cmode = emOverview;
|
|
}
|
|
|
|
void drawStats() {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"drawStats\n"));
|
|
|
|
#ifdef IOS
|
|
if(cmode != emNormal && cmode != emQuit)
|
|
return;
|
|
#endif
|
|
|
|
int vx, vy;
|
|
|
|
int s = vid.fsize;
|
|
|
|
bool portrait = vid.xres < vid.yres;
|
|
|
|
if(portrait) {
|
|
vx = vid.fsize * 3;
|
|
vy = vid.fsize * 2;
|
|
if(havebugs) vy += vid.fsize * 3/2;
|
|
}
|
|
else {
|
|
vx = vid.xres - vid.fsize * 3;
|
|
vy = vid.fsize;
|
|
}
|
|
|
|
#define ADV(z) \
|
|
{if(portrait) { \
|
|
vx += vid.fsize*4; \
|
|
if(vx > vid.xres - vid.fsize*2) vx = vid.fsize * 3, vy += vid.fsize; \
|
|
} \
|
|
else { \
|
|
vy += vid.fsize * z/2; \
|
|
if(vy > vid.yres || (vx > vid.xres/2 && vy > vid.yres - s * 3)) vx += (vx > vid.xres/2 ? -5:5) * vid.fsize, vy = vid.fsize * 5/2; \
|
|
}}
|
|
|
|
if(!portrait) vid.portreduction = 0;
|
|
if(vid.xres >= vid.yres * 5/3 || portrait)
|
|
vid.killreduction = vid.itemreduction = 0;
|
|
|
|
if(portrait) vid.fsize = s - vid.portreduction;
|
|
else vid.fsize = s - vid.itemreduction;
|
|
|
|
if(displaynum(vx, vy, 0, vid.fsize, 0xFFFFFF, gold(), "$$$")) {
|
|
mouseovers = XLAT("Your total wealth"),
|
|
help = XLAT(
|
|
"The total value of the treasure you have collected.\n\n"
|
|
"Every world type contains a specific type of treasure, worth 1 $$$; "
|
|
"your goal is to collect as much treasure as possible, but every treasure you find "
|
|
"causes more enemies to hunt you in its native land.\n\n"
|
|
"Orbs of Yendor are worth 50 $$$ each.\n\n"
|
|
);
|
|
}
|
|
|
|
ADV(3); if(portrait) {ADV(3);}
|
|
|
|
#ifndef MOBILE
|
|
int oldz = 0;
|
|
#endif
|
|
|
|
for(int z=0; z<3; z++) for(int i=0; i<ittypes; i++) if(itemclass(eItem(i)) == z) {
|
|
#ifndef MOBILE
|
|
if(z != oldz) { ADV(1); oldz = z; }
|
|
#endif
|
|
if(items[i]) {
|
|
bool b = displaynum(vx, vy, 0, vid.fsize, iinf[i].color, items[i], s0 + iinf[i].glyph);
|
|
ADV(2);
|
|
if(b) {
|
|
int t = itemclass(eItem(i));
|
|
if(t == IC_TREASURE)
|
|
mouseovers = XLAT("treasure collected: %1", eItem(i));
|
|
if(t == IC_OTHER)
|
|
mouseovers = XLAT("objects found: %1", eItem(i));
|
|
if(t == IC_ORB)
|
|
mouseovers = XLAT("orb power: %1", eItem(i));
|
|
if(i == itGreenStone) {
|
|
mouseovers += XLAT(" (click to drop)");
|
|
getcstat = 'g';
|
|
}
|
|
help = generateHelpForItem(eItem(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
// printf("vx = %d/%d fsize = %d\n", vx, vid.xres - vid.fsize*4, vid.fsize);
|
|
if(vx < vid.xres - s * 3)
|
|
vid.itemreduction++;
|
|
|
|
if(portrait) {
|
|
vx = vid.fsize * 3;
|
|
vy += vid.fsize * 2; // vy = vid.fsize * 5;
|
|
}
|
|
else {
|
|
vx = vid.fsize * 3;
|
|
vy = vid.fsize;
|
|
vid.fsize = s;
|
|
}
|
|
|
|
if(displaynum(vx, vy, 0, vid.fsize, 0xFFFFFF, calcfps(), "fps"))
|
|
mouseovers = XLAT("frames per second"),
|
|
help =
|
|
XLAT(
|
|
"The higher the number, the smoother the animations in the game. "
|
|
"If you find that animations are not smooth enough, you can try "
|
|
"to change the options "
|
|
) +
|
|
#ifdef ANDROID
|
|
XLAT(
|
|
"(Menu button) and select the ASCII mode, which runs much faster. "
|
|
"Depending on your device, turning the OpenGL mode on or off might "
|
|
"make it faster, slower, or cause glitches.");
|
|
#else
|
|
#ifdef IOS
|
|
XLAT(
|
|
"(in the MENU). You can reduce the sight range, this should make "
|
|
"the animations smoother.");
|
|
#else
|
|
XLAT(
|
|
"(press v) and change the wall/monster mode to ASCII, or change "
|
|
"the resolution.");
|
|
#endif
|
|
// todo: iOS
|
|
#endif
|
|
ADV(3);
|
|
|
|
int killtypes = 0;
|
|
for(int i=1; i<motypes; i++) if(kills[i]) killtypes++;
|
|
|
|
if(killtypes >= 3) {
|
|
int kvx, kvy;
|
|
if(!portrait)
|
|
kvx = vid.fsize * 8, kvy = vid.fsize;
|
|
else { ADV(3); kvx=vx, kvy=vy; }
|
|
if(displaynum(kvx, kvy, 0, vid.fsize, 0xFFFFFF, tkills(), "XX"))
|
|
mouseovers = XLAT("Your total kills"),
|
|
help = XLAT(
|
|
"In most lands, more treasures are generated with each enemy native to this land you kill. "
|
|
"Moreover, 100 kills is a requirement to enter the Graveyard and the Hive.\n\n"
|
|
"Friendly creatures and parts of monsters (such as the Ivy) do appear in the list, "
|
|
"but are not counted in the total kill count.");
|
|
if(portrait) ADV(6);
|
|
}
|
|
|
|
if(!portrait) vid.fsize = s - vid.killreduction;
|
|
|
|
for(int i=1; i<motypes; i++) if(kills[i]) {
|
|
eMonster m = eMonster(i);
|
|
|
|
if(displaynum(vx, vy, 0, vid.fsize, minf[i].color, kills[i], s0 + minf[i].glyph)) {
|
|
help = generateHelpForMonster(m);
|
|
if(isMonsterPart(m))
|
|
mouseovers = s0 + XLAT("parts destroyed: %1", m);
|
|
else if(isFriendly(m) && isNonliving(m))
|
|
mouseovers = s0 + XLAT("friends destroyed: %1", m);
|
|
else if(isFriendly(m))
|
|
mouseovers = s0 + XLAT("friends killed: %1", m);
|
|
else if(isNonliving(m))
|
|
mouseovers = s0 + XLAT("monsters destroyed: %1", m);
|
|
else if(m == moTortoise)
|
|
mouseovers = s0 + XLAT("animals killed: %1", m);
|
|
else
|
|
mouseovers = s0 + XLAT("monsters killed: %1", m);
|
|
}
|
|
ADV(2);
|
|
}
|
|
|
|
if(!portrait && vx > s * 3) vid.killreduction++;
|
|
if(portrait && vy > vid.ycenter - vid.radius && vid.fsize > 1) vid.portreduction ++;
|
|
vid.fsize = s;
|
|
|
|
achievement_display();
|
|
|
|
#ifdef LOCAL
|
|
process_local_stats();
|
|
#endif
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
|
|
#ifndef NOPNG
|
|
void IMAGESAVE(SDL_Surface *s, const char *fname) {
|
|
SDL_Surface *s2 = SDL_PNGFormatAlpha(s);
|
|
SDL_SavePNG(s2, fname);
|
|
SDL_FreeSurface(s2);
|
|
}
|
|
#endif
|
|
|
|
void saveHighQualityShot() {
|
|
|
|
#ifndef GFX
|
|
addMessage(XLAT("High quality shots not available on this platform"));
|
|
return;
|
|
#endif
|
|
|
|
int dcs = size(dcal);
|
|
for(int i=0; i<dcs; i++) {
|
|
cell *c = dcal[i];
|
|
if(c->cpdist <= 4) setdist(c, 1, NULL);
|
|
}
|
|
|
|
time_t timer;
|
|
timer = time(NULL);
|
|
|
|
SDL_Surface *sav = s;
|
|
s = SDL_CreateRGBSurface(SDL_SWSURFACE,2000,2000,32,0,0,0,0);
|
|
|
|
int ssr = sightrange; sightrange = 10; int sch = cheater; cheater = 0;
|
|
|
|
bool b = vid.usingGL;
|
|
vid.usingGL = false;
|
|
videopar vid2 = vid;
|
|
vid.xres = vid.yres = 2000;
|
|
// if(vid.pmodel == 0) vid.scale = 0.99;
|
|
calcparam();
|
|
inHighQual = true;
|
|
|
|
darken = 0;
|
|
|
|
for(int i=0; i<2; i++) {
|
|
SDL_FillRect(s, NULL, i ? 0xFFFFFF : 0);
|
|
drawfullmap();
|
|
|
|
char buf[128]; strftime(buf, 128, "bigshota-%y%m%d-%H%M%S" IMAGEEXT, localtime(&timer));
|
|
buf[7] += i;
|
|
IMAGESAVE(s, buf);
|
|
|
|
if(i == 0) addMessage(XLAT("Saved the high quality shot to %1", buf));
|
|
}
|
|
|
|
inHighQual = false;
|
|
SDL_FreeSurface(s); s = sav; vid = vid2; sightrange = ssr; cheater = sch;
|
|
vid.usingGL = b;
|
|
}
|
|
#endif
|
|
|
|
void drawfullmap() {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"draw full map\n"));
|
|
|
|
ptds.clear();
|
|
|
|
if(!vid.goteyes && !euclid && pmodel == 0) {
|
|
queuecircle(vid.xcenter, vid.ycenter, vid.radius, 0xFF >> darken);
|
|
}
|
|
|
|
if(pmodel == 3 || pmodel == 4) polygonal::drawBoundary(0xFF >> darken);
|
|
|
|
if(vid.wallmode < 2 && !euclid && !mapeditor::whichShape) {
|
|
int ls = size(lines);
|
|
if(ISMOBILE) ls /= 10;
|
|
for(int t=0; t<ls; t++) queueline(View * lines[t].P1, View * lines[t].P2, lines[t].col >> darken);
|
|
}
|
|
|
|
drawthemap();
|
|
#ifndef MOBILE
|
|
if(!inHighQual) {
|
|
if(cmode == emNormal && !rug::rugged) drawmovestar();
|
|
if(rug::rugged && !rug::renderonce) queueline(C0, mouseh, 0xFF00FF);
|
|
mapeditor::drawGrid();
|
|
}
|
|
#endif
|
|
drawqueue();
|
|
}
|
|
|
|
#include "menus.cpp"
|
|
|
|
void drawscreen() {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"drawscreen\n"));
|
|
|
|
calcparam();
|
|
#ifdef GL
|
|
if(vid.usingGL) setGLProjection();
|
|
#endif
|
|
if(cmode != emHelp) help = "@";
|
|
|
|
#ifndef MOBILE
|
|
// 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);
|
|
if(!vid.usingGL) SDL_FillRect(s, NULL, 0);
|
|
#endif
|
|
|
|
if(!canmove) darken = 1;
|
|
if(cmode != emNormal && cmode != emDraw && cmode != emCustomizeChar) darken = 2;
|
|
if(cmode == emQuit && !canmove) darken = 0;
|
|
if(cmode == emOverview) darken = 4;
|
|
|
|
#ifdef MOBILE
|
|
if(cmode == emQuit) darken = 1;
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
if(cmode == emMapEditor && !mapeditor::subscreen && !mapeditor::choosefile) darken = 0;
|
|
if(cmode == emDraw && mapeditor::choosefile) darken = 2;
|
|
#endif
|
|
if(hiliteclick && darken == 0 && vid.monmode == 2) darken = 1;
|
|
if(cmode == emProgress) darken = 0;
|
|
|
|
if(conformal::includeHistory && cmode != emProgress) conformal::restore();
|
|
|
|
if(rug::rugged) {
|
|
#ifndef MOBILE
|
|
rug::actDraw();
|
|
#endif
|
|
}
|
|
else drawfullmap();
|
|
|
|
if(conformal::includeHistory && cmode != emProgress) conformal::restoreBack();
|
|
|
|
getcstat = 0;
|
|
|
|
if(cmode == emNormal || cmode == emQuit) drawStats();
|
|
|
|
#ifdef MOBILE
|
|
|
|
buttonclicked = false;
|
|
|
|
if(cmode == emNormal) {
|
|
displayabutton(-1, -1, XLAT("MOVE"), andmode == 0 ? BTON : BTOFF);
|
|
displayabutton(+1, -1, XLAT(andmode == 1 ? "BACK" : "DRAG"), andmode == 1 ? BTON : BTOFF);
|
|
displayabutton(-1, +1, XLAT("INFO"), andmode == 2 ? BTON : BTOFF);
|
|
displayabutton(+1, +1, XLAT("MENU"), andmode == 3 ? BTON : BTOFF);
|
|
}
|
|
|
|
if(cmode == emQuit) {
|
|
displayabutton(-1, +1, XLAT("NEW"), BTON);
|
|
displayabutton(+1, -1, XLAT(canmove ? "PLAY" : ISIOS ? " " : "SHARE"), BTON);
|
|
displayabutton(+1, +1, XLAT("MENU"), BTON);
|
|
}
|
|
|
|
#endif
|
|
|
|
// displaynum(vx,100, 0, 24, 0xc0c0c0, celldist(cwt.c), ":");
|
|
|
|
darken = 0;
|
|
drawmessages();
|
|
|
|
if(cmode == emNormal) {
|
|
#ifdef MOBILE
|
|
if(!canmove) cmode = emQuit;
|
|
#endif
|
|
if(!canmove) showGameover();
|
|
#ifndef MOBILE
|
|
// if(!canmove)
|
|
// displayButton(vid.xres-8, vid.yres-vid.fsize*2, XLAT("ESC for menu/quest"), SDLK_ESCAPE, 16);
|
|
#endif
|
|
}
|
|
|
|
#ifndef ANDROID
|
|
if(cmode == emProgress) mouseovers = "";
|
|
#endif
|
|
|
|
displayMenus();
|
|
|
|
describeMouseover();
|
|
|
|
if(havebugs && darken == 0) for(int k=0; k<3; k++)
|
|
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;
|
|
int mines[4], tmines=0;
|
|
for(int p=0; p<numplayers(); p++) {
|
|
mines[p] = 0;
|
|
cell *c = playerpos(p);
|
|
for(int i=0; i<c->type; i++) if(c->mov[i]) {
|
|
if(c->mov[i]->land == laMinefield)
|
|
minefieldNearby = true;
|
|
if(c->mov[i]->wall == waMineMine) {
|
|
bool ep = false;
|
|
if(!ep) mines[p]++, tmines++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if((minefieldNearby || tmines) && canmove && !items[itOrbGhost] && darken == 0) {
|
|
string s;
|
|
if(tmines > 7) tmines = 7;
|
|
int col = minecolors[tmines];
|
|
|
|
if(tmines == 7) seenSevenMines = true;
|
|
|
|
for(int p=0; p<numplayers(); p++)
|
|
displayfr(vid.xres * (p+.5) / numplayers(),
|
|
vid.ycenter - vid.radius * 3/4, 2,
|
|
vid.fsize,
|
|
XLAT(minetexts[mines[p]]), minecolors[mines[p]], 8);
|
|
|
|
if(minefieldNearby && !shmup::on && cwt.c->land != laMinefield && cwt.c->mov[cwt.spin]->land != laMinefield) {
|
|
displayfr(vid.xres/2, vid.ycenter - vid.radius * 3/4 - vid.fsize*3/2, 2,
|
|
vid.fsize,
|
|
XLAT("WARNING: you are entering a minefield!"),
|
|
col, 8);
|
|
}
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
if(cmode == emNormal || cmode == emVisual1 || cmode == emVisual2 || cmode == emChangeMode )
|
|
displayButton(vid.xres-8, vid.yres-vid.fsize, XLAT("(v) menu"), 'v', 16);
|
|
#endif
|
|
|
|
if(cmode == emQuit) {
|
|
if(canmove || ISMOBILE) showGameover();
|
|
}
|
|
|
|
#ifndef ANDROID
|
|
if(cmode == emHelp) {
|
|
int last = 0;
|
|
int lastspace = 0;
|
|
int siz = vid.fsize;
|
|
|
|
if(help == "@") help = buildHelpText();
|
|
|
|
if(ISIOS && size(help) >= 500) siz = (siz * 9)/10;
|
|
else if(ISIOS) siz = (siz * 3+1)/2;
|
|
else if(size(help) >= 500) siz = siz * 2/3;
|
|
|
|
int vy = vid.fsize * 4;
|
|
|
|
int xs = vid.xres * 618/1000;
|
|
int xo = vid.xres * 186/1000;
|
|
|
|
for(int i=0; i<=size(help); i++) {
|
|
int ls = 0;
|
|
int prev = last;
|
|
if(help[i] == ' ') lastspace = i;
|
|
if(textwidth(siz, help.substr(last, i-last)) > xs) {
|
|
if(lastspace == last) ls = i-1, last = i-1;
|
|
else ls = lastspace, last = ls+1;
|
|
}
|
|
if(help[i] == 10 || i == size(help)) ls = i, last = i+1;
|
|
if(ls) {
|
|
displayfr(xo, vy, 2, siz, help.substr(prev, ls-prev), 0xC0C0C0, 0);
|
|
if(ls == prev) vy += siz/2;
|
|
else vy += siz;
|
|
lastspace = last;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
// DEB
|
|
if(mouseover && targetclick) {
|
|
shmup::cpid = 0;
|
|
eItem i = targetRangedOrb(mouseover, roCheck);
|
|
if(i == itOrbSummon) {
|
|
eMonster m = summonedAt(mouseover);
|
|
displaychr(mousex, mousey, 0, vid.fsize, minf[m].glyph, minf[m].color);
|
|
}
|
|
else if(i)
|
|
displaychr(mousex, mousey, 0, vid.fsize, '@', iinf[i].color);
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
// SDL_UnlockSurface(s);
|
|
|
|
//profile("swapbuffers");
|
|
#ifdef GL
|
|
if(vid.usingGL) SDL_GL_SwapBuffers(); else
|
|
#endif
|
|
SDL_UpdateRect(s, 0, 0, vid.xres, vid.yres);
|
|
|
|
//printf("\ec");
|
|
|
|
#endif
|
|
|
|
//profile("centerpc");
|
|
if(playermoved && vid.aspeed > 4.99 && !shmup::on) {
|
|
centerpc(1000);
|
|
playermoved = false;
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
bool setfsize = false;
|
|
|
|
void setvideomode() {
|
|
|
|
DEBB(DF_INIT, (debugfile,"setvideomode\n"));
|
|
|
|
if(!vid.full) {
|
|
if(vid.xres > vid.xscr) vid.xres = vid.xscr * 9/10, setfsize = true;
|
|
if(vid.yres > vid.yscr) vid.yres = vid.yscr * 9/10, setfsize = true;
|
|
}
|
|
|
|
if(setfsize) vid.fsize = min(vid.yres / 32, vid.xres / 48), setfsize = false;
|
|
|
|
int flags = 0;
|
|
|
|
#ifdef GL
|
|
if(vid.usingGL) {
|
|
flags = SDL_OPENGL | SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER;
|
|
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 1);
|
|
}
|
|
#endif
|
|
|
|
int sizeflag = (vid.full ? SDL_FULLSCREEN : SDL_RESIZABLE);
|
|
|
|
s= SDL_SetVideoMode(vid.xres, vid.yres, 32, flags | sizeflag);
|
|
|
|
if(vid.full && !s) {
|
|
vid.xres = vid.xscr;
|
|
vid.yres = vid.yscr;
|
|
vid.fsize = min(vid.yres / 32, vid.xres / 48);
|
|
s = SDL_SetVideoMode(vid.xres, vid.yres, 32, flags | SDL_FULLSCREEN);
|
|
}
|
|
|
|
if(!s) {
|
|
addMessage("Failed to set the graphical mode: "+its(vid.xres)+"x"+its(vid.yres)+(vid.full ? " fullscreen" : " windowed"));
|
|
vid.xres = 640;
|
|
vid.yres = 480;
|
|
s = SDL_SetVideoMode(vid.xres, vid.yres, 32, flags | SDL_RESIZABLE);
|
|
}
|
|
|
|
#ifdef GL
|
|
if(vid.usingGL) {
|
|
glViewport(0, 0, vid.xres, vid.yres);
|
|
resetGL();
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
void restartGraph() {
|
|
DEBB(DF_INIT, (debugfile,"restartGraph\n"));
|
|
if(euclid) {
|
|
centerover = euclideanAtCreate(0,0);
|
|
}
|
|
else {
|
|
viewctr.h = &origin;
|
|
viewctr.spin = 0;
|
|
}
|
|
View = Id;
|
|
webdisplay = 0;
|
|
}
|
|
|
|
void initcs(charstyle &cs) {
|
|
cs.charid = 0;
|
|
cs.skincolor = 0xD0D0D0FF;
|
|
cs.haircolor = 0x686868FF;
|
|
cs.dresscolor = 0xC00000FF;
|
|
cs.swordcolor = 0xD0D0D0FF;
|
|
cs.dresscolor2= 0x8080FFC0;
|
|
}
|
|
|
|
#ifndef ANDROID
|
|
|
|
void savecs(FILE *f, charstyle& cs) {
|
|
int gflags = cs.charid;
|
|
if(vid.samegender) gflags |= 16;
|
|
|
|
fprintf(f, "%d %d %08x %08x %08x %08x",
|
|
gflags, vid.language, cs.skincolor, cs.haircolor, cs.swordcolor, cs.dresscolor);
|
|
if(cs.charid == 3) fprintf(f, " %08x", cs.dresscolor2);
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
void loadcs(FILE *f, charstyle& cs) {
|
|
int gflags, err =
|
|
fscanf(f, "%d%d%x%x%x%x", &gflags, &vid.language, &cs.skincolor, &cs.haircolor, &cs.swordcolor, &cs.dresscolor);
|
|
|
|
if(err) cs.charid = gflags & 15;
|
|
if(err) vid.samegender = (gflags & 16) ? true : false;
|
|
if(cs.charid == 3) if(fscanf(f, "%x", &cs.dresscolor2))
|
|
;
|
|
}
|
|
|
|
void saveConfig() {
|
|
DEBB(DF_INIT, (debugfile,"save config\n"));
|
|
FILE *f = fopen(conffile, "wt");
|
|
if(!f) {
|
|
addMessage(s0 + "Could not open the config file: " + conffile);
|
|
return;
|
|
}
|
|
fprintf(f, "%d %d %d %d\n", vid.xres, vid.yres, vid.full, vid.fsize);
|
|
fprintf(f, "%f %f %f %f\n", float(vid.scale), float(vid.eye), float(vid.alpha), float(vid.aspeed));
|
|
fprintf(f, "%d %d %d %d %d %d %d\n", vid.wallmode, vid.monmode, vid.axes, audiovolume, vid.framelimit, vid.usingGL, vid.usingAA);
|
|
fprintf(f, "%d %d %d %lf %d %d\n", vid.joyvalue, vid.joyvalue2, vid.joypanthreshold, vid.joypanspeed, autojoy, vid.flashtime);
|
|
|
|
savecs(f, vid.cs);
|
|
|
|
fprintf(f, "%d %d\n", vid.darkhepta, vid.shifttarget);
|
|
|
|
fprintf(f, "%d %d %d %d\n", euclid, euclidland, shmup::on, hardcore);
|
|
|
|
shmup::saveConfig(f);
|
|
|
|
fprintf(f, "%d %d %d %d %f %d %d\n", rug::renderonce, rug::rendernogl, rug::texturesize, purehepta, rug::scale, vid.steamscore, chaosmode);
|
|
|
|
fprintf(f, "%d %d %lf %d %d %lf\n",
|
|
pmodel, polygonal::SI, polygonal::STAR, polygonal::deg,
|
|
conformal::includeHistory, conformal::lvspeed);
|
|
|
|
fprintf(f, "%d %d %d %d %d %d\n",
|
|
conformal::bandhalf, conformal::bandsegment,
|
|
conformal::rotation, conformal::autoband, conformal::autobandhistory,
|
|
conformal::dospiral);
|
|
|
|
fprintf(f, "%d", polygonal::maxcoef);
|
|
for(int i=0; i<=polygonal::maxcoef; i++) fprintf(f, " %lf %lf",
|
|
(double) real(polygonal::coef[i]), (double) imag(polygonal::coef[i]));
|
|
|
|
fprintf(f, "\n\nThis is a configuration file for HyperRogue (version " VER ")\n");
|
|
fprintf(f, "\n\nThe numbers are:\n");
|
|
fprintf(f, "screen width & height, fullscreen mode (0=windowed, 1=fullscreen), font size\n");
|
|
fprintf(f, "scale, eye distance, parameter, animation speed\n");
|
|
fprintf(f, "wallmode, monster mode, cross mode, audiovolume, framerate limit, usingGL, usingAA\n");
|
|
fprintf(f, "calibrate first joystick (threshold A, threshold B), calibrate second joystick (pan threshold, pan speed), joy mode\n");
|
|
fprintf(f, "gender (1=female, 16=same gender prince), language, skin color, hair color, sword color, dress color\n");
|
|
fprintf(f, "darken hepta, shift target\n");
|
|
fprintf(f, "euclid, euclid land, shmup, hardcore\n");
|
|
fprintf(f, "version number, shmup players, shmup keyboard/joystick config\n");
|
|
fprintf(f, "hypersian rug config: renderonce, rendernogl, texturesize; purehepta; rug scale; share score; chaosmode\n");
|
|
fprintf(f, "conformal: model, sides, star, degree, includeHistory, speed\n");
|
|
fprintf(f, "conformal: bandwidth, segment, rotation, autoband, autohistory, dospiral\n");
|
|
fprintf(f, "conformal: degree, (degree+1) times {real, imag}\n");
|
|
|
|
fclose(f);
|
|
#ifndef MOBILE
|
|
addMessage(s0 + "Configuration saved to: " + conffile);
|
|
#else
|
|
addMessage(s0 + "Configuration saved");
|
|
#endif
|
|
}
|
|
|
|
void loadConfig() {
|
|
|
|
DEBB(DF_INIT, (debugfile,"load config\n"));
|
|
vid.xres = 9999; vid.yres = 9999; vid.framelimit = 300;
|
|
FILE *f = fopen(conffile, "rt");
|
|
if(f) {
|
|
int fs, gl=1, aa=1, bb=1, cc, dd, ee;
|
|
int err;
|
|
err=fscanf(f, "%d%d%d%d", &vid.xres, &vid.yres, &fs, &vid.fsize);
|
|
vid.full = fs;
|
|
float a, b, c, d;
|
|
err=fscanf(f, "%f%f%f%f\n", &a, &b, &c, &d);
|
|
if(err == 4) {
|
|
vid.scale = a; vid.eye = b; vid.alpha = c; vid.aspeed = d;
|
|
}
|
|
err=fscanf(f, "%d%d%d%d%d%d%d", &vid.wallmode, &vid.monmode, &vid.axes, &audiovolume, &vid.framelimit, &gl, &aa);
|
|
vid.usingGL = gl; vid.usingAA = aa;
|
|
err=fscanf(f, "%d%d%d%f%d%d", &vid.joyvalue, &vid.joyvalue2, &vid.joypanthreshold, &vid.joypanspeed, &aa, &vid.flashtime);
|
|
autojoy = aa; aa = 0;
|
|
|
|
loadcs(f, vid.cs);
|
|
|
|
aa=0; bb=0;
|
|
err=fscanf(f, "%d%d", &aa, &bb);
|
|
vid.darkhepta = aa; vid.shifttarget = bb;
|
|
|
|
aa = euclid; bb = euclidland; cc = shmup::on; dd = hardcore;
|
|
err=fscanf(f, "%d%d%d%d", &aa, &bb, &cc, &dd);
|
|
euclid = aa; euclidland = eLand(bb); shmup::on = cc; hardcore = dd;
|
|
|
|
shmup::loadConfig(f);
|
|
|
|
aa = rug::renderonce; bb = rug::rendernogl; cc = purehepta; dd = chaosmode; ee = vid.steamscore;
|
|
err=fscanf(f, "%d%d%d%d%lf%d%d", &aa, &bb, &rug::texturesize, &cc, &rug::scale, &ee, &dd);
|
|
rug::renderonce = aa; rug::rendernogl = bb; purehepta = cc; chaosmode = dd; vid.steamscore = ee;
|
|
|
|
aa=conformal::includeHistory;
|
|
err=fscanf(f, "%d%d%lf%d%d%lf",
|
|
&pmodel, &polygonal::SI, &polygonal::STAR, &polygonal::deg,
|
|
&aa, &conformal::lvspeed);
|
|
conformal::includeHistory = aa;
|
|
|
|
aa=conformal::autoband; bb=conformal::autobandhistory; cc=conformal::dospiral;
|
|
err=fscanf(f, "%d%d%d%d%d%d",
|
|
&conformal::bandhalf, &conformal::bandsegment, &conformal::rotation,
|
|
&aa, &bb, &cc);
|
|
conformal::autoband = aa; conformal::autobandhistory = bb; conformal::dospiral = cc;
|
|
|
|
err=fscanf(f, "%d", &polygonal::maxcoef);
|
|
if(polygonal::maxcoef < 0) polygonal::maxcoef = 0;
|
|
if(polygonal::maxcoef > MSI) polygonal::maxcoef = MSI;
|
|
for(int i=0; i<=polygonal::maxcoef; i++) {
|
|
double re=0, im=0;
|
|
err=fscanf(f, "%lf%lf", &re, &im);
|
|
polygonal::coef[i] = polygonal::cld(re, im);
|
|
}
|
|
|
|
fclose(f);
|
|
DEBB(DF_INIT, (debugfile,"Loaded configuration: %s\n", conffile));
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
if(clWidth) vid.xres = clWidth;
|
|
if(clHeight) vid.yres = clHeight;
|
|
if(clFont) vid.fsize = clFont;
|
|
|
|
for(int k=0; k<int(commandline.size()); k++) switch(commandline[k]) {
|
|
case 'f': vid.full = true; break;
|
|
case 'w': vid.full = false; break;
|
|
case 'e': vid.wallmode = 3; vid.monmode = 2; break;
|
|
case 'p': vid.wallmode = 2; vid.monmode = 2; break;
|
|
case 'a': vid.wallmode = 0; vid.monmode = 0; break;
|
|
case 'o': vid.usingGL = !vid.usingGL; break;
|
|
case char(200): vid.usingGL = false; break;
|
|
case char(201): vid.usingGL = true; break;
|
|
case 'O': vid.usingGL = false; break;
|
|
case 'E': euclid = !euclid; if(euclid) euclidland = firstland; break;
|
|
case 'S': shmup::on = !shmup::on; break;
|
|
case 'P': k++; vid.scfg.players = commandline[k]-'0'; break;
|
|
case 'H': hardcore = !hardcore; break;
|
|
case '7': purehepta = !purehepta; break;
|
|
case 'C': chaosmode = !chaosmode; break;
|
|
case 'T': tactic::on = !tactic::on; break;
|
|
case 'R': randomPatternsMode = !randomPatternsMode; break;
|
|
case 'D':
|
|
randomPatternsMode = false;
|
|
tactic::on = false;
|
|
hardcore = false;
|
|
vid.scfg.players = 1;
|
|
euclid = false;
|
|
shmup::on = false;
|
|
break;
|
|
}
|
|
#endif
|
|
precalc();
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
string musfname[landtypes];
|
|
|
|
bool loadMusicInfo(string dir) {
|
|
DEBB(DF_INIT, (debugfile,"load music info\n"));
|
|
if(dir == "") return false;
|
|
FILE *f = fopen(dir.c_str(), "rt");
|
|
if(f) {
|
|
string dir2;
|
|
for(int i=0; i<size(dir); i++) if(dir[i] == '/' || dir[i] == '\\')
|
|
dir2 = dir.substr(0, i+1);
|
|
char buf[1000];
|
|
while(fgets(buf, 800, f) > 0) {
|
|
for(int i=0; buf[i]; i++) if(buf[i] == 10 || buf[i] == 13) buf[i] = 0;
|
|
if(buf[0] == '[' && buf[3] == ']') {
|
|
int id = (buf[1] - '0') * 10 + buf[2] - '0';
|
|
if(id >= 0 && id < landtypes) {
|
|
if(buf[5] == '*' && buf[6] == '/') musfname[id] = dir2 + (buf+7);
|
|
else musfname[id] = buf+5;
|
|
}
|
|
else {
|
|
fprintf(stderr, "warning: bad soundtrack id, use the following format:\n");
|
|
fprintf(stderr, "[##] */filename\n");
|
|
fprintf(stderr, "where ## are two digits, and */ is optional and replaced by path to the music\n");
|
|
fprintf(stderr, "alternatively LAST = reuse the last track instead of having a special one");
|
|
}
|
|
// printf("[%2d] %s\n", id, buf);
|
|
}
|
|
else if(buf[0] == '#') {
|
|
}
|
|
else {
|
|
musiclicense += buf;
|
|
musiclicense += "\n";
|
|
}
|
|
}
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
void initJoysticks() {
|
|
DEBB(DF_INIT, (debugfile,"init joysticks\n"));
|
|
numsticks = SDL_NumJoysticks();
|
|
if(numsticks > 8) numsticks = 8;
|
|
for(int i=0; i<numsticks; i++) {
|
|
sticks[i] = SDL_JoystickOpen(i);
|
|
/* printf("axes = %d, balls = %d, buttons = %d, hats = %d\n",
|
|
SDL_JoystickNumAxes(sticks[i]),
|
|
SDL_JoystickNumBalls(sticks[i]),
|
|
SDL_JoystickNumButtons(sticks[i]),
|
|
SDL_JoystickNumHats(sticks[i])
|
|
); */
|
|
}
|
|
}
|
|
|
|
void closeJoysticks() {
|
|
DEBB(DF_INIT, (debugfile,"close joysticks\n"));
|
|
for(int i=0; i<numsticks; i++) {
|
|
SDL_JoystickClose(sticks[i]), sticks[i] = NULL;
|
|
}
|
|
numsticks = 0;
|
|
}
|
|
#endif
|
|
|
|
void initgraph() {
|
|
|
|
DEBB(DF_INIT, (debugfile,"initgraph\n"));
|
|
|
|
vid.usingGL = true;
|
|
vid.usingAA = true;
|
|
vid.flashtime = 8;
|
|
vid.scale = 1;
|
|
vid.alpha = 1;
|
|
vid.aspeed = 0;
|
|
vid.eye = 0;
|
|
vid.full = false;
|
|
vid.quick = true;
|
|
vid.wallmode = 3;
|
|
|
|
vid.joyvalue = 4800;
|
|
vid.joyvalue2 = 5600;
|
|
vid.joypanthreshold = 2500;
|
|
#ifdef PANDORA
|
|
vid.joypanspeed = 0.0001;
|
|
#else
|
|
vid.joypanspeed = 0;
|
|
#endif
|
|
|
|
vid.framelimit = 75;
|
|
vid.monmode = 2;
|
|
vid.axes = 1;
|
|
vid.steamscore = true;
|
|
|
|
initcs(vid.cs);
|
|
|
|
vid.killreduction = 0;
|
|
|
|
vid.samegender = false;
|
|
vid.language = -1;
|
|
|
|
joyx = joyy = 0; joydir.d = -1;
|
|
|
|
shmup::initConfig();
|
|
|
|
restartGraph();
|
|
|
|
initgeo();
|
|
|
|
buildpolys();
|
|
|
|
#ifndef MOBILE
|
|
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) == -1)
|
|
{
|
|
printf("Failed to initialize video.\n");
|
|
exit(2);
|
|
}
|
|
const SDL_VideoInfo *inf = SDL_GetVideoInfo();
|
|
vid.xscr = vid.xres = inf->current_w;
|
|
vid.yscr = vid.yres = inf->current_h;
|
|
|
|
SDL_WM_SetCaption("HyperRogue " VER, "HyperRogue " VER);
|
|
|
|
loadConfig();
|
|
|
|
setvideomode();
|
|
if(!s) {
|
|
printf("Failed to initialize graphics.\n");
|
|
exit(2);
|
|
}
|
|
|
|
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
|
|
SDL_EnableUNICODE(1);
|
|
|
|
if(TTF_Init() != 0) {
|
|
printf("Failed to initialize TTF.\n");
|
|
exit(2);
|
|
}
|
|
|
|
initJoysticks();
|
|
|
|
#ifdef AUDIO
|
|
|
|
audio =
|
|
loadMusicInfo(musicfile)
|
|
|| loadMusicInfo("./hyperrogue-music.txt")
|
|
|| loadMusicInfo("music/hyperrogue-music.txt")
|
|
// Destination set by ./configure (in the GitHub repository)
|
|
#ifdef MUSICDESTDIR
|
|
|| loadMusicInfo(MUSICDESTDIR)
|
|
#endif
|
|
#ifdef FHS
|
|
|| loadMusicInfo("/usr/share/hyperrogue/hyperrogue-music.txt")
|
|
|| loadMusicInfo(s0 + getenv("HOME") + "/.hyperrogue-music.txt")
|
|
#endif
|
|
;
|
|
|
|
if(audio) {
|
|
if(Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 4096) != 0) {
|
|
fprintf(stderr, "Unable to initialize audio: %s\n", Mix_GetError());
|
|
audio = false;
|
|
}
|
|
else {
|
|
audio = true;
|
|
Mix_AllocateChannels(4);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
|
|
int frames;
|
|
bool outoffocus = false;
|
|
|
|
#ifdef AUDIO
|
|
|
|
bool loaded[landtypes];
|
|
Mix_Music* music[landtypes];
|
|
int musicpos[landtypes];
|
|
int musstart;
|
|
int musfadeval = 2000;
|
|
|
|
eLand cid = laNone;
|
|
|
|
void handlemusic() {
|
|
DEBB(DF_GRAPH, (debugfile,"handle music\n"));
|
|
if(audio && audiovolume) {
|
|
eLand id = cwt.c->land;
|
|
if(isHaunted(id)) id = laHaunted;
|
|
if(id == laGridSea) id = laGridCoast;
|
|
#ifdef LOCAL
|
|
extern bool local_changemusic(eLand& id);
|
|
if(local_changemusic(id)) return;
|
|
#endif
|
|
if(outoffocus) id = eLand(0);
|
|
if(musfname[id] == "LAST") id = cid;
|
|
if(!loaded[id]) {
|
|
loaded[id] = true;
|
|
// printf("loading (%d)> %s\n", id, musfname[id].c_str());
|
|
if(musfname[id] != "") {
|
|
music[id] = Mix_LoadMUS(musfname[id].c_str());
|
|
if(!music[id]) {
|
|
printf("Mix_LoadMUS: %s\n", Mix_GetError());
|
|
}
|
|
}
|
|
}
|
|
if(cid != id && !musfadeval) {
|
|
musicpos[cid] = SDL_GetTicks() - musstart;
|
|
musfadeval = musicpos[id] ? 500 : 2000;
|
|
Mix_FadeOutMusic(musfadeval);
|
|
// printf("fadeout %d, pos %d\n", musfadeval, musicpos[cid]);
|
|
}
|
|
if(music[id] && !Mix_PlayingMusic()) {
|
|
cid = id;
|
|
Mix_VolumeMusic(audiovolume);
|
|
Mix_FadeInMusicPos(music[id], -1, musfadeval, musicpos[id] / 1000.0);
|
|
// printf("fadein %d, pos %d\n", musfadeval, musicpos[cid]);
|
|
musstart = SDL_GetTicks() - musicpos[id];
|
|
musicpos[id] = 0;
|
|
musfadeval = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void resetmusic() {
|
|
if(audio && audiovolume) {
|
|
Mix_FadeOutMusic(3000);
|
|
cid = laNone;
|
|
for(int i=0; i<landtypes; i++) musicpos[i] = 0;
|
|
musfadeval = 2000;
|
|
}
|
|
}
|
|
|
|
#else
|
|
void resetmusic() {}
|
|
#endif
|
|
|
|
void panning(hyperpoint hf, hyperpoint ht) {
|
|
View =
|
|
rgpushxto0(hf) * rgpushxto0(gpushxto0(hf) * ht) * gpushxto0(hf) * View;
|
|
playermoved = false;
|
|
}
|
|
|
|
#ifdef LOCAL
|
|
#include "local.cpp"
|
|
#endif
|
|
|
|
void resetview() {
|
|
DEBB(DF_GRAPH, (debugfile,"reset view\n"));
|
|
View = Id;
|
|
// EUCLIDEAN
|
|
if(!euclid) viewctr.h = cwt.c->master;
|
|
else centerover = cwt.c;
|
|
// SDL_LockSurface(s);
|
|
// SDL_UnlockSurface(s);
|
|
}
|
|
|
|
void fullcenter() {
|
|
if(playerfound && false) centerpc(INF);
|
|
else {
|
|
resetview();
|
|
drawthemap();
|
|
centerpc(INF);
|
|
}
|
|
playermoved = true;
|
|
}
|
|
|
|
#ifndef MOBILE
|
|
|
|
// Warning: a very long function! todo: refactor
|
|
|
|
void mainloop() {
|
|
int lastt = 0;
|
|
cmode = emNormal;
|
|
while(true) {
|
|
|
|
DEBB(DF_GRAPH, (debugfile,"main loop\n"));
|
|
|
|
#ifndef GFX
|
|
#ifndef GL
|
|
vid.wallmode = 0;
|
|
vid.monmode = 0;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef LOCAL
|
|
process_local_extra();
|
|
#endif
|
|
|
|
optimizeview();
|
|
|
|
if(conformal::on) conformal::apply();
|
|
|
|
ticks = SDL_GetTicks();
|
|
|
|
int cframelimit = vid.framelimit;
|
|
if((cmode == emVisual1 || cmode == emVisual2 || cmode == emHelp || cmode == emQuit ||
|
|
cmode == emCustomizeChar || cmode == emMenu || cmode == emPickEuclidean ||
|
|
cmode == emScores || cmode == emPickScores) && cframelimit > 15)
|
|
cframelimit = 15;
|
|
if(outoffocus && cframelimit > 10) cframelimit = 10;
|
|
|
|
int timetowait = lastt + 1000 / cframelimit - ticks;
|
|
|
|
if(shmup::on && cmode == emNormal)
|
|
timetowait = 0, shmup::turn(ticks - lastt);
|
|
|
|
if(timetowait > 0)
|
|
SDL_Delay(timetowait);
|
|
else {
|
|
if(playermoved && vid.aspeed > -4.99 && !outoffocus)
|
|
centerpc((ticks - lastt) / 1000.0 * exp(vid.aspeed));
|
|
if(panjoyx || panjoyy)
|
|
checkpanjoy((ticks - lastt) / 1000.0);
|
|
tortoise::updateVals(ticks - lastt);
|
|
lastt = ticks;
|
|
frames++;
|
|
if(!outoffocus) {
|
|
drawscreen();
|
|
}
|
|
}
|
|
|
|
Uint8 *keystate = SDL_GetKeyState(NULL);
|
|
rightclick = keystate[SDLK_RCTRL];
|
|
leftclick = keystate[SDLK_RSHIFT];
|
|
hiliteclick = keystate[SDLK_LALT] | keystate[SDLK_RALT];
|
|
anyshiftclick = keystate[SDLK_LSHIFT] | keystate[SDLK_RSHIFT];
|
|
|
|
bool didsomething = false;
|
|
|
|
if(vid.shifttarget) {
|
|
leftclick = false;
|
|
targetclick = keystate[SDLK_RSHIFT] | keystate[SDLK_LSHIFT];
|
|
}
|
|
else {
|
|
leftclick = keystate[SDLK_RSHIFT];
|
|
targetclick = true;
|
|
}
|
|
|
|
#ifdef AUDIO
|
|
if(audio) handlemusic();
|
|
#endif
|
|
SDL_Event ev;
|
|
DEBB(DF_GRAPH, (debugfile,"polling for events\n"));
|
|
|
|
achievement_pump();
|
|
while(SDL_PollEvent(&ev)) {
|
|
DEBB(DF_GRAPH, (debugfile,"got event type #%d\n", ev.type));
|
|
int sym = 0;
|
|
int uni = 0;
|
|
shiftmul = 1;
|
|
|
|
/* if(ev.type == SDL_JOYDEVICEADDED || ev.type == SDL_JOYDEVICEREMOVED) {
|
|
joyx = joyy = 0;
|
|
panjoyx = panjoyy = 0;
|
|
closeJoysticks();
|
|
initJoysticks();
|
|
}*/
|
|
|
|
if(ev.type == SDL_ACTIVEEVENT) {
|
|
if(ev.active.state & SDL_APPINPUTFOCUS) {
|
|
if(ev.active.gain) {
|
|
outoffocus = false;
|
|
}
|
|
else {
|
|
outoffocus = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(ev.type == SDL_VIDEORESIZE) {
|
|
vid.xres = ev.resize.w;
|
|
vid.yres = ev.resize.h;
|
|
vid.killreduction = 0;
|
|
extern bool setfsize;
|
|
setfsize = true;
|
|
setvideomode();
|
|
#ifdef GL
|
|
if(vid.usingGL) glViewport(0, 0, vid.xres, vid.yres);
|
|
#endif
|
|
}
|
|
|
|
if(ev.type == SDL_VIDEOEXPOSE) {
|
|
drawscreen();
|
|
}
|
|
|
|
if(ev.type == SDL_JOYAXISMOTION) {
|
|
flashMessages();
|
|
if(ev.jaxis.value != 0)
|
|
printf("which = %d axis = %d value = %d\n",
|
|
ev.jaxis.which,
|
|
ev.jaxis.axis,
|
|
ev.jaxis.value);
|
|
if(ev.jaxis.which == 0) {
|
|
if(ev.jaxis.axis == 0)
|
|
joyx = ev.jaxis.value;
|
|
else if(ev.jaxis.axis == 1)
|
|
joyy = ev.jaxis.value;
|
|
else if(ev.jaxis.axis == 3)
|
|
panjoyx = ev.jaxis.value;
|
|
else if(ev.jaxis.axis == 4)
|
|
panjoyy = ev.jaxis.value;
|
|
checkjoy();
|
|
// printf("panjoy = %d,%d\n", panjoyx, panjoyy);
|
|
}
|
|
else {
|
|
if(ev.jaxis.axis == 0)
|
|
panjoyx = ev.jaxis.value;
|
|
else
|
|
panjoyy = ev.jaxis.value;
|
|
}
|
|
}
|
|
|
|
if(ev.type == SDL_JOYBUTTONDOWN && cmode == emShmupConfig && vid.scfg.setwhat) {
|
|
int joyid = ev.jbutton.which;
|
|
int button = ev.jbutton.button;
|
|
if(joyid < 8 && button < 32)
|
|
vid.scfg.joyaction[joyid][button] = vid.scfg.setwhat;
|
|
vid.scfg.setwhat = 0;
|
|
}
|
|
|
|
else if(ev.type == SDL_JOYHATMOTION && cmode == emShmupConfig && vid.scfg.setwhat) {
|
|
int joyid = ev.jhat.which;
|
|
int hat = ev.jhat.hat;
|
|
int dir = 4;
|
|
if(ev.jhat.value == SDL_HAT_UP) dir = 0;
|
|
if(ev.jhat.value == SDL_HAT_RIGHT) dir = 1;
|
|
if(ev.jhat.value == SDL_HAT_DOWN) dir = 2;
|
|
if(ev.jhat.value == SDL_HAT_LEFT) dir = 3;
|
|
if(joyid < 8 && hat < 4 && dir < 4) {
|
|
vid.scfg.hataction[joyid][hat][dir] = vid.scfg.setwhat;
|
|
vid.scfg.setwhat = 0;
|
|
}
|
|
}
|
|
|
|
else if(ev.type == SDL_JOYBUTTONDOWN && !shmup::on) {
|
|
flashMessages();
|
|
movepcto(joydir);
|
|
checkjoy();
|
|
}
|
|
|
|
if(ev.type == SDL_KEYDOWN) {
|
|
flashMessages();
|
|
mousing = false;
|
|
sym = ev.key.keysym.sym;
|
|
uni = ev.key.keysym.unicode;
|
|
if(ev.key.keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT)) shiftmul = -1;
|
|
if(ev.key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) shiftmul /= 10;
|
|
}
|
|
|
|
if(ev.type == SDL_MOUSEBUTTONDOWN) {
|
|
flashMessages();
|
|
mousepressed = true;
|
|
mousing = true;
|
|
if(ev.button.button==SDL_BUTTON_RIGHT || leftclick)
|
|
sym = SDLK_F1;
|
|
else if(ev.button.button==SDL_BUTTON_MIDDLE || rightclick)
|
|
sym = 1, didsomething = true;
|
|
else if(ev.button.button==SDL_BUTTON_WHEELUP && ((cmode == emQuit) ^ !canmove)) {
|
|
sym = 1; msgscroll++; didsomething = true;
|
|
}
|
|
else if(ev.button.button==SDL_BUTTON_WHEELDOWN && ((cmode == emQuit) ^ !canmove)) {
|
|
sym = 1; msgscroll--; didsomething = true;
|
|
}
|
|
else if(ev.button.button==SDL_BUTTON_WHEELUP) {
|
|
ld jx = (mousex - vid.xcenter - .0) / vid.radius / 10;
|
|
ld jy = (mousey - vid.ycenter - .0) / vid.radius / 10;
|
|
playermoved = false;
|
|
View = gpushxto0(hpxy(jx, jy)) * View;
|
|
sym = 1;
|
|
}
|
|
else {
|
|
sym = getcstat, uni = getcstat, shiftmul = getcshift;
|
|
}
|
|
}
|
|
|
|
if(ev.type == SDL_MOUSEBUTTONUP)
|
|
mousepressed = false;
|
|
|
|
if(((cmode == emNormal && canmove) || (cmode == emQuit && !canmove) || cmode == emDraw || cmode == emMapEditor) && !shmup::on && !rug::rugged) {
|
|
#ifndef PANDORA
|
|
if(sym == SDLK_RIGHT)
|
|
View = xpush(-0.2*shiftmul) * View, playermoved = false, didsomething = true;
|
|
if(sym == SDLK_LEFT)
|
|
View = xpush(+0.2*shiftmul) * View, playermoved = false, didsomething = true;
|
|
if(sym == SDLK_UP)
|
|
View = ypush(+0.2*shiftmul) * View, playermoved = false, didsomething = true;
|
|
if(sym == SDLK_DOWN)
|
|
View = ypush(-0.2*shiftmul) * View, playermoved = false, didsomething = true;
|
|
#endif
|
|
if(sym == SDLK_PAGEUP) {
|
|
View = spin(M_PI/21*shiftmul) * View, didsomething = true;
|
|
}
|
|
if(sym == SDLK_PAGEDOWN)
|
|
View = spin(-M_PI/21*shiftmul) * View, didsomething = true;
|
|
|
|
if(sym == SDLK_PAGEUP || sym == SDLK_PAGEDOWN)
|
|
if(isGravityLand(cwt.c->land)) playermoved = false;
|
|
}
|
|
|
|
if(ev.type == SDL_MOUSEMOTION) {
|
|
hyperpoint mouseoh = mouseh;
|
|
|
|
mousing = true;
|
|
mousex = ev.motion.x;
|
|
mousey = ev.motion.y;
|
|
if(rug::rugged)
|
|
mouseh = rug::gethyper(mousex, mousey);
|
|
else
|
|
mouseh = gethyper(mousex, mousey);
|
|
|
|
if((rightclick || (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON_MMASK)) &&
|
|
!outofmap(mouseh) && !outofmap(mouseoh) &&
|
|
mouseh[2] < 50 && mouseoh[2] < 50) {
|
|
panning(mouseoh, mouseh);
|
|
}
|
|
|
|
#ifdef SIMULATE_JOYSTICK
|
|
// pretend that both joysticks are present
|
|
stick = panstick = (SDL_Joystick*) (&vid);
|
|
panjoyx = 20 * (mousex - vid.xcenter);
|
|
panjoyy = 20 * (mousey - vid.ycenter);
|
|
checkjoy();
|
|
#endif
|
|
}
|
|
|
|
if(sym == SDLK_F7 && !vid.usingGL) {
|
|
|
|
time_t timer;
|
|
timer = time(NULL);
|
|
char buf[128]; strftime(buf, 128, "shot-%y%m%d-%H%M%S" IMAGEEXT, localtime(&timer));
|
|
|
|
IMAGESAVE(s, buf);
|
|
addMessage(XLAT("Screenshot saved to %1", buf));
|
|
}
|
|
|
|
if(cmode == emNormal) {
|
|
|
|
if(cheater) {
|
|
if(applyCheat(uni, mouseover))
|
|
sym = 0;
|
|
}
|
|
|
|
if(!(uni >= 'A' && uni <= 'Z') && !shmup::on) {
|
|
if(sym == 'l' || sym == 'd' || sym == SDLK_KP6) movepckeydir(0);
|
|
if(sym == 'n' || sym == 'c' || sym == SDLK_KP3) movepckeydir(1);
|
|
if(sym == 'j' || sym == 'x' || sym == SDLK_KP2) movepckeydir(2);
|
|
if(sym == 'b' || sym == 'z' || sym == SDLK_KP1) movepckeydir(3);
|
|
if(sym == 'h' || sym == 'a' || sym == SDLK_KP4) movepckeydir(4);
|
|
if(sym == 'y' || sym == 'q' || sym == SDLK_KP7) movepckeydir(5);
|
|
if(sym == 'k' || sym == 'w' || sym == SDLK_KP8) movepckeydir(6);
|
|
if(sym == 'u' || sym == 'e' || sym == SDLK_KP9) movepckeydir(7);
|
|
}
|
|
|
|
#ifdef PANDORA
|
|
if(!shmup::on) {
|
|
if(sym == SDLK_RIGHT) movepckeydir(0);
|
|
if(sym == SDLK_LEFT) movepckeydir(4);
|
|
if(sym == SDLK_DOWN) movepckeydir(2 + (leftclick?1:0) - (rightclick?1:0));
|
|
if(sym == SDLK_UP) movepckeydir(6 - (leftclick?1:0) + (rightclick?1:0));
|
|
}
|
|
#endif
|
|
|
|
if(!shmup::on) {
|
|
if(sym == '.' || sym == 's') movepcto(-1, 1);
|
|
if((sym == SDLK_DELETE || sym == SDLK_KP_PERIOD || sym == 'g') && uni != 'G' && uni != 'G'-64)
|
|
movepcto(-2, 1);
|
|
if(sym == 't' && uni != 'T' && uni != 'T'-64 && canmove && cmode == emNormal) {
|
|
if(playermoved && items[itStrongWind]) {
|
|
cell *c = whirlwind::jumpDestination(cwt.c);
|
|
if(c) centerover = c;
|
|
}
|
|
targetRangedOrb(centerover, roKeyboard);
|
|
sym = 0; uni = 0;
|
|
}
|
|
}
|
|
|
|
if(sym == SDLK_KP5 && !shmup::on) movepcto(-1, 1);
|
|
|
|
// if(sym == SDLK_F4) restartGameSwitchEuclid();
|
|
|
|
if(sym == SDLK_F5) restartGame();
|
|
if(sym == SDLK_ESCAPE) {
|
|
cmode = emQuit;
|
|
achievement_final(false);
|
|
if(!canmove) {
|
|
addMessage(XLAT("GAME OVER"));
|
|
addMessage(timeline());
|
|
}
|
|
msgscroll = 0;
|
|
}
|
|
if(sym == SDLK_F10) return;
|
|
|
|
if(!canmove) {
|
|
if(sym == SDLK_RETURN) return;
|
|
else if(uni == 'r') restartGame();
|
|
else if(uni == 't') {
|
|
restartGame();
|
|
loadScores();
|
|
}
|
|
else if(rug::rugged) ;
|
|
else if(sym == SDLK_UP || sym == SDLK_KP8) msgscroll++;
|
|
else if(sym == SDLK_DOWN || sym == SDLK_KP2) msgscroll--;
|
|
else if(sym == SDLK_PAGEUP || sym == SDLK_KP9) msgscroll+=5;
|
|
else if(sym == SDLK_PAGEDOWN || sym == SDLK_KP3) msgscroll-=5;
|
|
}
|
|
|
|
if(uni == 'o') setAppropriateOverview();
|
|
|
|
if(sym == SDLK_HOME || sym == SDLK_F3 || (sym == ' ' && !shmup::on))
|
|
fullcenter();
|
|
|
|
/* if(sym == SDLK_F6) {
|
|
View = spin(M_PI/2) * inverse(cwtV) * View;
|
|
if(flipplayer) View = spin(M_PI) * View;
|
|
cmode = emDraw;
|
|
} */
|
|
|
|
if(sym == 'v') {
|
|
cmode = emMenu;
|
|
}
|
|
|
|
if(sym == SDLK_F2) {
|
|
cmode = emVisual1;
|
|
}
|
|
|
|
#ifdef PANDORA
|
|
if(ev.type == SDL_MOUSEBUTTONUP && sym == 0 && !rightclick)
|
|
#else
|
|
if(ev.type == SDL_MOUSEBUTTONDOWN && sym == 0 && !rightclick)
|
|
#endif
|
|
{
|
|
bool forcetarget = (keystate[SDLK_RSHIFT] | keystate[SDLK_LSHIFT]);
|
|
|
|
shmup::cpid = 0;
|
|
if(mouseover && targetclick && (numplayers() == 1) && targetRangedOrb(mouseover, forcetarget ? roMouseForce : roMouse))
|
|
;
|
|
else if(forcetarget)
|
|
;
|
|
else if(shmup::on)
|
|
;
|
|
else mousemovement();
|
|
}
|
|
|
|
if(sym == SDLK_F1) {
|
|
lastmode = cmode;
|
|
cmode = emHelp;
|
|
}
|
|
|
|
#ifdef LOCAL
|
|
process_local0(sym);
|
|
#endif
|
|
}
|
|
|
|
else if(cmode == emMenu) { if(handleMenuKey(sym, ev.type == SDL_MOUSEBUTTONDOWN)) return; }
|
|
else if(cmode == emCheatMenu) handleCheatMenu(uni);
|
|
else if(cmode == emVisual1) handleVisual1(sym, uni);
|
|
else if(cmode == emCustomizeChar) handleCustomizeChar(sym, uni, ev.key.keysym.mod);
|
|
else if(cmode == emVisual2) handleVisual2(sym, uni);
|
|
else if(cmode == emChangeMode) handleChangeMode(sym, uni);
|
|
else if(cmode == emShmupConfig) shmup::handleConfig(uni, sym);
|
|
else if(cmode == emNetgen) netgen::handleKey(uni, sym);
|
|
else if(cmode == emRugConfig) rug::handleKey(uni, sym);
|
|
else if(cmode == emConformal) conformal::handleKey(uni, sym);
|
|
else if(cmode == emYendor) yendor::handleKey(uni, sym);
|
|
else if(cmode == emTactic) tactic::handleKey(uni, sym);
|
|
else if(cmode == emMapEditor) mapeditor::handleKey(uni, sym);
|
|
else if(cmode == emOverview) handleOverview(uni);
|
|
else if(cmode == emDraw) mapeditor::drawHandleKey(uni, sym, shiftmul);
|
|
else if(cmode == emPickEuclidean) handleEuclidean(sym, uni);
|
|
else if(cmode == emScores) handleScoreKeys(sym, ev);
|
|
else if(cmode == emPickScores) handlePickScoreKeys(uni, ev);
|
|
|
|
else if(cmode == emHelp) {
|
|
if(sym == SDLK_F1 && help != "@")
|
|
help = "@";
|
|
else if(uni == 'c')
|
|
help = buildCredits();
|
|
else if((sym != 0 && sym != SDLK_F12) || ev.type == SDL_MOUSEBUTTONDOWN)
|
|
cmode = lastmode;
|
|
}
|
|
|
|
else if(cmode == emQuit) {
|
|
// ignore the camera movement keys
|
|
if(rug::rugged && (sym == SDLK_UP || sym == SDLK_DOWN || sym == SDLK_PAGEUP || sym == SDLK_PAGEDOWN ||
|
|
sym == SDLK_RIGHT || sym == SDLK_LEFT))
|
|
sym = 0;
|
|
|
|
if(sym == SDLK_RETURN || sym == SDLK_F10) return;
|
|
else if(uni == 'r' || sym == SDLK_F5) {
|
|
restartGame(), cmode = emNormal;
|
|
msgs.clear();
|
|
}
|
|
else if(sym == SDLK_UP || sym == SDLK_KP8) msgscroll++;
|
|
else if(sym == SDLK_DOWN || sym == SDLK_KP2) msgscroll--;
|
|
else if(sym == SDLK_PAGEUP || sym == SDLK_KP9) msgscroll+=5;
|
|
else if(sym == SDLK_PAGEDOWN || sym == SDLK_KP3) msgscroll-=5;
|
|
else if(uni == 'v') cmode = emMenu;
|
|
else if(sym == SDLK_HOME || sym == SDLK_F3 || (sym == ' ' && !shmup::on))
|
|
fullcenter();
|
|
else if(uni == 'o') setAppropriateOverview();
|
|
else if(uni == 't') {
|
|
if(!canmove) restartGame();
|
|
loadScores();
|
|
msgs.clear();
|
|
}
|
|
|
|
else if(((sym != 0 && sym != SDLK_F12) || ev.type == SDL_MOUSEBUTTONDOWN) && !didsomething) {
|
|
cmode = emNormal;
|
|
msgscroll = 0;
|
|
msgs.clear();
|
|
}
|
|
}
|
|
|
|
if(ev.type == SDL_QUIT)
|
|
return;
|
|
|
|
}
|
|
|
|
if(playerdead) break;
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
#ifndef MOBILE
|
|
void cleargraph() {
|
|
DEBB(DF_INIT, (debugfile,"clear graph\n"));
|
|
for(int i=0; i<256; i++) if(font[i]) TTF_CloseFont(font[i]);
|
|
for(int i=0; i<128; i++) if(glfont[i]) delete glfont[i];
|
|
#ifndef SIMULATE_JOYSTICK
|
|
closeJoysticks();
|
|
#endif
|
|
SDL_Quit();
|
|
}
|
|
#endif
|
|
|
|
void cleargraphmemory() {
|
|
DEBB(DF_INIT, (debugfile,"clear graph memory\n"));
|
|
mouseover = centerover = lmouseover = NULL;
|
|
#ifndef MOBILE
|
|
if(mapeditor::painttype == 4)
|
|
mapeditor::painttype = 0, mapeditor::paintwhat = 0,
|
|
mapeditor::paintwhat_str = "clear monster";
|
|
mapeditor::copywhat = NULL;
|
|
mapeditor::undo.clear();
|
|
if(!cheater) mapeditor::displaycodes = 0;
|
|
if(!cheater) mapeditor::whichShape = 0;
|
|
#endif
|
|
}
|
|
|
|
void showMissionScreen() {
|
|
cmode = emQuit;
|
|
msgscroll = 0;
|
|
}
|