This is the doxygen documentation for gtkboard.

.          

---

samegame.c

Go to the documentation of this file.

/*  This file is a part of gtkboard, a board games system.
    Copyright (C) 2003, Arvind Narayanan <arvindn@users.sourceforge.net>

    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., 59 Temple Place - Suite 330, Boston, MA 02111 USA

*/
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <time.h>

#include "game.h"
#include "aaball.h"

#define SAMEGAME_NUM_ANIM 8

#define SAMEGAME_CELL_SIZE 40
#define SAMEGAME_NUM_PIECES (3*SAMEGAME_NUM_ANIM)

#define SAMEGAME_BOARD_WID 15
#define SAMEGAME_BOARD_HEIT 10

#define SAMEGAME_EMPTY 0
#define SAMEGAME_RP 1
#define SAMEGAME_BP 2
#define SAMEGAME_GP 3

char samegame_colors[6] = {50, 50, 50, 50, 50, 50};

void samegame_init ();

Game Samegame = { SAMEGAME_CELL_SIZE, SAMEGAME_BOARD_WID, SAMEGAME_BOARD_HEIT, 
        SAMEGAME_NUM_PIECES, 
        samegame_colors, NULL, /*samegame_pixmaps*/ NULL, 
        "Samegame", 
        samegame_init};

typedef struct
{
        int score;
} Samegame_state;

SCORE_FIELD samegame_score_fields[] = {SCORE_FIELD_RANK, SCORE_FIELD_USER, SCORE_FIELD_SCORE, SCORE_FIELD_TIME, SCORE_FIELD_DATE, SCORE_FIELD_NONE};
char *samegame_score_field_names[] = {"Rank", "User", "Score", "Time", "Date", NULL};

static void recursive_delete (byte *board, int x, int y, int val);
static void pull_down (byte *board);
static byte * synth_move (byte *newboard, byte *board);

static int samegame_animate (Pos *pos, byte **movp);
static int samegame_getmove (Pos *, int, int, GtkboardEventType, Player, byte **, int **);
static char **samegame_get_pixmap (int , int);
static void *samegame_newstate (Pos *, byte *);
static ResultType samegame_who_won (Pos *, Player, char **);
static void samegame_search (Pos *pos, byte **movp);
static void samegame_getxy (byte *board, int *x, int *y);

static int anim_curx=-1, anim_cury=-1;

void samegame_set_init_pos (Pos *pos)
{
        int i;
        for (i=0; i<SAMEGAME_BOARD_WID * SAMEGAME_BOARD_HEIT; i++)
                pos->board[i] = ((random () % 3) + 1) * SAMEGAME_NUM_ANIM;
}

void samegame_init ()
{
        game_single_player = 1;
        game_getmove = samegame_getmove;
        game_set_init_pos = samegame_set_init_pos;
        game_get_pixmap = samegame_get_pixmap;
        game_search = samegame_search;
        game_animate = samegame_animate;
        game_animation_time = 80;
        game_animation_use_movstack = FALSE;
        game_stateful = TRUE;
        game_state_size = sizeof (Samegame_state);
        game_newstate = samegame_newstate;
        game_who_won = samegame_who_won;
        game_scorecmp = game_scorecmp_def_dscore;
        game_score_fields =  samegame_score_fields;
        game_score_field_names = samegame_score_field_names;
        game_doc_about = 
                "Samegame\n"
                "Single player game\n"
                "Status: Fully implemented\n"
                "URL: "GAME_DEFAULT_URL("samegame");
        game_doc_rules = 
                " Samegame rules\n\n"
                "  * Two or more balls of the same color that form a connected region constitute a block.\n"
                "  * Hovering the mouse over a ball will highlight the block that the ball belongs to.\n" 
                "  * Clicking on a ball removes that ball's block.\n"
                "  * You get (n-2)^2 points for removing a block with n balls in it.\n" 
                "  * You get a 1000 point bonus if you remove all the balls.\n"
                "  * The goal is to maximize your score.\n"
                "  * As balls are removed, balls above fall down to take their place. If a column is removed, the column to its right moves to the left.\n"     ;
        game_doc_strategy = 
                " Samegame tips\n\n"
                "  * Try to identify the color which occurs the most number of times.\n"
                "  * Remove balls of the other 2 colors until all the balls of the most frequent color (or as many of them as possible) form a single block.\n"
                "  * Remove this block. Now do the same with the remaining two colors.\n"
                "  * Avoid getting into a situation in which there is a single ball of some color. If this happens you won't be able to clear the entire board.\n"
                ;
}


int samegame_over (byte *board)
{
        int i, j, k;
        int incx[2] = {1, 0};
        int incy[2] = {0, 1};
        for (i=0; i<board_wid; i++)
                for (j=0; j<board_heit; j++)
                        for (k=0; k<2; k++)
                        {
                                int x = i + incx[k], y = j + incy[k];
                                if (board [j * board_wid + i] == 0) continue;
                                if (x < 0 || x > board_wid - 1 || y < 0 || y > board_heit - 1)
                                        continue;
                                if (board [y * board_wid + x] == board [j * board_wid + i])
                                        return FALSE;
                        }
        return TRUE;
}

