PDA

View Full Version : Community for Gamedevelopment (viral gof 2 Players)



debirius
06-28-2012, 12:05 AM
Hello Community,

Im new in here. Ill describe in a few words what could be even interesting for you.
I guess Gofl is familiar to everyone. Im trying to develop a 2 Player version out of it.

Description:

- Fielddimension various. (rectangle)
- 1 turn for moving (<= 3 cells in the square (cornered or straight)
- Set cells active unlimited in a turn (right mouse button) // means the cell would react gofl like with neighbored ones if set active)
- the evolving generations erase the ones of the other players
- game start with 10 to 30 cells on the left player 1 and on the right player 2.
- so first to move the cells to a combination that is reactive (setting them active)
- only inactive cells can move (means every automatic moving cell is locked and does its thing)
- goal is to place your inactive cells in the startupcells the other player is starting (inactive cells even erase by moving them)

I didnt get very far in programming it. Here is the startup code
If someone has some freetime and maybe interested in developing on the code
please feel free to post.



#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <stdarg.h>
#include <GL/freeglut.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>

#define dimFieldX 40
#define dimFieldY 34

#define dimQUAD 2
#define colIdx 3
#define zDepth 0
#define CELLS 8

struct gField {
float ***fld;
int **col;
bool turn[2];
} gf;
struct player1 {
float ***fld1;
int **col1;
float NM[3];
bool turn1;
float ****cells;
} pl1;
struct player2 {
float ***fld2;
int **col2;
float NM[3];
bool turn2;
float ****cells;
} pl2;
void buildFont(void);
void glPrint(const char *fmt, ...);
void initRendering();
void drawScene(void);
void func_setF();
int initGL(void);
void processMouse(int button, int state, int x, int y);
int main(int argc, char *argv[]) {
char exit = 'q';
gf.turn[0] = false;
gf.turn[1] = false;
//-------------------------------------------------------
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(10,10);
glutInitWindowSize(1280,840);
glutCreateWindow("_");
initGL();
func_setF();
glutMouseFunc(processMouse);
glutDisplayFunc(drawScene);
glutMainLoop();
//-------------------------------------------------------
free(pl1.fld1);
free(pl1.col1);
free(pl2.fld2);
free(pl2.col2);
free(pl1.cells);
free(pl2.cells);
free(gf.fld);
free(gf.col);
return 0;
}

GLvoid glPrint( const char *fmt, ... )
{
int base = glGenLists(96);
char text[256]; /* Holds our string */
va_list ap; /* Pointer to our list of elements */

/* If there's no text, do nothing */
if ( fmt == NULL )
return;

/* Parses The String For Variables */
va_start( ap, fmt );
/* Converts Symbols To Actual Numbers */
vsprintf( text, fmt, ap );
va_end( ap );

/* Pushes the Display List Bits */
glPushAttrib( GL_LIST_BIT );

/* Sets base character to 32 */
glListBase( base - 32 );

/* Draws the text */
glCallLists( strlen( text ), GL_UNSIGNED_BYTE, text );

/* Pops the Display List Bits */
glPopAttrib( );
}

void buildFont( void )
{
Display *dpy; /* Our current X display */
XFontStruct *fontInfo; /* Our font info */

/* Sotrage for 96 characters */
int base = glGenLists( 96 );

/* Get our current display long enough to get the fonts */
dpy = XOpenDisplay( NULL );

/* Get the font information */
fontInfo = XLoadQueryFont( dpy, "-adobe-helvetica-medium-r-normal--18-*-*-*-p-*-iso8859-1" );

/* If the above font didn't exist try one that should */
if ( fontInfo == NULL )
{
fontInfo = XLoadQueryFont( dpy, "fixed" );
/* If that font doesn't exist, something is wrong */
if ( fontInfo == NULL )
{
fprintf( stderr, "no X font available?\n" );
exit( 1 );
}
}

/* generate the list */
glXUseXFont( fontInfo->fid, 32, 96, base );

/* Recover some memory */
XFreeFont( dpy, fontInfo );

/* close the display now that we're done with it */
XCloseDisplay( dpy );

return;
}
int initGL()
{

/* Enable smooth shading */
glShadeModel( GL_SMOOTH );

/* Set the background black */
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );

/* Depth buffer setup */
glClearDepth( 1.0f );

/* Enables Depth Testing */
glEnable( GL_DEPTH_TEST );

/* The Type Of Depth Test To Do */
glDepthFunc( GL_LEQUAL );

/* Really Nice Perspective Calculations */
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );

buildFont( );
return 1;
}

void drawScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST | GL_DEPTH);
glLoadIdentity();
int i_0, i_1, i_c, ctr = 0;
glRasterPos3f(-0.2f, -0.8f, 0.0f);
// glutBitmapString(GLUT_BITMAP_TIMES_ROMAN_24,"Active OpenGL Text - %20.2f");
glColor3f(1.0f,1.0f,1.0f);
glTranslatef(-0.4f, -0.4f, 0.0f);
glPushMatrix();
for(i_0 = 0; i_0 < dimFieldX - 1; i_0++) {
for(i_1 = 0; i_1 < dimFieldY - 1; i_1++) {
glBegin(GL_LINES);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(gf.fld[i_0][i_1][0],((gf.fld[i_0][i_1][1])), (float) zDepth - 0.1f);
glVertex3f(gf.fld[i_0 + 1][i_1][0],((gf.fld[i_0][i_1][1])), (float) zDepth - 0.1f);

glVertex3f(gf.fld[i_0 + 1][i_1][0],((gf.fld[i_0][i_1][1])), (float) zDepth - 0.1f);
glVertex3f(gf.fld[i_0 + 1][i_1][0],((gf.fld[i_0 + 1][i_1 + 1][1])), (float) zDepth - 0.1f);

glVertex3f(gf.fld[i_0 + 1][i_1][0],((gf.fld[i_0 + 1][i_1 + 1][1])), (float) zDepth - 0.1f);
glVertex3f(gf.fld[i_0][i_1][0],((gf.fld[i_0][i_1 + 1][1])), (float) zDepth - 0.1f);

glVertex3f(gf.fld[i_0][i_1][0],((gf.fld[i_0][i_1 + 1][1])), (float) zDepth - 0.1f);
glVertex3f(gf.fld[i_0][i_1][0],((gf.fld[i_0][i_1][1])), (float) zDepth - 0.1f);
}
}
for(i_c = 0; i_c < CELLS; i_c++) {
for(i_0 = 0; i_0 < dimFieldX - 1; i_0++) {
for(i_1 = 0; i_1 < dimFieldY - 1; i_1++) {
glColor3f(0.0f,1.0f,0.0f);
glBegin(GL_QUAD_STRIP);
glVertex3f(pl1.cells[i_c][i_0][i_1][0],pl1.cells[i_c][i_0][i_1][1], (float) zDepth -0.1f);
glVertex3f(pl1.cells[i_c][i_0 + 1][i_1][0],pl1.cells[i_c][i_0][i_1][1], (float) zDepth -0.1f);
glVertex3f(pl1.cells[i_c][i_0 + 1][i_1][0],pl1.cells[i_c][i_0 + 1][i_1 + 1][1], (float) zDepth -0.1f);
glVertex3f(pl1.cells[i_c][i_0][i_1][0],pl1.cells[i_c][i_0][i_1 + 1][1], (float) zDepth -0.1f);
glColor3f(0.0f,0.0f,1.0f);
glBegin(GL_QUAD_STRIP);
glVertex3f(pl2.cells[i_c][i_0][i_1][0],pl2.cells[i_c][i_0][i_1][1], (float) zDepth -0.1f);
glVertex3f(pl2.cells[i_c][i_0 + 1][i_1][0],pl2.cells[i_c][i_0][i_1][1], (float) zDepth -0.1f);
glVertex3f(pl2.cells[i_c][i_0 + 1][i_1][0],pl2.cells[i_c][i_0 + 1][i_1 + 1][1], (float) zDepth -0.1f);
glVertex3f(pl2.cells[i_c][i_0][i_1][0],pl2.cells[i_c][i_0][i_1 + 1][1], (float) zDepth -0.1f);
}
}
}
glPopMatrix();
//-->
glEnd();
glutSwapBuffers();
glFlush();
}
void func_setF() {
int i_0, i_1, i_c;
srand(time(NULL));

gf.col = (int **) malloc((dimFieldX*dimFieldY)*sizeof(int *));
pl1.col1 = (int **) malloc((dimFieldX*dimFieldY)*sizeof(int *));
pl2.col2 = (int **) malloc((dimFieldX*dimFieldY)*sizeof(int *));
for(i_0 = 0; i_0 < dimFieldX * dimFieldY; i_0++) {
gf.col[i_0] = (int *) malloc(colIdx*sizeof(int));
pl1.col1[i_0] = (int *) malloc((colIdx)*sizeof(int));
pl2.col2[i_0] = (int *) malloc((colIdx)*sizeof(int));
}
gf.fld = (float ***) malloc(dimFieldX*sizeof(float **));
pl1.fld1 = (float ***) malloc(dimFieldX*sizeof(float **));
pl2.fld2 = (float ***) malloc(dimFieldX*sizeof(float **));
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
gf.fld[i_0] = (float **) malloc(dimFieldY*sizeof(float *));
pl1.fld1[i_0] = (float **) malloc(dimFieldY*sizeof(float *));
pl2.fld2[i_0] = (float **) malloc(dimFieldY*sizeof(float *));
}
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
for(i_1 = 0; i_1 < dimFieldY; i_1++) {
gf.fld[i_0][i_1] = (float *) malloc(dimQUAD*sizeof(float));
pl1.fld1[i_0][i_1] = (float *) malloc(dimQUAD*sizeof(float));
pl2.fld2[i_0][i_1] = (float *) malloc(dimQUAD*sizeof(float));
}
}
for(i_0 = 1; i_0 <= dimFieldX; i_0++) {
for(i_1 = 1; i_1 <= dimFieldY; i_1++) {
gf.fld[i_0 - 1][i_1 - 1][0] = ((float)i_0 / (float)dimFieldX);
gf.fld[i_0 - 1][i_1 - 1][1] = ((float)i_1 / (float)dimFieldY);
}
}
pl1.cells = (float ****) malloc(CELLS*sizeof(float ***));
pl2.cells = (float ****) malloc(CELLS*sizeof(float ***));
for(i_c = 0; i_c < CELLS; i_c++) {
pl1.cells[i_c] = (float ***) malloc(dimFieldX*sizeof(float **));
pl2.cells[i_c] = (float ***) malloc(dimFieldX*sizeof(float **));
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
pl1.cells[i_c][i_0] = (float **) malloc(dimFieldY*sizeof(float *));
pl2.cells[i_c][i_0] = (float **) malloc(dimFieldY*sizeof(float *));
for(i_1 = 0; i_1 < dimFieldY; i_1++) {
pl1.cells[i_c][i_0][i_1] = (float *) malloc(3*sizeof(float));
pl2.cells[i_c][i_0][i_1] = (float *) malloc(3*sizeof(float));
}
}
}
for(i_c = 0; i_c < CELLS; i_c++) {
for(i_0 = 1; i_0 <= dimFieldX; i_0++) {
for(i_1 = 1; i_1 <= dimFieldY; i_1++) {
pl1.cells[i_c][i_0 - 1][i_1 - 1][0] = 0.0;
pl1.cells[i_c][i_0 - 1][i_1 - 1][1] = ((float) i_1 / (float) dimFieldY);
pl2.cells[i_c][i_0 - 1][i_1 - 1][0] = (float) dimFieldX;
pl2.cells[i_c][i_0 - 1][i_1 - 1][1] = ((float) i_1 / (float) dimFieldY);
pl1.cells[i_c][i_0 - 1][i_1 - 1][2] = 0.0; // inactive gofcell
pl2.cells[i_c][i_0 - 1][i_1 - 1][2] = 0.0;
}
}
}
pl1.NM[0] = 0.0;
pl2.NM[0] = 0.0;
pl1.NM[1] = 0.0;
pl2.NM[1] = 0.0;
pl1.NM[3] = 0.0;
pl2.NM[3] = 0.0;
}
void processMouse(int button, int state, int x, int y)
{
int cL, i_0, i_1;
if(state == GLUT_DOWN)
{
if(button == GLUT_LEFT_BUTTON)
{
if(pl1.turn1 == true) {
if(pl1.NM[0] == x && pl1.NM[1] == y) {
for(cL = 0; cL < CELLS; cL++) {
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
for(i_1 = 0; i_1 < dimFieldY; i_1++) {
if(pl1.cells[cL][i_0][i_1][0] == (float) x && pl1.cells[cL][i_0][i_1][1] == (float) y) {
if((pl1.NM[0] - x) + (pl1.NM[1] -y) <= 3 && (pl1.NM[0] - x) + (pl1.NM[1] -y) >= 1) {
pl1.cells[cL][i_0][i_1][0] = pl1.NM[0];
pl1.cells[cL][i_0][i_1][1] = pl1.NM[1];
}
}
}
}
}
}
}
if(pl2.turn2 == true) {
if(pl2.NM[0] == 0 && pl2.NM[1] == 0) {
for(cL = 0; cL < CELLS; cL++) {
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
for(i_1 = 0; i_1 < dimFieldY; i_1++) {
if(pl2.cells[cL][i_0][i_1][0] == (float) x && pl2.cells[cL][i_0][i_1][1] == (float) y) {
if((pl2.NM[0] - x) + (pl2.NM[1] -y) <= 3 && (pl2.NM[0] - x) + (pl2.NM[1] -y) >= 1) {
pl2.cells[cL][i_0][i_1][0] = pl2.NM[0];
pl2.cells[cL][i_0][i_1][1] = pl2.NM[1];
}
}
}
}
}
}
}
}
else if(button == GLUT_RIGHT_BUTTON)
{
if(pl1.turn1 == true) {
if(pl1.NM[0] == x && pl1.NM[1] == y) {
for(cL = 0; cL < CELLS; cL++) {
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
for(i_1 = 0; i_1 < dimFieldY; i_1++) {
if(pl1.cells[cL][i_0][i_1][0] == (float) x && pl1.cells[cL][i_0][i_1][1] == (float) y) {
pl1.cells[cL][i_0][i_1][3] = 1.0;
}
}
}
}

}
}
if(pl2.turn2 == true) {
if(pl2.NM[0] == x && pl2.NM[1] == y) {
for(i_0 = 0; i_0 < dimFieldX; i_0++) {
for(i_1 = 0; i_1 < dimFieldY; i_1++) {
if(pl2.cells[cL][i_0][i_1][0] == (float) x && pl2.cells[cL][i_0][i_1][1] == (float) y) {
pl2.cells[cL][i_0][i_1][3] = 1.0;
}
}
}

}
}
}
}
else
{
//alternate code
}
}


thx for reading

reference for the missing algorithm: http://www.math.com/students/wonders/life/life.html

debirius