Subversion Repositories connect-6

/*

connectk -- a program to play the connect-k family of games

Copyright (C) 2007 Michael Levin

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 2

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, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#include "config.h"

#include <string.h>

#include <math.h>

#include <glib.h>

#include "../shared.h"

#include "../connectk.h"

/*

 *      AIs

 */

static AI ais[] = {

        { "human", "Human", NULL },

        { "random", "Random", ai_random },

        { "adjacent", "Adjacent", ai_adjacent },

        { "threats", "Threats", ai_threats },

        /*{ "windows", "Windows", ai_windows },*/

        /*{ "priority", "Prioritized Threats", ai_priority },*/

        { "sequences", "Sequences", ai_sequences },

        { "mesh", "Mesh", ai_mesh },

        { "montecarlo", "Monte Carlo", ai_monte_carlo },

};

static gboolean is_adjacent(const Board *b, BCOORD x, BCOORD y, int dist)

{

        int dx, dy, count;

        PIECE p;

        if (!piece_empty(piece_at(b, x, y)))

                return FALSE;

        for (dy = -1; dy < 2; dy++)

                for (dx = -1; dx < 2; dx++) {

                        if (!dx && !dy)

                                continue;

                        count = count_pieces(b, x, y, PIECE_NONE, dx, dy, &p);

                        if (count - 1 < dist && p != PIECE_NONE)

                                return TRUE;

                }

        return FALSE;

}

AIMoves *enum_adjacent(const Board *b, int dist)

{

        AIMoves *moves;

        AIMove move;

        move.weight = AIW_NONE;

        moves = aimoves_new();

        for (move.y = 0; move.y < board_size; move.y++)

                for (move.x = 0; move.x < board_size; move.x++)

                        if (is_adjacent(b, move.x, move.y, dist))

                                aimoves_append(moves, &move);

        aimoves_shuffle(moves);

        return moves;

}

AIMoves *ai_marks(const Board *b, PIECE min)

{

        AIMoves *moves = aimoves_new();

        AIMove move;

        PIECE p;

        for (move.y = 0; move.y < board_size; move.y++)

                for (move.x = 0; move.x < board_size; move.x++)

                        if ((p = piece_at(b, move.x, move.y)) >= min) {

                                move.weight = p - PIECE_THREAT0;

                                aimoves_set(moves, &move);

                        }

        return moves;

}

AIMoves *ai_random(const Board *b)

/* Returns a list of all empty tiles */

{

        AIMove move;

        AIMoves *moves;

        moves = aimoves_new();

        for (move.y = 0; move.y < board_size; move.y++)

                for (move.x = 0; move.x < board_size; move.x++)

                        if (piece_empty(piece_at(b, move.x, move.y))) {

                                move.weight =

                                           g_random_int_range(AIW_MIN, AIW_MAX);

                                aimoves_append(moves, &move);

                        }

        return moves;

}

AIMoves *ai_adjacent(const Board *b)

{

        AIMove move;

        AIMoves *moves;

        /* Get all open tiles adjacent to any piece */

        moves = enum_adjacent(b, 1);

        if (moves->len)

                return moves;

        /* Play in the middle if there are no open adjacent tiles */

        move.x = board_size / 2;

        move.y = board_size / 2;

        move.weight = AIW_NONE;

        aimoves_append(moves, &move);

        return moves;

}

const char *player_to_string(PLAYER p)

{

        return ais[p].l_desc;

}

int number_of_ais(void)

{

        return sizeof (ais) / sizeof (*ais);

}

AI *ai(int n)

{

        if (n >= 0 && n < number_of_ais())

                return ais + n;

        return NULL;

}