ResultType samegame_who_won (Pos *pos, Player to_play, char **commp)
{
        static char comment[32];
        gboolean over = samegame_over (pos->board);
        char *scorestr = over ? "Game over. Score:" : "Score:";
        snprintf (comment, 32, "%s %d", scorestr,
                        pos->state ? ((Samegame_state *)pos->state)->score : 0);
        *commp = comment;
        return over ? RESULT_WON : RESULT_NOTYET;
}


static Samegame_state state = {0};

void *samegame_newstate (Pos *pos, byte *move)
{
        int i, score = 0;
        gboolean bonus = FALSE;
        for (i=0; move[3*i] >= 0; i++)
        {
                if (move[3*i] == 0 && move[3*i + 1] == 0 && move[3*i + 2] == 0)
                        bonus = TRUE;
                if (move[3*i+2] == 0)
                        score++;
        }
        score -= 2; score *= score;
        if (score < 0) score = 0;
        state.score = (pos->state ? ((Samegame_state *)pos->state)->score : 0) + score;
        if (bonus)
                state.score += 1000;
        return &state;
}

static byte animgen_buf [SAMEGAME_BOARD_WID * SAMEGAME_BOARD_HEIT];

static void recursive_animgen (byte *board, int x, int y, int val, int newval, byte **mp)
{
        int tmp;
        if (x < 0 || y < 0 || x >= board_wid || y >= board_heit)
                return;
        if (animgen_buf[y * board_wid + x] != 0)
                return;
        if (board [y * board_wid + x] == 0) return;
        if ((board [y * board_wid + x]-1)/SAMEGAME_NUM_ANIM != val)
                return;
        animgen_buf [y * board_wid + x] = 1;
        **mp = x; (*mp)++; **mp = y; (*mp)++;
/*      tmp = board[y * board_wid + x];
        if (tmp % SAMEGAME_NUM_ANIM == 0)
                tmp -= SAMEGAME_NUM_ANIM;
        g_assert (tmp >= 0);*/
        **mp = newval; (*mp)++;
        recursive_animgen (board, x - 1, y   , val, newval, mp);
        recursive_animgen (board, x + 1, y   , val, newval, mp);
        recursive_animgen (board, x    , y - 1, val, newval, mp);
        recursive_animgen (board, x    , y + 1, val, newval, mp);
}

int samegame_animate (Pos *pos, byte **movp)
{
        static byte move[1024];
        static int animdir = 1;
        int i, j;
        byte *mp = move;
        byte *board = pos->board;
        memset (animgen_buf, 0, SAMEGAME_BOARD_WID * SAMEGAME_BOARD_HEIT);
        if (anim_curx >= 0 && anim_cury >= 0 
                        && board [anim_cury * board_wid + anim_curx] != 0)
        {
                int val = board[anim_cury * board_wid + anim_curx];
                if (val % SAMEGAME_NUM_ANIM == 0) animdir = -1;
                if (val % SAMEGAME_NUM_ANIM == 1) animdir = 1;
                recursive_animgen (board, anim_curx, anim_cury, 
                        (val - 1) / SAMEGAME_NUM_ANIM, val + animdir, &mp);
                if (mp - move <= 3)
                        mp = move;
        }
        for (i=0; i<board_wid; i++)
        for (j=0; j<board_heit; j++)
        {
                if (animgen_buf[j * board_wid + i] == 0 
                                && board [j * board_wid + i] % SAMEGAME_NUM_ANIM != 0)
                {
                        // don't let any balls settle at less than max intensity
                        // after they have finished animating
                        int newval = board [j * board_wid + i] + SAMEGAME_NUM_ANIM - 
                                board [j * board_wid + i] % SAMEGAME_NUM_ANIM;
                        *mp++ = i;
                        *mp++ = j;
                        *mp++ = newval;
                }
        }
        *mp = -1;
        if (mp - move < 3) return -1;
        *movp = move;
        return 1;
}

static int getmove_real (Pos *pos, int x, int y, byte **movp)
{
        byte *newboard, val;
        if ((val = pos->board[y * board_wid + x]) == 0) 
                return -1;
        /* do we have at least 1 neighbor */
        do
        {
                if (x > 0 && val == pos->board[y * board_wid + x - 1])
                        break;
                if (x < board_wid -1 && val == pos->board[y * board_wid + x + 1 ])
                        break;
                if (y > 0 && val == pos->board[(y-1) * board_wid + x])
                        break;
                if (y < board_heit && val == pos->board[(y+1) * board_wid + x])
                        break;
                return -1;
        } while (0);
                
        newboard = (byte *) malloc (board_wid * board_heit);
        assert (newboard);
        memcpy (newboard, pos->board, board_wid * board_heit);
        recursive_delete (newboard, x, y, newboard[y * board_wid + x]);
        pull_down (newboard);
        if (movp)
                *movp = synth_move (newboard, pos->board);
        free (newboard);
        
        return 1;
}

