spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Funktion, die den Zeiger benötigt
void Funktion(S_Spielfeld* Spielfeld[Breite][Höhe]){
  ...
  return;
}

C-/C++-Quelltext

int main(){
  ...
  S_Spielfeld Spielfeld[Breite][Höhe];
  Funktion(&Spielfeld);
  ...
  return 0;
}

Quellcode

#include <iostream>
int main()
{
    int array[10];
    int* pointer = array;
    std::cout << sizeof(array) << ' ' << sizeof(pointer) << '\n';
    std::cout << &array << ' ' << &array[0] << '\n';
    std::cout << &pointer << ' ' << &pointer[0] << '\n';
}

Quellcode

struct _game_field {
    unsigned int l;
    bool **field;
};

static struct _game_field *new_game_field(unsigned int l)
{
    int i, j;
    struct _game_field *n;

    // allocate memory for the game field struct
    n = malloc(sizeof(struct _game_field));
    if(!n)
        return NULL;

    n->l = l;
    // allocate memory for pointers to each row
    n->field = malloc(sizeof(bool *) * l);
    if(!n->field){
        free(n);
        return NULL;
    }

    // allocate space on each row for l fields
    for(i = 0; i < l; i++){
        n->field[i] = malloc(sizeof(bool) * l);

        // then we're out of memory, clean up
        if(!n->field[i]){
            while(i--)
                free(n->field[i]);

            free(n->field);
            free(n);
            return NULL;
        }
    }

    // set all fields to 0
    for(i = 0; i < l; i++)
        for(j = 0; j < l; j++)
            n->field[i][j] = 0;

    return n;
}

Quellcode

