/*
 * chess.c - part of the chess demo in the glut distribution.
 *
 * (C) Henk Kok (kok@wins.uva.nl)
 *
 * This file can be freely copied,changed,redistributed,etc. as long as
 * this copyright notice stays intact.
 */

#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>
#include <math.h>
#include "chess.h"

#if 0
/* Uncomment to debug various scenarios. */
#undef GL_VERSION_1_1
#undef GL_EXT_texture_object
#undef GL_EXT_texture
#endif

#ifndef GL_VERSION_1_1

#if defined(GL_EXT_texture_object) && defined(GL_EXT_texture)
#define glGenTextures glGenTexturesEXT
#define glBindTexture glBindTextureEXT
#else
#define USE_DISPLAY_LISTS
#endif

#endif

/* Some <math.h> files do not define M_PI... */
#ifndef M_PI
#define M_PI 3.1415926536F
#endif

int texturing = 0;
int reflection = 0;
int chaos = 0;
int chaosPieces = 0;
int animating = 1;
static GLuint texName[3];

extern int path[10][10],piece,piece2;

extern GLfloat CX1,CY1,CX2,CY2,CZ2;

#define WIT 0
#define ZWART 16

int board[10][10];

GLubyte white_square[TXSX][TXSY][3];
GLubyte black_square[TXSX][TXSY][3];
GLubyte wood[TXSX][TXSY][3];

extern GLfloat lightpos[];

GLfloat buf[256],phase;
GLfloat transl[48];
int list[48];
GLfloat width[144],height[144];
GLfloat bwidth,bheight;
int cycle[10][10],cyclem,cycle2;
int stunt[10][10],stuntm,stunt2;
GLfloat blackamb[4] = { 0.2F,0.1F,0.1F,0.5F };
GLfloat blackdif[4] = { 0.2F,0.1F,0.0F,0.5F };
GLfloat blackspec[4] = { 0.5F,0.5F,0.5F,0.5F };
GLfloat whiteamb[4] = { 0.7F,0.7F,0.4F,0.5F };
GLfloat whitedif[4] = { 0.8F,0.7F,0.4F,0.5F };
GLfloat whitespec[4] = { 0.8F,0.7F,0.4F,0.5F };
GLfloat copperamb[4] = { 0.24F,0.2F,0.07F,1.0F };
GLfloat copperdif[4] = { 0.75F,0.61F,0.22F,1.0F };
GLfloat copperspec[4] = { 0.32F,0.25F,0.17F,1.0F };
GLfloat darkamb[4] = { 0.10F,0.10F,0.10F,1.0F };
GLfloat darkdif[4] = { 0.6F,0.6F,0.6F,1.0F };
GLfloat darkspec[4] = { 0.25F,0.25F,0.25F,1.0F };
GLdouble ClipPlane[4] = { 0.0,1.0,0.0,0.0 };

void white_texture(void) {
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,whitedif);
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,whiteamb);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,whitespec);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,40.0);
}

void black_texture(void) {
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,blackdif);
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,blackamb);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,blackspec);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,40.0);
}

void copper_texture(void) {
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,copperdif);
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,copperamb);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,copperspec);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,40.0);
}

void dark_texture(void) {
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,darkdif);
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,darkamb);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,darkspec);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,40.0);
}

void border_texture(void) {
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,copperdif);
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,copperamb);
  glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,copperspec);
  glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,90.0);
}

void init_textures(void) {
#if !defined(USE_DISPLAY_LISTS)
  glGenTextures(3,texName);
#else
  texName[0] = 1000;
  texName[1] = 1001;
  texName[2] = 1002;
#endif
  GenerateTextures();
  glPixelStorei(GL_UNPACK_ALIGNMENT,1);
#if !defined(USE_DISPLAY_LISTS)
  glBindTexture(GL_TEXTURE_2D,texName[0]);
#else
  glNewList(texName[0],GL_COMPILE);
#endif
  glTexImage2D(GL_TEXTURE_2D,0,3,TXSX,TXSY,0,GL_RGB,GL_UNSIGNED_BYTE,&wood[0][0][0]);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
#if defined(USE_DISPLAY_LISTS)
  glEndList();
#endif
#if !defined(USE_DISPLAY_LISTS)
  glBindTexture(GL_TEXTURE_2D,texName[1]);
#else
  glNewList(texName[1],GL_COMPILE);
#endif
  glTexImage2D(GL_TEXTURE_2D,0,3,TXSX,TXSY,0,GL_RGB,GL_UNSIGNED_BYTE,&white_square[0][0][0]);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
#if defined(USE_DISPLAY_LISTS)
  glEndList();
#endif
#if !defined(USE_DISPLAY_LISTS)
  glBindTexture(GL_TEXTURE_2D,texName[2]);
#else
  glNewList(texName[2],GL_COMPILE);
#endif
  glTexImage2D(GL_TEXTURE_2D,0,3,TXSX,TXSY,0,GL_RGB,GL_UNSIGNED_BYTE,&black_square[0][0][0]);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
#if defined(USE_DISPLAY_LISTS)
  glEndList();
#endif
}

