← Back to branch summary

~ubuntu-branches/ubuntu/natty/gtkboard/natty

« back to all changes in this revision

Viewing changes to .pc/debian-changes-0.11pre0+cvs.2003.11.02-1/src/infiltrate.c

  • Committer: Bazaar Package Importer
  • Author(s): Barak A. Pearlmutter
  • Date: 2011-02-28 11:25:02 UTC
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20110228112502-e9aah248wxelm7ao
Tags: 0.11pre0+cvs.2003.11.02-2
autotools tweaks, most notably -lSDL to supplement -lSDL_mixer

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/debian-changes-0.11pre0+cvs.2003.11.02-1/src/infiltrate.c
1
 
/*  This file is a part of gtkboard, a board games system.
2
 
    Copyright (C) 2003, Arvind Narayanan <arvindn@users.sourceforge.net>
3
 
 
4
 
    This program is free software; you can redistribute it and/or modify
5
 
    it under the terms of the GNU General Public License as published by
6
 
    the Free Software Foundation; either version 2 of the License, or
7
 
    (at your option) any later version.
8
 
 
9
 
    This program is distributed in the hope that it will be useful,
10
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
    GNU General Public License for more details.
13
 
 
14
 
    You should have received a copy of the GNU General Public License
15
 
    along with this program; if not, write to the Free Software
16
 
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA
17
 
 
18
 
*/
19
 
#include <stdio.h>
20
 
#include <string.h>
21
 
#include <stdlib.h>
22
 
#include <math.h>
23
 
 
24
 
#include "game.h"
25
 
#include "aaball.h"
26
 
 
27
 
#define INFILTRATE_CELL_SIZE 40
28
 
#define INFILTRATE_NUM_PIECES 2
29
 
 
30
 
#define INFILTRATE_BOARD_WID 5
31
 
#define INFILTRATE_BOARD_HEIT 5
32
 
 
33
 
#define INFILTRATE_EMPTY 0
34
 
#define INFILTRATE_WP 1
35
 
#define INFILTRATE_BP 2
36
 
 
37
 
char infiltrate_colors[] = 
38
 
        {180, 180, 180, 
39
 
        200, 200, 200};
40
 
        
41
 
int     infiltrate_init_pos[] = 
42
 
{
43
 
         2 , 2 , 2 , 2 , 2 ,
44
 
         2 , 0 , 0 , 0 , 2 ,
45
 
         0 , 0 , 0 , 0 , 0 ,
46
 
         1 , 0 , 0 , 0 , 1 ,
47
 
         1 , 1 , 1 , 1 , 1 ,
48
 
};
49
 
 
50
 
static int infiltrate_max_moves = 200;
51
 
 
52
 
 
53
 
void infiltrate_init ();
54
 
int infiltrate_getmove (Pos *, int, int, GtkboardEventType, Player, byte **, int **);
55
 
//ResultType infiltrate_who_won (byte *, int, char **);
56
 
byte *infiltrate_movegen (Pos *);
57
 
ResultType infiltrate_eval (Pos *, Player, float *);
58
 
guchar * infiltrate_get_rgbmap (int idx, int color);
59
 
void infiltrate_reset_uistate ();
60
 
        
61
 
Game Infiltrate = 
62
 
        { INFILTRATE_CELL_SIZE, INFILTRATE_BOARD_WID, INFILTRATE_BOARD_HEIT, 
63
 
        INFILTRATE_NUM_PIECES,
64
 
        infiltrate_colors, infiltrate_init_pos, NULL, "Infiltrate", NULL,
65
 
        infiltrate_init};
66
 
 
67
 
void infiltrate_init ()
68
 
{
69
 
        game_getmove = infiltrate_getmove;
70
 
        game_movegen = infiltrate_movegen;
71
 
        //game_who_won = infiltrate_who_won;
72
 
        game_eval = infiltrate_eval;
73
 
        game_get_rgbmap = infiltrate_get_rgbmap;
74
 
        game_reset_uistate = infiltrate_reset_uistate;
75
 
        game_doc_about_status = STATUS_PARTIAL;
76
 
        game_doc_about = 
77
 
                "Infiltrate\n"
78
 
                "Two player game\n"
79
 
                "Status: Partially implemented\n"
80
 
                "URL: "GAME_DEFAULT_URL ("infiltrate");
81
 
        game_doc_rules = 
82
 
                "The pieces move diagonally, one square at a time. The objective is to get all your pieces to the starting squares of your opponent's pieces.\n";
83
 
}
84
 
 
85
 
byte * infiltrate_movegen (Pos *pos)
86
 
