env_maze.c

Go to the documentation of this file.

/*
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "env_maze.h"
#include "param.h"
#include "utils.h"
 
#define MAX_PAYOFF (1.) 
 
static const int x_moves[] = { 0, +1, +1, +1, 0, -1, -1, -1 };
 
static const int y_moves[] = { -1, -1, 0, +1, +1, +1, 0, -1 };
 
static double
env_maze_sensor(const struct XCSF *xcsf, const char s)
{
    (void) xcsf;
    switch (s) {
        case '*':
            return 0.1;
        case 'O':
            return 0.3;
        case 'G':
            return 0.5;
        case 'F':
            return 0.7;
        case 'Q':
            return 0.9;
        default:
            printf("unsupported maze state: %c\n", s);
            exit(EXIT_FAILURE);
    }
}
 
void
env_maze_init(struct XCSF *xcsf, const char *filename)
{
    // open maze file
    FILE *fp = fopen(filename, "rt");
    if (fp == 0) {
        printf("could not open %s. %s.\n", filename, strerror(errno));
        exit(EXIT_FAILURE);
    }
    // read maze
    struct EnvMaze *env = malloc(sizeof(struct EnvMaze));
    int x = 0;
    int y = 0;
    int c = 0;
    while ((c = fgetc(fp)) != EOF) {
        if (c == '\n') {
            ++y;
            env->xsize = x;
            x = 0;
        } else {
            env->maze[y][x] = (char) c;
            ++x;
        }
        // check maximum maze size not exceeded
        if (x > MAX_SIZE || y > MAX_SIZE) {
            printf("Maze too big. Max size = [%d,%d]\n", MAX_SIZE, MAX_SIZE);
            fclose(fp);
            exit(EXIT_FAILURE);
        }
    }
    // check if EOF came from an end-of-file or an error
    if (ferror(fp)) {
        printf("EOF error opening %s. %s.\n", filename, strerror(errno));
        fclose(fp);
        exit(EXIT_FAILURE);
    }
    env->ysize = y;
    env->state = malloc(sizeof(double) * 8);
    xcsf->env = env;
    fclose(fp);
    param_init(xcsf, 8, 1, 8);
}
 
void
env_maze_free(const struct XCSF *xcsf)
{
    struct EnvMaze *env = xcsf->env;
    free(env->state);
    free(env);
}
 
void
env_maze_reset(const struct XCSF *xcsf)
{
    struct EnvMaze *env = xcsf->env;
    env->done = false;
    do {
        env->xpos = rand_uniform_int(0, env->xsize);
        env->ypos = rand_uniform_int(0, env->ysize);
    } while (env->maze[env->ypos][env->xpos] != '*');
}
 
bool
env_maze_is_done(const struct XCSF *xcsf)
{
    const struct EnvMaze *env = xcsf->env;
    return env->done;
}
 
const double *
env_maze_get_state(const struct XCSF *xcsf)
{
    const struct EnvMaze *env = xcsf->env;
    int spos = 0;
    for (int y = -1; y < 2; ++y) {
        for (int x = -1; x < 2; ++x) {
            if (x == 0 && y == 0) { // ignore current pos
                continue;
            }
            // toroidal maze
            const int xsense =
                ((env->xpos + x) % env->xsize + env->xsize) % env->xsize;
            const int ysense =
                ((env->ypos + y) % env->ysize + env->ysize) % env->ysize;
            const char s = env->maze[ysense][xsense];
            // convert sensor to real number
            env->state[spos] = env_maze_sensor(xcsf, s);
            ++spos;
        }
    }
    return env->state;
}
 
double
env_maze_execute(const struct XCSF *xcsf, const int action)
{
    if (action < 0 || action > 7) {
        printf("invalid maze action\n");
        exit(EXIT_FAILURE);
    }
    struct EnvMaze *env = xcsf->env;
    // toroidal maze
    const int newx =
        ((env->xpos + x_moves[action]) % env->xsize + env->xsize) % env->xsize;
    const int newy =
        ((env->ypos + y_moves[action]) % env->ysize + env->ysize) % env->ysize;
    // make the move and receive reward
    double reward = 0;
    switch (env->maze[newy][newx]) {
        case 'O':
        case 'Q':
            break;
        case '*':
            env->ypos = newy;
            env->xpos = newx;
            break;
        case 'F':
        case 'G':
            env->ypos = newy;
            env->xpos = newx;
            env->done = true;
            reward = MAX_PAYOFF;
            break;
        default:
            printf("invalid maze type\n");
            exit(EXIT_FAILURE);
    }
    return reward;
}
 
double
env_maze_maxpayoff(const struct XCSF *xcsf)
{
    (void) xcsf;
    return MAX_PAYOFF;
}
 
bool
env_maze_multistep(const struct XCSF *xcsf)
{
    (void) xcsf;
    return true;
}