int samegame_getmove 
        (Pos *pos, int x, int y, GtkboardEventType type, Player to_play, byte **movp, int ** rmovep)
{
        if (type == GTKBOARD_MOTION_NOTIFY)
        {
                anim_curx = x;
                anim_cury = y;
        }
        if (type == GTKBOARD_LEAVE_NOTIFY)
        {
                anim_curx = -1;
                anim_cury = -1;
        }
        if (type != GTKBOARD_BUTTON_RELEASE)
                return 0;

        return getmove_real (pos, x, y, movp);
}

static void recursive_delete (byte *board, int x, int y, int val)
{
        if (x < 0 || y < 0 || x >= board_wid || y >= board_heit)
                return;
        if (board[y * board_wid + x] != val)
                return;
        board[y * board_wid + x] = 0;
        recursive_delete (board, x - 1, y   , val);
        recursive_delete (board, x + 1, y   , val);
        recursive_delete (board, x    , y - 1, val);
        recursive_delete (board, x    , y + 1, val);
}

static void pull_down (byte *board)
{
        int i, j, k, cnt;
        byte *tempcol;
        tempcol = (byte *) malloc (board_heit);
        assert (tempcol);

        /* for each column apply gravity */
        for (i=0; i<board_wid; i++)
        {
                for (j=0, k=0; j<board_heit; j++)
                {
                        if (board[j * board_wid + i])
                                tempcol[k++] = board [j * board_wid + i];
                }
                for (; k<board_heit; k++)
                        tempcol[k] = 0;
                for (j=0; j<board_heit; j++)
                        board[j * board_wid + i] = tempcol [j];
        }

        for (cnt = 0; cnt < board_wid; cnt++) // ugly, but works
        {
                /* if a column is empty move the col to its right in its place */
                for (i=0; i<board_wid - 1; i++)
                {
                        for (j=0; j<board_heit; j++)
                                if (board[j * board_wid + i])
                                        break;
                        if (j == board_heit)    /* col is empty */
                                for (j=0; j<board_heit; j++)
                                {
                                        board [j * board_wid + i]       = board [j * board_wid + i + 1];
                                        board [j * board_wid + i + 1] = 0;
                                }
                }
        }
        free (tempcol);
}

static byte * synth_move (byte *newboard, byte *board)
{
        static byte movbuf [1024];
        int i, j, m = 0;
        for (i=0; i<board_wid; i++)
                for (j=0; j<board_heit; j++)
                        if (newboard [j * board_wid + i] != board [j * board_wid + i])
                        {
                                movbuf[m++] = i;
                                movbuf[m++] = j;
                                movbuf[m++] = newboard [j * board_wid + i];
                        }
        movbuf[m] = -1;
        return movbuf;
}

char ** samegame_get_pixmap (int idx, int color)
{
        int bg, fg = 0, i, tmp;
        static char pixbuf[SAMEGAME_CELL_SIZE*(SAMEGAME_CELL_SIZE+1)];
        static gboolean first = TRUE;
        for(i=0, bg=0;i<3;i++) 
        { int col = samegame_colors[i]; 
                if (col<0) col += 256; bg += col * (1 << (16-8*i));}
        idx--;
        tmp = idx%SAMEGAME_NUM_ANIM;
        if (tmp == SAMEGAME_NUM_ANIM-1) fg = 255;
        else
                fg = 256 * (SAMEGAME_NUM_ANIM-1 + tmp) / (2*(SAMEGAME_NUM_ANIM-1));
        switch (idx/SAMEGAME_NUM_ANIM + 1)
        {
                case SAMEGAME_RP: fg *= 0x010000; break;
                case SAMEGAME_GP: fg *= 0x000100; break;
                case SAMEGAME_BP: fg *= 0x000001; break;
        }
        if (first)
        {
                first = FALSE;
                return pixmap_ball_gen (SAMEGAME_CELL_SIZE, pixbuf, fg, bg, 
                        SAMEGAME_CELL_SIZE * 2/7, 24.0);
        }
        return pixmap_header_gen (SAMEGAME_CELL_SIZE, pixbuf, fg, bg);
}

void samegame_search (Pos *pos, byte **movp)
{
        int x, y;
        int retval;
        samegame_getxy (pos->board, &x, &y);
        retval = getmove_real (pos, x, y, movp);
        assert (retval > 0);
}

void samegame_getxy (byte *board, int *x, int *y)
{
        int i, j;
        for (i=0; i<board_wid; i++)
        for (j=0; j<board_heit; j++)
        {
                int val = board [j * board_wid + i];
                if (val == SAMEGAME_EMPTY) continue;
                if ((i > 0 && board [j * board_wid + i-1] == val) || 
                                (j > 0 && board [(j-1) * board_wid + i] == val))
                {
                        *x = i;
                        *y = j;
                        return;
                }
        }
}