{
87
 
        int i, j, diffx, diffy;
88
 
        byte movbuf [256];
89
 
        byte *movlist, *mp = movbuf;
90
 
        byte *board = pos->board;
91
 
        Player player = pos->player;
92
 
        for (i=0; i<board_wid; i++)
93
 
        for (j=0; j<board_heit; j++)
94
 
        {
95
 
                if (player == BLACK && (board [j * board_wid + i] != INFILTRATE_BP))
96
 
                        continue;
97
 
                if (player == WHITE && (board [j * board_wid + i] != INFILTRATE_WP))
98
 
                        continue;
99
 
                for (diffx = -1; diffx <= 1; diffx += 2)
100
 
                for (diffy = -1; diffy <= 1; diffy += 2)
101
 
                {
102
 
                        int x, y;
103
 
                        if (!ISINBOARD(x = i+diffx, y = j+diffy)) continue;
104
 
                        if (board [y * board_wid + x] != 0) continue;
105
 
                        *mp++ = i; *mp++ = j; *mp++ = 0;
106
 
                        *mp++ = i + diffx; *mp++ = j + diffy; 
107
 
                        *mp++ = (player == WHITE ? INFILTRATE_WP : INFILTRATE_BP);
108
 
                        *mp++ = -1;
109
 
                }
110
 
        }
111
 
        if (mp == movbuf)
112
 
                *mp++ = -1;
113
 
        *mp++ = -2;
114
 
        movlist = (byte *) (malloc (mp - movbuf));
115
 
        memcpy (movlist, movbuf, (mp - movbuf));
116
 
        return movlist;
117
 
}
118
 
 
119
 
ResultType infiltrate_eval (Pos *pos, Player to_play, float *eval)
120
 
{
121
 
        float sum = 0;
122
 
        int i, j;
123
 
        for (i=0; i<board_wid; i++)
124
 
        for (j=0; j<board_heit; j++)
125
 
                if (pos->board [j * board_wid + i])
126
 
                        sum += j;
127
 
        *eval = sum;
128
 
        return RESULT_NOTYET;
129
 
 
130
 
}
131
 
 
132
 
static int oldx = -1, oldy = -1;
133
 
 
134
 
void infiltrate_reset_uistate ()
135
 
{
136
 
        oldx = -1, oldy = -1;
137
 
}
138
 
        
139
 
int infiltrate_getmove (Pos *pos, int x, int y, GtkboardEventType type, Player to_play, 
140
 
                byte **movp, int ** rmovep)
141
 
{
142
 
        static byte move[10];
143
 
        byte *mp = move;
144
 
        byte *board = pos->board;
145
 
        if (type != GTKBOARD_BUTTON_RELEASE) return 0;
146
 
        if (oldx < 0)
147
 
        {
148
 
                int val = board [y * board_wid + x];
149
 
                if ((val != INFILTRATE_BP && !(to_play == WHITE)) ||
150
 
                (val != INFILTRATE_WP && !(to_play == BLACK)))
151
 
                        return -1;
152
 
                oldx = x; oldy = y;
153
 
                return 0;
154
 
        }
155
 
        else
156
 
        {
157
 
                int diffx, diffy;
158
 
                diffx = x - oldx;
159
 
                diffy = y - oldy;
160
 
                if (abs (diffx) != 1 || abs (diffy) != 1)
161
 
                {
162
 
                        oldx = -1; oldy = -1;
163
 
                        return -1;
164
 
                }
165
 
                if (board [y * board_wid + x] != INFILTRATE_EMPTY)
166
 
                {
167
 
                        oldx = -1; oldy = -1;
168
 
                        return -1;
169
 
                }
170
 
                *mp++ = oldx; *mp++ = oldy; *mp++ = 0;
171
 
                *mp++ = x; *mp++ = y; *mp++ = board [oldy * board_wid + oldx];
172
 
                *mp++ = -1;
173
 
                *movp = move;
174
 
                oldx = oldy = -1;
175
 
                return 1;
176
 
 
177
 
        }
178
 
}
179
 
 
180
 
guchar *infiltrate_get_rgbmap (int idx, int color)
181
 
{
182
 
        static guchar rgbbuf[3*INFILTRATE_CELL_SIZE*INFILTRATE_CELL_SIZE];
183
 
        int fg, bg, i;
184
 
        char *colors;
185
 
        colors = infiltrate_colors;
186
 
        fg = (idx == INFILTRATE_WP ? 0xffffff : 0x0000ff);
187
 
        if (color == BLACK) colors += 3;
188
 
        for(i=0, bg=0;i<3;i++) 
189
 
        { int col = colors[i]; if (col<0) col += 256; bg += col * (1 << (16-8*i));}
190
 
        rgbmap_ball_shadow_gen(INFILTRATE_CELL_SIZE, rgbbuf, fg, bg, 8, 24, 2);
191
 
        return rgbbuf;
192
 
}
193
 
 
194
 
/*
195
 
char ** infiltrate_get_pixmap (int idx, int color)
196
 
{
197
 
        int bg;
198
 
        int i;
199
 
        static char pixbuf[INFILTRATE_CELL_SIZE * (INFILTRATE_CELL_SIZE+1)];
200
 
        for(i=0, bg=0;i<3;i++) 
201
 
        { int col = infiltrate_colors[i]; 
202
 
                if (col<0) col += 256; bg += col * (1 << (16-8*i));}
203
 
        return pixmap_ball_gen (INFILTRATE_CELL_SIZE, pixbuf,
204
 
                        idx == INFILTRATE_WP ? 0xffffff : 0x0000ff, bg, 
205
 
                        8, 24);
206
 
}
207
 
*/