Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 1 of 1

Thread: Community for Gamedevelopment (viral gof 2 Players)

  1. #1
    Junior Member Newbie
    Join Date
    Jun 2012
    Location
    stp Austria
    Posts
    1

    Community for Gamedevelopment (viral gof 2 Players)

    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.

    Code :
    #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
    Last edited by Dark Photon; 06-28-2012 at 05:07 AM. Reason: Add code blocks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •