expand2x.c

Go to the documentation of this file.

/*
 * --------------------------------------------------------------------------
 * $Id: expand2x.c 11578 2009-02-23 22:02:27Z lalo $
 *
 * ALGORITHM
 *
 * ... (TBW)
 */

#include <stdlib.h>   /* just in case */
#include <expand2x.h>   /* use compiler to do sanity check */


/* PROTOTYPES */

static void expand_misc(char **newlayout, int i, int j, char **layout);
static void expand_wall(char **newlayout, int i, int j, char **layout, int xsize, int ysize);
static void expand_door(char **newlayout, int i, int j, char **layout, int xsize, int ysize);

/* FUNCTIONS */

char **expand2x(char **layout, int xsize, int ysize) {
    int i, j;
    int nxsize = xsize*2-1;
    int nysize = ysize*2-1;

    /* Allocate new layout */
    char **newlayout = (char **)calloc(sizeof(char *), nxsize);
    for (i = 0; i < nxsize; i++) {
        newlayout[i] = (char *)calloc(sizeof(char), nysize);
    }

    for (i = 0; i < xsize; i++) {
        for (j = 0; j < ysize; j++) {
            switch (layout[i][j]) {
            case '#':
                expand_wall(newlayout, i, j, layout, xsize, ysize);
                break;

            case 'D':
                expand_door(newlayout, i, j, layout, xsize, ysize);
                break;

            default:
                expand_misc(newlayout, i, j, layout);
            }
        }
    }

    /* Dump old layout */
    for (i = 0; i < xsize; i++) {
        free(layout[i]);
    }
    free(layout);

    return newlayout;
}

static void expand_misc(char **newlayout, int i, int j, char **layout) {
    newlayout[i*2][j*2] = layout[i][j];
    /* (Note: no need to reset rest of 2x2 area to \0 because calloc does that
     * for us.) */
}

static int calc_pattern(char ch, char **layout, int i, int j, int xsize, int ysize) {
    int pattern = 0;

    if (i+1 < xsize && layout[i+1][j] == ch)
        pattern |= 1;

    if (j+1 < ysize) {
        if (layout[i][j+1] == ch)
            pattern |= 2;
        if (i+1 < xsize && layout[i+1][j+1] == ch)
            pattern |= 4;
    }

    return pattern;
}

static void expand_wall(char **newlayout, int i, int j, char **layout, int xsize, int ysize) {
    int wall_pattern = calc_pattern('#', layout, i, j, xsize, ysize);
    int door_pattern = calc_pattern('D', layout, i, j, xsize, ysize);
    int both_pattern = wall_pattern|door_pattern;

    newlayout[i*2][j*2] = '#';
    if (i+1 < xsize) {
        if (both_pattern&1) {
            /* join walls/doors to the right */
            newlayout[i*2+1][j*2] = layout[i+1][j];
        }
    }

    if (j+1 < ysize) {
        if (both_pattern&2) {
            /* join walls/doors to the bottom */
            newlayout[i*2][j*2+1] = layout[i][j+1];
        }

        if (wall_pattern == 7) {
            /* if orig layout is a 2x2 wall block,
             * we fill the result with walls. */
            newlayout[i*2+1][j*2+1] = '#';
        }
    }
}

static void expand_door(char **newlayout, int i, int j, char **layout, int xsize, int ysize) {
    int wall_pattern = calc_pattern('#', layout, i, j, xsize, ysize);
    int door_pattern = calc_pattern('D', layout, i, j, xsize, ysize);
    int join_pattern;

    /* Doors "like" to connect to walls more than other doors. If there is
     * a wall and another door, this door will connect to the wall and
     * disconnect from the other door. */
    if (wall_pattern&3) {
        join_pattern = wall_pattern;
    } else {
        join_pattern = door_pattern;
    }

    newlayout[i*2][j*2] = 'D';
    if (i+1 < xsize) {
        if (join_pattern&1) {
            /* there is a door/wall to the right */
            newlayout[i*2+1][j*2] = 'D';
        }
    }

    if (j+1 < ysize) {
        if (join_pattern&2) {
            /* there is a door/wall below */
            newlayout[i*2][j*2+1] = 'D';
        }
    }
}