/*
 * game of life
 * (c) 2010 richard weinberger <richard@nod.at>
 *
 * usage:
 * $ mkdir tmp
 * $ cd tmp
 * $ ../gol 150 50 7
 * $ convert -delay 75 -loop 0 field* ../game_of_life.gif
 * $ cd ..
 * $ gwenview game_of_life.gif
 * $ rm -rf tmp/
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>

#ifdef DEBUG
    #define debug(fmt, ...) printf("DEBUG: " fmt, __VA_ARGS__)
#else
    #define debug(fmt, ...) {}while(0)
#endif

struct _game_field {
    unsigned int l;
    bool **field;
};

static struct _game_field *new_game_field(unsigned int l)
{
    int i, j;
    struct _game_field *n;

    // allocate memory for the game field struct
    n = malloc(sizeof(struct _game_field));
    if(!n)
        return NULL;

    n->l = l;
    // allocate memory for pointers to each row
    n->field = malloc(sizeof(bool *) * l);
    if(!n->field){
        free(n);
        return NULL;
    }

    // allocate space on each row for l fields
    for(i = 0; i < l; i++){
        n->field[i] = malloc(sizeof(bool) * l);

        // then we're out of memory, clean up
        if(!n->field[i]){
            while(i--)
                free(n->field[i]);

            free(n->field);
            free(n);
            return NULL;
        }
    }

    // set all fields to 0
    for(i = 0; i < l; i++)
        for(j = 0; j < l; j++)
            n->field[i][j] = 0;

    return n;
}

static struct _game_field *copy_game_field(struct _game_field *gf)
{
    struct _game_field *n;
    int i;

    // request a new game field
    n = new_game_field(gf->l);
    if(!n)
        return NULL;

    n->l = gf->l;
    for(i = 0; i < gf->l; i++){
        // copy each row from the old one
        // memcpy() is faster than copying field per field by hand
        memcpy(n->field[i], gf->field[i], sizeof(bool) * gf->l);
    }

    return n;
}

static void del_game_field(struct _game_field *gf)
{
    int i;

    // free each row
    for(i = 0; i < gf->l; i++)
        free(gf->field[i]);

    // free pointers to each row
    free(gf->field);
    // free the remaining struct
    free(gf);
}

static int get_neighbors(struct _game_field *gf, int x, int y)
{
    int n = 0;
    int l = gf->l - 1;

    // check each neighbor
    // it's simpler to write 8 if statements than a complex loop 8-)

    if(l > x && gf->field[x + 1][y])
        n++;

    if(l > y && gf->field[x][y + 1])
        n++;

    if(l > x && l > y && gf->field[x + 1][y + 1])
        n++;

    if(x && y && gf->field[x - 1][y - 1])
        n++;

    if(x && gf->field[x - 1][y])
        n++;

    if(y && gf->field[x][y - 1])
        n++;

    if(l > x && y && gf->field[x + 1][y - 1])
        n++;

    if(x && l > y && gf->field[x - 1][y + 1])
        n++;

    return n;
}

static struct _game_field *game_iteration(struct _game_field *gf)
{
    int i, j, n;
    // request a copy of our current game field
    struct _game_field *next = copy_game_field(gf);

    if(!next)
        return NULL;

    // apply for each cell the three rules on the new game field
    for(i = 0; i < gf->l; i++){
        for(j = 0; j < gf->l; j++){
            // get neighbors of cell i,j
            n = get_neighbors(gf, i, j);

            if(gf->field[i][j] && n <= 1){
                debug("field[%i][%i] dies!\n", i, j);
                next->field[i][j] = 0;
            }
            if(gf->field[i][j] && n >= 4){
                debug("field[%i][%i] dies!\n", i, j);
                next->field[i][j] = 0;
            }
            if(!gf->field[i][j] && n == 3){
                debug("field[%i][%i] lifes!\n", i, j);
                next->field[i][j] = 1;
            }
        }
    }

    del_game_field(gf);

    return next;
}

static int write_pbm_file(const char *fn, struct _game_field *gf)
{
    int i, j;
    FILE *fp;

    debug("writing game field to %s\n", fn);

    // open the file for writing
    fp = fopen(fn, "w+");
    if(!fp){
        printf("unable to open '%s' - '%s'\n", fn, strerror(errno));

        return -1;
    }

    // write the pbm header
    fprintf(fp, "P1\n");
    fprintf(fp, "%i\n", gf->l);
    fprintf(fp, "%i\n", gf->l);

    // write each cell
    for(i = 0; i < gf->l; i++)
        for(j = 0; j < gf->l; j++)
            fprintf(fp, "%i\n", gf->field[i][j]);

    fclose(fp);

    return 0;
}

static void set_random_life(struct _game_field *gf, int factor)
{
    int i, j, k;
    struct timeval tv;

    gettimeofday(&tv, NULL);
    srand(tv.tv_usec);

    // when we have n cells, select n times a random cell to be alive
    for(i = 0; i < gf->l * gf->l; i = i + factor){
        j = rand() % gf->l;
        k = rand() % gf->l;

        gf->field[j][k] = 1;
    }
}

static void run_game(int length, int iterations, int factor)
{
    int i;
    char fname[256] = {0};
    struct _game_field *gf;

    // create the initial game field
    gf = new_game_field(length);
    if(!gf){
        printf("Unable to allocate memory for game field!\n");

        return;
    }

    // fill it randomly with life
    set_random_life(gf, factor);

    // for each iteration write a pbm file, apply the three rules of life
    for(i = 0; i < iterations; i++){
        debug("game iteration %i of %i\n", i, iterations);
        snprintf(fname, sizeof fname, "field%03i.pbm", i);
        write_pbm_file(fname, gf);
        gf = game_iteration(gf);
        if(!gf){
            printf("Unable to allocate memory for next game field!\n");

            return;
        }
    }

    del_game_field(gf);
}

int main(int argc, char **argv)
{
    int length;
    int iterations;
    int factor;

    if(argc < 4){
        printf("Usage: %s field-length num-iterations randfactor\n", argv[0]);

        return 1;
    }

    length = atoi(argv[1]);
    if(!length){
        printf("Invalid length value!\n");

        return 1;
    }

    iterations = atoi(argv[2]);
    if(!iterations){
        printf("Invalid iteration value!\n");

        return 1;
    }

    factor = atoi(argv[3]);
    if(!factor){
        printf("Invalid randfactor value!\n");

        return 1;
    }

    debug("running game with length=%i iterations=%i factor=%i\n", length, iterations, factor);
    run_game(length, iterations, factor);

    return 0;
}