chess.c

学习c++必备

	}
	glEnd();
    }
}

GLfloat pion_data[] = {
	-0.04, 3.000,   0.000, 0.000,   0.000, 0.000,   0.000, 0.000,
	0.000, 0.000,   0.000, 0.000,   0.000, 0.000,   0.000, 0.000,
	0.200, 2.000,   0.560, 1.900,   0.560, 1.800,   0.300, 1.800,
	0.300, 1.800,   0.520, 1.030,   0.520, 1.030,   0.550, 1.030,
	0.550, 1.030,   0.670, 0.670,   0.940, 0.450,   0.940, 0.300,
	0.840, 0.300,   0.840, 0.150,   0.940, 0.150,   0.940, 0.000,
	0.940, 0.000,	0.000, 0.000,	0.000, 0.000
};

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.04, 3.000,	0.000, 3.000,	0.600, 3.000,	0.600, 3.000,
	0.600, 3.200,	0.600, 3.200,	0.800, 3.200,	0.800, 3.200,
	0.800, 3.200,	0.600, 2.700,	0.600, 2.700,	0.550, 2.700,
	0.550, 2.700,	0.700, 1.200,	0.700, 1.200,	0.730, 1.200,
	0.730, 1.200,   0.850, 0.850,	1.050, 0.500,	1.050, 0.500,
	1.050, 0.300,	0.950, 0.350,	0.950, 0.150,	1.050, 0.150,
	1.050, 0.000,	1.050, 0.000,	0.000, 0.000,	0.000, 0.000
};
	
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.04, 1.950,	0.200, 1.950,	0.200, 1.950,	0.200, 1.550,
	0.200, 1.550,	0.650, 1.550,	0.650, 1.550,	0.700, 1.400,
	0.700, 1.100,
	0.850, 0.850,	1.050, 0.500,	1.050, 0.500,	1.050, 0.300,
	0.950, 0.350,	0.950, 0.150,	1.050, 0.150,	1.050, 0.000,
	1.050, 0.000,	0.000, 0.000,	0.000, 0.000
};

GLfloat paard_data2[] = {
	0.000, 1.600,	0.500, 1.600,	0.500, 1.600,	0.800, 2.800,
	0.870, 3.000,	0.550, 3.500,	0.000, 4.000,	-0.30, 4.300,
	-0.30, 4.300,	-0.50, 3.850,	-0.50, 3.850,	-0.85, 3.500,
	-0.85, 3.500,	-0.85, 3.200,	-0.85, 3.200,	-0.20, 3.000,
	-0.20, 3.000,	-0.45, 2.500,	-0.80, 2.350,	-0.80, 2.350,
	-0.65, 1.600,	0.000, 1.600
};

void do_paard(void)
{
    do_rotate(paard_data, sizeof(paard_data)/sizeof(GLfloat));
    do_solid(paard_data2, sizeof(paard_data2)/sizeof(GLfloat), 0.08);
}
    
GLfloat loper_data[] = {
	-0.20, 4.700,	0.000, 4.600,	0.250, 4.450,	0.150, 4.350,
	0.150, 4.350,	0.500, 3.900,	0.640, 3.500,	0.450, 3.100,
	0.450, 3.100,	0.580, 3.050,	0.450, 3.000,	0.450, 3.000,
	0.450, 2.700,	0.450, 2.700,	0.560, 2.650,	0.520, 2.600,
	0.520, 2.600,	0.700, 2.500,   0.740, 2.450,	0.700, 2.400,
	0.300, 2.300,	0.300, 2.300,	0.500, 1.150,	0.500, 1.150,
	0.550, 1.150,	0.550, 1.150,
	0.850, 0.850,	1.050, 0.500,	1.050, 0.500,	1.050, 0.300,
	0.950, 0.350,	0.950, 0.150,	1.050, 0.150,	1.050, 0.000,
	1.050, 0.000,	0.000, 0.000,	0.000, 0.000
};

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

GLfloat koning_data[] = {
	-0.20, 5.600,
	0.000, 5.600,	0.300, 5.600,	0.550, 5.400,	0.850, 5.400,
	0.554, 4.350,	0.554, 4.350,	0.650, 4.250,	0.550, 4.150,
	0.550, 4.150,	0.550, 3.900,	0.551, 3.900,	0.750, 3.650,
	0.750, 3.651,	0.751, 3.651,	0.920, 3.550,	0.500, 3.450,
	0.500, 3.450,
	0.500, 3.400,	0.650, 1.600,	0.700, 1.600,	0.750, 1.600,
	1.150, 0.850,	1.200, 0.800,	1.200, 0.500,	1.200, 0.500,
	1.100, 0.400,	1.200, 0.300,	1.200, 0.300,	1.200, 0.000,
	1.200, 0.000,	0.000, 0.000,	0.000, 0.000
};

GLfloat koning_data2[] = {
	0.000, 5.400,	0.200, 5.400,
	0.200, 5.400,	0.200, 7.000,	0.200, 7.000,	-0.20, 7.000,
	-0.20, 7.000,	-0.20, 5.400,	-0.20, 5.400,	0.000, 5.400,
};

GLfloat koning_data3[] = {
	0.000, 6.100,	0.700, 6.100,	0.700, 6.100,	0.700, 6.500,
	0.700, 6.500,	-0.70, 6.500,	-0.70, 6.500,	-0.70, 6.100,
	-0.70, 6.100,	0.000, 6.100
};

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.05);
    do_solid(koning_data3, sizeof(koning_data3)/sizeof(GLfloat), 0.05);
}

GLfloat dame_data[] = {
	-0.20, 6.000,	0.000, 6.000,	0.300, 5.850,	0.200, 5.700,
	0.300, 5.600,
	0.301, 5.600,	0.550, 5.400,	0.550, 5.400,	0.850, 5.400,
	0.800, 5.400,	0.800, 5.000,	0.800, 5.000,	0.650, 4.750,
	0.554, 4.350,	0.554, 4.350,	0.650, 4.250,	0.550, 4.150,
	0.550, 4.150,	0.550, 3.900,	0.551, 3.900,	0.750, 3.650,
	0.750, 3.651,	0.751, 3.651,	0.920, 3.550,	0.500, 3.450,
	0.500, 3.400,	0.650, 1.600,	0.700, 1.600,	0.750, 1.600,
	1.150, 0.850,	1.200, 0.800,	1.200, 0.500,	1.200, 0.500,
	1.100, 0.400,	1.200, 0.300,	1.200, 0.300,	1.200, 0.000,
	1.200, 0.000,	0.000, 0.000,	0.000, 0.000
};

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.2, 1.2, 1.2);
	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.2, 1.2, 1.2);
	    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.2, 1.2, 1.2);
	    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.2, 1.2, 1.2);
	    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.2, 1.2, 1.2);
	    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.0, 0.2, 0.0);
	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.0, 0.2, 0.0);
	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);
    }

/*
 * Also without texturing I want to blend, to keep the contrast of the board
 * consistent.
 */

    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);
}