void do_border(void) {
  glPushMatrix();
  glTranslatef(-0.5,0.0,-0.5);
  if (texturing) {
#if !defined(USE_DISPLAY_LISTS)
    glBindTexture(GL_TEXTURE_2D,texName[0]);
#else
    glCallList(texName[0]);
#endif
    glEnable(GL_TEXTURE_2D); } 
    else
    border_texture();
  glBegin(GL_QUADS);
  glNormal3f(0.0F,1.0F,0.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(0.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(8.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(8.5F,0.08F,-0.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(-0.5F,0.08F,-0.5F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(8.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(8.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(8.5F,0.08F,8.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(8.5F,0.08F,-0.5F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(8.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(0.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(-0.5F,0.08F,8.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(8.5F,0.08F,8.5F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(0.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(0.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(-0.5F,0.08F,-0.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(-0.5F,0.08F,8.5F);
  glEnd();
  glBegin(GL_QUADS);
  glNormal3f(0.0F,0.0F,1.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(0.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(8.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(8.0F,-0.08F,0.0F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(0.0F,-0.08F,0.0F);
  glNormal3f(0.0F,1.0F,0.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(8.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(8.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(8.0F,-0.08F,8.0F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(8.0F,-0.08F,0.0F);
  glNormal3f(0.0F,0.0F,1.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(8.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(0.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(0.0F,-0.08F,8.0F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(8.0F,-0.08F,8.0F);
  glNormal3f(0.0F,1.0F,0.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(0.0F,0.08F,8.0F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(0.0F,0.08F,0.0F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(0.0F,-0.08F,0.0F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(0.0F,-0.08F,8.0F);
  glEnd();
  glBegin(GL_QUADS);
  glNormal3f(0.0F,0.0F,1.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(-0.5F,0.08F,-0.5F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(8.5F,0.08F,-0.5F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(8.5F,-0.08F,-0.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(-0.5F,-0.08F,-0.5F);
  glNormal3f(0.0F,1.0F,0.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(8.5F,0.08F,-0.5F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(8.5F,0.08F,8.5F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(8.5F,-0.08F,8.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(8.5F,-0.08F,-0.5F);
  glNormal3f(0.0F,0.0F,1.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(8.5F,0.08F,8.5F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(-0.5F,0.08F,8.5F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(-0.5F,-0.08F,8.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(8.5F,-0.08F,8.5F);
  glNormal3f(0.0F,1.0F,0.0F);
  glTexCoord2f(0.0F,0.0F); 
  glVertex3f(-0.5F,0.08F,8.5F);
  glTexCoord2f(0.6F,0.0F); 
  glVertex3f(-0.5F,0.08F,-0.5F);
  glTexCoord2f(0.6F,0.6F); 
  glVertex3f(-0.5F,-0.08F,-0.5F);
  glTexCoord2f(0.0F,0.6F); 
  glVertex3f(-0.5F,-0.08F,8.5F);
  glEnd();
  if (texturing)
    glDisable(GL_TEXTURE_2D);
  glPopMatrix();
}

void do_vlakje(void) {
  glColor4f(1.0,1.0,1.0,1.0);
  glDisable(GL_LIGHTING);
  glPushMatrix();
  glTranslatef(-0.5,0.0,-0.5);
  glBegin(GL_QUADS);
  glVertex3f(0.0,0.0,0.0);
  glVertex3f(8.0,0.0,0.0);
  glVertex3f(8.0,0.0,8.0);
  glVertex3f(0.0,0.0,8.0);
  glEnd();
  glPopMatrix();
  glEnable(GL_LIGHTING);
}

void do_board(void) {
  int x,y;
  glPushMatrix();
  glTranslatef(-0.5,0.0,-0.5);
  white_texture();
  if (texturing) {
#if !defined(USE_DISPLAY_LISTS)
    glBindTexture(GL_TEXTURE_2D,texName[1]);
#else
    glCallList(texName[1]);
#endif
    glEnable(GL_TEXTURE_2D); }
  glBegin(GL_QUADS);
  glNormal3f(0.0,1.0,0.0);
  for (x=0;x<8;x++) {
    for (y=x%2;y<8;y+=2) {
      glTexCoord2f(0.2*x,0.2*y); glVertex3f(x,0,y);
      glTexCoord2f(0.17+0.2*x,0.2*y); glVertex3f(x+1,0,y);
      glTexCoord2f(0.17+0.2*x,0.17+0.2*y); glVertex3f(x+1,0,y+1);
      glTexCoord2f(0.2*x,0.17+0.2*y); glVertex3f(x,0,y+1); } }
  glEnd();
  if (texturing) {
    glDisable(GL_TEXTURE_2D);
#if !defined(USE_DISPLAY_LISTS)
    glBindTexture(GL_TEXTURE_2D,texName[2]);
#else
    glCallList(texName[2]);
#endif
    glEnable(GL_TEXTURE_2D); } 
    else
    black_texture();
  glBegin(GL_QUADS);
  glNormal3f(0.0,1.0,0.0);
  for (x=0;x<8;x++) {
    for (y=1-(x%2);y<8;y+=2) {
      glTexCoord2f(0.2*x,0.2*y); glVertex3f(x,0,y);
      glTexCoord2f(0.17+0.2*x,0.2*y); glVertex3f(x+1,0,y);
      glTexCoord2f(0.17+0.2*x,0.17+0.2*y); glVertex3f(x+1,0,y+1);
      glTexCoord2f(0.2*x,0.17+0.2*y); glVertex3f(x,0,y+1); } }
  glEnd();
  if (texturing)
    glDisable(GL_TEXTURE_2D);
  glPopMatrix();
}

void do_solid(GLfloat *f,int sz,GLfloat width) {
  GLfloat nx,ny,s;
  GLfloat length;
  int i,j;
  for (i=0;i<sz;i++)
    buf[i] = f[i]/4.2;
  for (i=0;i<sz;i+=2) {
    buf[i+1] = buf[i+1] * (1 - cos(phase)/3);
    buf[i] = buf[i] * (1+sin(M_PI*buf[i+1]/buf[1])*cos(phase)*0.7);
/*
  if (buf[i] > bwidth)
      bwidth = buf[i];
*/
    if (buf[i+1] > bheight)
      bheight = buf[i+1]; }
  glBegin(GL_QUAD_STRIP);
  for (i=2;i<sz;i+=2) {
    if (buf[i+3] == buf[i+1] && buf[i+2] == buf[i])
      continue;
    nx = buf[i-1] + buf[i+3];
    ny = buf[i+2] - buf[i];
    length = sqrt(nx*nx+ny*ny);
    nx = nx/length;
    ny = ny/length;
    s = (1+cos(phase)*0.7);
    glNormal3f(0.0,ny,nx);
    glVertex3f(width*s,buf[i+1],buf[i]);
    glVertex3f(-width*s,buf[i+1],buf[i]); }
  glEnd();
  glNormal3f(-1.0,0.0,0.0);
  i = 2; 
  j = sz-4;
  glBegin(GL_TRIANGLE_STRIP);
  while (i < j) {
    while (buf[i-1] == buf[i+1] && buf[i-2] == buf[i] && i < j)
      i += 2;
    if (i < j) {
      s = (1+cos(phase)*0.7);
      glVertex3f(-width*s,buf[i+1],buf[i]); }
    i += 2;
    while (buf[j-1] == buf[j+1] && buf[j-2] == buf[j] && i < j)
      j -= 2;
    if (i < j) {
      s = (1+cos(phase)*0.7);
      glVertex3f(-width*s,buf[j+1],buf[j]); }
    j -= 2; }
  glEnd();
  i = 2; 
  j = sz-4;
  glBegin(GL_TRIANGLE_STRIP);
  glNormal3f(1.0,0.0,0.0);
  while (i < j) {
    while (buf[i-1] == buf[i+1] && buf[i-2] == buf[i] && i < j)
      i += 2;
    if (i < j) {
      s = (1+cos(phase)*0.7);
      glVertex3f(width*s,buf[i+1],buf[i]); }
    i += 2;
    while (buf[j-1] == buf[j+1] && buf[j-2] == buf[j] && i < j)
      j -= 2;
    if (i < j) {
      s = (1+cos(phase)*0.7);
      glVertex3f(width*s,buf[j+1],buf[j]); }
    j -= 2; }
  glEnd();
}

void do_rotate(GLfloat *f,int sz) {
  GLfloat nx,ny;
  GLfloat length;
  GLfloat a,c,s;
  int i,j;
  bheight = 0;
  bwidth = 0;
  for (i=0;i<sz;i++)
    buf[i] = f[i] / 4.2;
  for (i=0;i<sz;i+=2) {
    buf[i+1] = buf[i+1] * (1 - cos(phase)/3);
    buf[i] = buf[i] * (1+sin(M_PI*buf[i+1]/buf[1])*cos(phase)*0.7);
    if (buf[i] > bwidth)
      bwidth = buf[i];
    if (buf[i+1] > bheight)
      bheight = buf[i+1]; }
  for (i=2;i<sz-4;i+=2) {
    if (fabs(buf[i+3]+buf[i+1]) +fabs(buf[i+2]+buf[i]) < 0.0001)
      continue;
    glBegin(GL_QUAD_STRIP);
    for (j=0;j<=ACC;j++) {
      a = ((float) j)*M_PI*2/ACC;
      c = cos(a);
      s = sin(a);
      nx = buf[i-1] + buf[i+3];
      ny = buf[i+2] - buf[i];
      length = sqrt(nx*nx+ny*ny);
      nx = nx/length;
      ny = ny/length;
      glNormal3f(c*nx,ny,s*nx);
      glVertex3f(c*buf[i],buf[i+1],s*buf[i]);
      nx = buf[i-1] + buf[i+3];
      ny = buf[i+2] - buf[i];
      length = sqrt(nx*nx+ny*ny);
      nx = nx/length;
      ny = ny/length;
      glNormal3f(c*nx,ny,s*nx);
      glVertex3f(c*buf[i+2],buf[i+3],s*buf[i+2]); }
    glEnd(); }
}

GLfloat pion_data[] = {
  -0.04F,3.0F,0.0F,0.0F,0.0F,0.0F,0.0F,0.0F,
  0.0F,0.0F,0.0F,0.0F,0.0F,0.0F,0.0F,0.0F,
  0.20F,2.0F,0.560F,1.90F,0.560F,1.80F,0.30F,1.80F,
  0.30F,1.80F,0.520F,1.030F,0.520F,1.030F,0.550F,1.030F,
  0.550F,1.030F,0.670F,0.670F,0.940F,0.450F,0.940F,0.30F,
  0.840F,0.30F,0.840F,0.150F,0.940F,0.150F,0.940F,0.0F,
  0.940F,0.0F,0.0F,0.0F,0.0F,0.0F };

void prepare_pion(void) {
  int i;
  GLfloat a,c,s;
  for (i=0;i<7;i++) {
    a = ((GLfloat) i)*M_PI/8;
    s = sin(a);
    c = cos(a);
    pion_data[2+i*2] = s*0.56;
    pion_data[3+i*2] = c*0.56+2.44; }
  pion_data[2+i*2] = pion_data[i*2];
  pion_data[3+i*2] = pion_data[i*2+1];
}

void do_pion(void) {
  do_rotate(pion_data,sizeof(pion_data)/sizeof(GLfloat));
}

GLfloat toren_data[] = {
  -0.04F,3.0F,0.0F,3.0F,0.60F,3.0F,0.60F,3.0F,
  0.60F,3.20F,0.60F,3.20F,0.80F,3.20F,0.80F,3.20F,
  0.80F,3.20F,0.60F,2.70F,0.60F,2.70F,0.550F,2.70F,
  0.550F,2.70F,0.70F,1.20F,0.70F,1.20F,0.730F,1.20F,
  0.730F,1.20F,0.850F,0.850F,1.050F,0.50F,1.050F,0.50F,
  1.050F,0.30F,0.950F,0.350F,0.950F,0.150F,1.050F,0.150F,
  1.050F,0.0F,1.050F,0.0F,0.0F,0.0F,0.0F,0.0F };
  
void do_toren(void) {
  int i;
  GLfloat a1,a2,c1,s1,c2,s2,h1,h2;
  do_rotate(toren_data,sizeof(toren_data)/sizeof(GLfloat));
  h1 = buf[9];
  h2 = buf[9] + buf[9] - buf[3];
  for (i=0;i<ACC;i++) {
    if ((i*8/ACC)%2) {
      a1 = ((GLfloat) i)*M_PI*2/ACC;
      s1 = cos(a1);
      c1 = sin(a1);
      a2 = ((GLfloat) i+1)*M_PI*2/ACC;
      s2 = cos(a2);
      c2 = sin(a2);
      glBegin(GL_QUADS);
      glNormal3f(c1,0.0,s1);
      glVertex3f(0.143*c1,h1,0.143*s1);
      glVertex3f(0.143*c1,h2,0.143*s1);
      glNormal3f(c2,0.0,s2);
      glVertex3f(0.143*c2,h2,0.143*s2);
      glVertex3f(0.143*c2,h1,0.143*s2);
      glEnd();
      glBegin(GL_QUADS);
      glNormal3f(0.0,1.0,0.0);
      glVertex3f(0.143*c1,h2,0.143*s1);
      glVertex3f(0.190*c1,h2,0.190*s1);
      glVertex3f(0.190*c2,h2,0.190*s2);
      glVertex3f(0.143*c2,h2,0.143*s2);
      glEnd();
      glBegin(GL_QUADS);
      glNormal3f(c1,0.0,s1);
      glVertex3f(0.190*c1,h1,0.190*s1);
      glVertex3f(0.190*c1,h2,0.190*s1);
      glNormal3f(c2,0.0,s2);
      glVertex3f(0.190*c2,h2,0.190*s2);
      glVertex3f(0.190*c2,h1,0.190*s2);
      glEnd(); } }
  for (i=0;i<ACC;i++) {
    if (!((i*8) % ACC)) {
      a1 = ((GLfloat) i)*M_PI*2/ACC;
      s1 = cos(a1);
      c1 = sin(a1);
      glBegin(GL_QUADS);
      glNormal3f(s1,0.0,-c1);
      glVertex3f(c1*0.143,h1,s1*0.143);
      glVertex3f(c1*0.190,h1,s1*0.190);
      glVertex3f(c1*0.190,h2,s1*0.190);
      glVertex3f(c1*0.143,h2,s1*0.143);
      glEnd(); } }
}

GLfloat paard_data[] = {
  -0.04F,1.950F,0.20F,1.950F,0.20F,1.950F,0.20F,1.550F,
  0.20F,1.550F,0.650F,1.550F,0.650F,1.550F,0.70F,1.40F,
  0.70F,1.10F,
  0.850F,0.850F,1.050F,0.50F,1.050F,0.50F,1.050F,0.30F,
  0.950F,0.350F,0.950F,0.150F,1.050F,0.150F,1.050F,0.0F,
  1.050F,0.0F,0.0F,0.0F,0.0F,0.0F };

GLfloat paard_data2[] = {
  0.0F,1.60F,0.50F,1.60F,0.50F,1.60F,0.80F,2.80F,
  0.870F,3.0F,0.550F,3.50F,0.0F,4.0F,-0.30F,4.30F,
  -0.30F,4.30F,-0.50F,3.850F,-0.50F,3.850F,-0.85F,3.50F,
  -0.85F,3.50F,-0.85F,3.20F,-0.85F,3.20F,-0.20F,3.0F,
  -0.20F,3.0F,-0.45F,2.50F,-0.80F,2.350F,-0.80F,2.350F,
  -0.65F,1.60F,0.0F,1.6F };

void do_paard(void) {
  do_rotate(paard_data,sizeof(paard_data)/sizeof(GLfloat));
  do_solid(paard_data2,sizeof(paard_data2)/sizeof(GLfloat),0.08F);
}
    
GLfloat loper_data[] = {
  -0.20F,4.70F,0.0F,4.60F,0.250F,4.450F,0.150F,4.350F,
  0.150F,4.350F,0.50F,3.90F,0.640F,3.50F,0.450F,3.10F,
  0.450F,3.10F,0.580F,3.050F,0.450F,3.0F,0.450F,3.0F,
  0.450F,2.70F,0.450F,2.70F,0.560F,2.650F,0.520F,2.60F,
  0.520F,2.60F,0.70F,2.50F,0.740F,2.450F,0.70F,2.40F,
  0.30F,2.30F,0.30F,2.30F,0.50F,1.150F,0.50F,1.150F,
  0.550F,1.150F,0.550F,1.150F,
  0.850F,0.850F,1.050F,0.50F,1.050F,0.50F,1.050F,0.30F,
  0.950F,0.350F,0.950F,0.150F,1.050F,0.150F,1.050F,0.0F,
  1.050F,0.0F,0.0F,0.0F,0.0F,0.0F };

void do_loper(void) {
  do_rotate(loper_data,sizeof(loper_data)/sizeof(GLfloat));
}

GLfloat koning_data[] = {
  -0.20F,5.60F,
  0.0F,5.60F,0.30F,5.60F,0.550F,5.40F,0.850F,5.40F,
  0.554F,4.350F,0.554F,4.350F,0.650F,4.250F,0.550F,4.150F,
  0.550F,4.150F,0.550F,3.90F,0.551F,3.90F,0.750F,3.650F,
  0.750F,3.651F,0.751F,3.651F,0.920F,3.550F,0.50F,3.450F,
  0.50F,3.450F,
  0.50F,3.40F,0.650F,1.60F,0.70F,1.60F,0.750F,1.60F,
  1.150F,0.850F,1.20F,0.80F,1.20F,0.50F,1.20F,0.50F,
  1.10F,0.40F,1.20F,0.30F,1.20F,0.30F,1.20F,0.0F,
  1.20F,0.0F,0.0F,0.0F,0.0F,0.0F };

GLfloat koning_data2[] = {
  0.0F,5.40F,0.20F,5.40F,
  0.20F,5.40F,0.20F,7.0F,0.20F,7.0F,-0.20F,7.0F,
  -0.20F,7.0F,-0.20F,5.40F,-0.20F,5.40F,0.0F,5.40F};

GLfloat koning_data3[] = {
  0.0F,6.10F,0.70F,6.10F,0.70F,6.10F,0.70F,6.50F,
  0.70F,6.50F,-0.70F,6.50F,-0.70F,6.50F,-0.70F,6.10F,
  -0.70F,6.10F,0.0F,6.1F };

void prepare_koning(void) {
/*
 * I used much data from the dame for the koning,but the koning it a little
 * bit bigger,so....
 */
  int i;
  for (i=0;i<sizeof(koning_data)/sizeof(GLfloat);i+=2) {
    koning_data[i] = koning_data[i] * 0.95;
    koning_data[i+1] = koning_data[i+1] * 1.05; }
  for (i=0;i<sizeof(koning_data2)/sizeof(GLfloat);i++)
    koning_data2[i] = koning_data2[i] * 1.05;
  for (i=0;i<sizeof(koning_data3)/sizeof(GLfloat);i++)
    koning_data3[i] = koning_data3[i] * 1.05;
}

void do_koning(void) {
  do_rotate(koning_data,sizeof(koning_data)/sizeof(GLfloat));
  glRotatef(90.0,0.0,1.0,0.0);
  do_solid(koning_data2,sizeof(koning_data2)/sizeof(GLfloat),0.05F);
  do_solid(koning_data3,sizeof(koning_data3)/sizeof(GLfloat),0.05F);
}

GLfloat dame_data[] = {
  -0.20F,6.0F,0.0F,6.0F,0.30F,5.850F,0.20F,5.70F,
  0.30F,5.60F,
  0.301F,5.60F,0.550F,5.40F,0.550F,5.40F,0.850F,5.40F,
  0.80F,5.40F,0.80F,5.0F,0.80F,5.0F,0.650F,4.750F,
  0.554F,4.350F,0.554F,4.350F,0.650F,4.250F,0.550F,4.150F,
  0.550F,4.150F,0.550F,3.90F,0.551F,3.90F,0.750F,3.650F,
  0.750F,3.651F,0.751F,3.651F,0.920F,3.550F,0.50F,3.450F,
  0.50F,3.40F,0.650F,1.60F,0.70F,1.60F,0.750F,1.60F,
  1.150F,0.850F,1.20F,0.80F,1.20F,0.50F,1.20F,0.50F,
  1.10F,0.40F,1.20F,0.30F,1.20F,0.30F,1.20F,0.0F,
  1.20F,0.0F,0.0F,0.0F,0.0F,0.0F };

void do_dame(void) {
  do_rotate(dame_data,sizeof(dame_data)/sizeof(GLfloat));
}

void init_lists(void) {
  int i,j;
  printf("Generating textures.\n");
  init_textures();
  for (i=0;i<17;i++)
    transl[i+12] = transl[44-i] = sin(((GLfloat) i)*M_PI/32)/1.5;
  for (i=0;i<17;i++)
    list[i+8] = list[40-i] = i*8;
  for (i=0;i<8;i++)
    list[40+i] = list[7-i] = i*8;
  printf("Generating display lists.\n");
  prepare_pion();
  prepare_koning();
  for (i=0;i<=16;i++) {
    phase = ((GLfloat) i) * M_PI/16.0;
    glNewList(PION + 8*i,GL_COMPILE);
    width[PION+8*i] = bwidth;
    height[PION+8*i] = bheight;
    do_pion();
    glEndList();
    glNewList(TOREN + 8*i,GL_COMPILE);
    do_toren();
    width[TOREN+8*i] = bwidth;
    height[TOREN+8*i] = bheight;
    glEndList();
    glNewList(PAARD + 8*i,GL_COMPILE);
    do_paard();
    width[PAARD+8*i] = bwidth;
    height[PAARD+8*i] = bheight;
    glEndList();
    glNewList(LOPER + 8*i,GL_COMPILE);
    do_loper();
    width[LOPER+8*i] = bwidth;
    height[LOPER+8*i] = bheight;
    glEndList();
    glNewList(KONING + 8*i,GL_COMPILE);
    do_koning();
    width[KONING+8*i] = bwidth;
    height[KONING+8*i] = bheight;
    glEndList();
    glNewList(DAME + 8*i,GL_COMPILE);
    do_dame();
    width[DAME+8*i] = bwidth;
    height[DAME+8*i] = bheight;
    glEndList(); }
  for (i=0;i<10;i++)
    for (j=0;j<10;j++) {
      board[i][j] = 0;
      cycle[i][j] = -1; }
  for (i=1;i<9;i++) {
    board[i][2] = PION + WIT;
    board[i][7] = PION + ZWART; }
  board[1][1] = board[8][1] = TOREN + WIT;
  board[2][1] = board[7][1] = PAARD + WIT;
  board[3][1] = board[6][1] = LOPER + WIT;
  board[4][1] = DAME + WIT;
  board[5][1] = KONING + WIT;
  board[1][8] = board[8][8] = TOREN + ZWART;
  board[2][8] = board[7][8] = PAARD + ZWART;
  board[3][8] = board[6][8] = LOPER + ZWART;
  board[4][8] = DAME + ZWART;
  board[5][8] = KONING + ZWART;
  read_move();
}

extern int speed;

void do_piece(int pc,GLfloat x,GLfloat y,int *st,int *cl,int color) {
  GLfloat a,s;
  if (*cl >= 0)
    (*cl)++;
  if (*cl < 0 && ((rand()%300) < 4) && chaos) {
    chaosPieces++;
    *cl = 0;
    *st = rand() % 6; }
  if (*cl >= 48) {
    chaosPieces--;
    if (chaosPieces == 0 && !chaos) {
      if (!animating && (speed == 0))
        glutIdleFunc(NULL); }
    *cl = -1; }
  if (*cl < 0) {
    glPushMatrix();
    glTranslatef(x - 1.0,((x==CX2 && y==CY2)?CZ2:0.0),8.0 - y);
    if (color == ZWART && pc == PAARD)
      glRotatef(180.0,0.0,1.0,0.0);
    glScalef(1.2F,1.2F,1.2F);
    glCallList(pc+list[0]);
    glPopMatrix();
    return; }
  glPushMatrix();
  switch (*st) {
    case 0: glTranslatef(x - 1.0,transl[(*cl)>=0?*cl:0] + ((x==CX2 && y==CY2)?CZ2:0.0),8.0 - y);
            if (color == ZWART && pc == PAARD)
              glRotatef(180.0,0.0,1.0,0.0);
            glScalef(1.2F,1.2F,1.2F);
            glCallList(list[(*cl)>=0?*cl:0]+pc);
            break;
    case 1:
    case 2: glTranslatef(x - 1.0,transl[(*cl)>=0?*cl:0] + ((x==CX2 && y==CY2)?CZ2:0.0),8.0 - y);
            if (color == ZWART && pc == PAARD)
              glRotatef(180.0,0.0,1.0,0.0);
            if ((*cl > 16) && (*cl < 32)) {
              glTranslatef(0.0,height[list[*cl]+pc]/2,0.0);
              if (*st == 1)
                glRotatef(((*cl)-16) * 22.5,1.0,0.0,0.0);
                else
                glRotatef(-((*cl)-16) * 22.5,1.0,0.0,0.0);
              glTranslatef(0.0,-height[list[*cl]+pc]/2,0.0); }
            glScalef(1.2F,1.2F,1.2F);
            glCallList(list[*cl]+pc);
            break;
    case 3: glTranslatef(x - 1.0,((x==CX2 && y==CY2)?CZ2:0.0),8.0 - y);
            if (color == ZWART && pc == PAARD)
              glRotatef(180.0,0.0,1.0,0.0);
            a = ((GLfloat) (*cl)) * M_PI / 12;
            s = sin(a);
            glRotatef(15*s,0.0,0.0,1.0);
            glTranslatef(0.0,width[list[0]+pc]*s*s,0.0);
            glScalef(1.2F,1.2F,1.2F);
            glCallList(list[0] + pc);
            break;
    default:glTranslatef(x - 1.0,((x==CX2 && y==CY2)?CZ2:0.0),8.0 - y);
            if (color == ZWART && pc == PAARD)
              glRotatef(180.0,0.0,1.0,0.0);
            a = ((GLfloat) (*cl)) * M_PI / 12;
            s = sin(a);
            glRotatef(15*s,0.0,0.0,1.0);
            glRotatef((*cl) * 30,0.0,1.0,0.0);
            glTranslatef(0.0,width[list[0]+pc]*s*s,0.0);
            glScalef(1.2F,1.2F,1.2F);
            glCallList(list[0]+pc);
            break; }
  glPopMatrix();
}

void do_pieces(void) {
  int i,j;
  copper_texture();
  for (i=0;i<10;i++) {
    for (j=0;j<10;j++) {
      if (board[i][j]&16 || !(board[i][j]&15))
        continue;
      do_piece(board[i][j]&15,i,j,&stunt[i][j],&cycle[i][j],WIT); } }
  if ((piece&16) == WIT && piece > 0) {
    glPushMatrix();
    glTranslatef(0.0F,0.2F,0.0F);
    do_piece(piece&15,CX1,CY1,&stuntm,&cyclem,WIT);
    glPopMatrix(); }
  if ((piece2&16) == WIT && piece2 > 0)
    do_piece(piece2&15,CX2,CY1,&stunt2,&cycle2,WIT);
    dark_texture();
    for (i=0;i<10;i++) {
      for (j=0;j<10;j++) {
        if (!(board[i][j]&16) || !board[i][j])
          continue;
        do_piece(board[i][j]&15,i,j,&stunt[i][j],&cycle[i][j],ZWART); } }
  if ((piece&16) == ZWART && piece > 0) {
    glPushMatrix();
    glTranslatef(0.0F,0.2F,0.0F);
    do_piece(piece&15,CX1,CY1,&stuntm,&cyclem,ZWART);
    glPopMatrix(); }
  if ((piece2&16) == ZWART && piece2 > 0)
    do_piece(piece2&15,CX2,CY2,&stunt2,&cycle2,ZWART); 
}

void do_display(void) {
  glDisable(GL_DEPTH_TEST);
  /* glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_FALSE); */
  if (reflection) {
    glEnable(GL_STENCIL_TEST);
    glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
    glStencilFunc(GL_ALWAYS,1,0xffffffff); }
  do_vlakje();
  glEnable(GL_DEPTH_TEST);
  glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
  if (reflection) {
    glStencilFunc(GL_EQUAL,1,0xffffffff);
    glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
    glPushMatrix();
    glScalef(1.0,-1.0,1.0);
    glLightfv(GL_LIGHT0,GL_POSITION,lightpos);
    glClipPlane(GL_CLIP_PLANE1,ClipPlane);
    glEnable(GL_CLIP_PLANE1);
    do_pieces();
    glPopMatrix();
    glDisable(GL_CLIP_PLANE1);
    glDisable(GL_STENCIL_TEST);
    glLightfv(GL_LIGHT0,GL_POSITION,lightpos); }
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  do_board();
  glDisable(GL_BLEND);
  do_border();
  glClipPlane(GL_CLIP_PLANE1,ClipPlane);
  glEnable(GL_CLIP_PLANE1);
  do_pieces();
  glDisable(GL_CLIP_PLANE1);
}