2 * pegs.c: the classic Peg Solitaire game.
28 * Grid shapes. I do some macro ickery here to ensure that my enum
29 * and the various forms of my name list always match up.
32 A(CROSS,Cross,cross) \
33 A(OCTAGON,Octagon,octagon) \
34 A(RANDOM,Random,random)
35 #define ENUM(upper,title,lower) TYPE_ ## upper,
36 #define TITLE(upper,title,lower) #title,
37 #define LOWER(upper,title,lower) #lower,
38 #define CONFIG(upper,title,lower) ":" #title
40 enum { TYPELIST(ENUM
) TYPECOUNT
};
41 static char const *const pegs_titletypes
[] = { TYPELIST(TITLE
) };
42 static char const *const pegs_lowertypes
[] = { TYPELIST(LOWER
) };
43 #define TYPECONFIG TYPELIST(CONFIG)
45 #define FLASH_FRAME 0.13F
58 static game_params
*default_params(void)
60 game_params
*ret
= snew(game_params
);
63 ret
->type
= TYPE_CROSS
;
68 static const struct game_params pegs_presets
[] = {
76 static int game_fetch_preset(int i
, char **name
, game_params
**params
)
81 if (i
< 0 || i
>= lenof(pegs_presets
))
84 ret
= snew(game_params
);
85 *ret
= pegs_presets
[i
];
87 strcpy(str
, pegs_titletypes
[ret
->type
]);
88 if (ret
->type
== TYPE_RANDOM
)
89 sprintf(str
+ strlen(str
), " %dx%d", ret
->w
, ret
->h
);
96 static void free_params(game_params
*params
)
101 static game_params
*dup_params(game_params
*params
)
103 game_params
*ret
= snew(game_params
);
104 *ret
= *params
; /* structure copy */
108 static void decode_params(game_params
*params
, char const *string
)
110 char const *p
= string
;
114 while (*p
&& isdigit((unsigned char)*p
)) p
++;
118 while (*p
&& isdigit((unsigned char)*p
)) p
++;
120 params
->h
= params
->w
;
123 for (i
= 0; i
< lenof(pegs_lowertypes
); i
++)
124 if (!strcmp(p
, pegs_lowertypes
[i
]))
128 static char *encode_params(game_params
*params
, int full
)
132 sprintf(str
, "%dx%d", params
->w
, params
->h
);
134 assert(params
->type
>= 0 && params
->type
< lenof(pegs_lowertypes
));
135 strcat(str
, pegs_lowertypes
[params
->type
]);
140 static config_item
*game_configure(game_params
*params
)
142 config_item
*ret
= snewn(4, config_item
);
145 ret
[0].name
= "Width";
146 ret
[0].type
= C_STRING
;
147 sprintf(buf
, "%d", params
->w
);
148 ret
[0].sval
= dupstr(buf
);
151 ret
[1].name
= "Height";
152 ret
[1].type
= C_STRING
;
153 sprintf(buf
, "%d", params
->h
);
154 ret
[1].sval
= dupstr(buf
);
157 ret
[2].name
= "Board type";
158 ret
[2].type
= C_CHOICES
;
159 ret
[2].sval
= TYPECONFIG
;
160 ret
[2].ival
= params
->type
;
170 static game_params
*custom_params(config_item
*cfg
)
172 game_params
*ret
= snew(game_params
);
174 ret
->w
= atoi(cfg
[0].sval
);
175 ret
->h
= atoi(cfg
[1].sval
);
176 ret
->type
= cfg
[2].ival
;
181 static char *validate_params(game_params
*params
, int full
)
183 if (full
&& (params
->w
<= 3 || params
->h
<= 3))
184 return "Width and height must both be greater than three";
187 * It might be possible to implement generalisations of Cross
188 * and Octagon, but only if I can find a proof that they're all
189 * soluble. For the moment, therefore, I'm going to disallow
190 * them at any size other than the standard one.
192 if (full
&& (params
->type
== TYPE_CROSS
|| params
->type
== TYPE_OCTAGON
)) {
193 if (params
->w
!= 7 || params
->h
!= 7)
194 return "This board type is only supported at 7x7";
199 /* ----------------------------------------------------------------------
200 * Beginning of code to generate random Peg Solitaire boards.
202 * This procedure is done with no aesthetic judgment, no effort at
203 * symmetry, no difficulty grading and generally no finesse
204 * whatsoever. We simply begin with an empty board containing a
205 * single peg, and repeatedly make random reverse moves until it's
206 * plausibly full. This typically yields a scrappy haphazard mess
207 * with several holes, an uneven shape, and no redeeming features
208 * except guaranteed solubility.
210 * My only concessions to sophistication are (a) to repeat the
211 * generation process until I at least get a grid that touches
212 * every edge of the specified board size, and (b) to try when
213 * selecting moves to reuse existing space rather than expanding
214 * into new space (so that non-rectangular board shape becomes a
215 * factor during play).
220 * x,y are the start point of the move during generation (hence
221 * its endpoint during normal play).
223 * dx,dy are the direction of the move during generation.
224 * Absolute value 1. Hence, for example, x=3,y=5,dx=1,dy=0
225 * means that the move during generation starts at (3,5) and
226 * ends at (5,5), and vice versa during normal play.
230 * cost is 0, 1 or 2, depending on how many GRID_OBSTs we must
231 * turn into GRID_HOLEs to play this move.
236 static int movecmp(void *av
, void *bv
)
238 struct move
*a
= (struct move
*)av
;
239 struct move
*b
= (struct move
*)bv
;
243 else if (a
->y
> b
->y
)
248 else if (a
->x
> b
->x
)
253 else if (a
->dy
> b
->dy
)
258 else if (a
->dx
> b
->dx
)
264 static int movecmpcost(void *av
, void *bv
)
266 struct move
*a
= (struct move
*)av
;
267 struct move
*b
= (struct move
*)bv
;
269 if (a
->cost
< b
->cost
)
271 else if (a
->cost
> b
->cost
)
274 return movecmp(av
, bv
);
278 tree234
*bymove
, *bycost
;
281 static void update_moves(unsigned char *grid
, int w
, int h
, int x
, int y
,
282 struct movetrees
*trees
)
288 * There are twelve moves that can include (x,y): three in each
289 * of four directions. Check each one to see if it's possible.
291 for (dir
= 0; dir
< 4; dir
++) {
295 dx
= 0, dy
= dir
- 2;
297 dy
= 0, dx
= dir
- 1;
299 assert(abs(dx
) + abs(dy
) == 1);
301 for (pos
= 0; pos
< 3; pos
++) {
309 if (move
.x
< 0 || move
.x
>= w
|| move
.y
< 0 || move
.y
>= h
)
310 continue; /* completely invalid move */
311 if (move
.x
+2*move
.dx
< 0 || move
.x
+2*move
.dx
>= w
||
312 move
.y
+2*move
.dy
< 0 || move
.y
+2*move
.dy
>= h
)
313 continue; /* completely invalid move */
315 v1
= grid
[move
.y
* w
+ move
.x
];
316 v2
= grid
[(move
.y
+move
.dy
) * w
+ (move
.x
+move
.dx
)];
317 v3
= grid
[(move
.y
+2*move
.dy
)*w
+ (move
.x
+2*move
.dx
)];
318 if (v1
== GRID_PEG
&& v2
!= GRID_PEG
&& v3
!= GRID_PEG
) {
321 move
.cost
= (v2
== GRID_OBST
) + (v3
== GRID_OBST
);
324 * This move is possible. See if it's already in
327 m
= find234(trees
->bymove
, &move
, NULL
);
328 if (m
&& m
->cost
!= move
.cost
) {
330 * It's in the tree but listed with the wrong
331 * cost. Remove the old version.
333 #ifdef GENERATION_DIAGNOSTICS
334 printf("correcting %d%+d,%d%+d at cost %d\n",
335 m
->x
, m
->dx
, m
->y
, m
->dy
, m
->cost
);
337 del234(trees
->bymove
, m
);
338 del234(trees
->bycost
, m
);
344 m
= snew(struct move
);
346 m2
= add234(trees
->bymove
, m
);
347 m2
= add234(trees
->bycost
, m
);
349 #ifdef GENERATION_DIAGNOSTICS
350 printf("adding %d%+d,%d%+d at cost %d\n",
351 move
.x
, move
.dx
, move
.y
, move
.dy
, move
.cost
);
354 #ifdef GENERATION_DIAGNOSTICS
355 printf("not adding %d%+d,%d%+d at cost %d\n",
356 move
.x
, move
.dx
, move
.y
, move
.dy
, move
.cost
);
361 * This move is impossible. If it is already in the
364 * (We make use here of the fact that del234
365 * doesn't have to be passed a pointer to the
366 * _actual_ element it's deleting: it merely needs
367 * one that compares equal to it, and it will
368 * return the one it deletes.)
370 struct move
*m
= del234(trees
->bymove
, &move
);
371 #ifdef GENERATION_DIAGNOSTICS
372 printf("%sdeleting %d%+d,%d%+d\n", m ?
"" : "not ",
373 move
.x
, move
.dx
, move
.y
, move
.dy
);
376 del234(trees
->bycost
, m
);
384 static void pegs_genmoves(unsigned char *grid
, int w
, int h
, random_state
*rs
)
386 struct movetrees atrees
, *trees
= &atrees
;
390 trees
->bymove
= newtree234(movecmp
);
391 trees
->bycost
= newtree234(movecmpcost
);
393 for (y
= 0; y
< h
; y
++)
394 for (x
= 0; x
< w
; x
++)
395 if (grid
[y
*w
+x
] == GRID_PEG
)
396 update_moves(grid
, w
, h
, x
, y
, trees
);
401 int limit
, maxcost
, index
;
402 struct move mtmp
, move
, *m
;
405 * See how many moves we can make at zero cost. Make one,
406 * if possible. Failing that, make a one-cost move, and
407 * then a two-cost one.
409 * After filling at least half the input grid, we no longer
410 * accept cost-2 moves: if that's our only option, we give
414 maxcost
= (nmoves
< w
*h
/2 ?
2 : 1);
415 m
= NULL
; /* placate optimiser */
416 for (mtmp
.cost
= 0; mtmp
.cost
<= maxcost
; mtmp
.cost
++) {
418 m
= findrelpos234(trees
->bycost
, &mtmp
, NULL
, REL234_LT
, &limit
);
419 #ifdef GENERATION_DIAGNOSTICS
420 printf("%d moves available with cost %d\n", limit
+1, mtmp
.cost
);
428 index
= random_upto(rs
, limit
+1);
429 move
= *(struct move
*)index234(trees
->bycost
, index
);
431 #ifdef GENERATION_DIAGNOSTICS
432 printf("selecting move %d%+d,%d%+d at cost %d\n",
433 move
.x
, move
.dx
, move
.y
, move
.dy
, move
.cost
);
436 grid
[move
.y
* w
+ move
.x
] = GRID_HOLE
;
437 grid
[(move
.y
+move
.dy
) * w
+ (move
.x
+move
.dx
)] = GRID_PEG
;
438 grid
[(move
.y
+2*move
.dy
)*w
+ (move
.x
+2*move
.dx
)] = GRID_PEG
;
440 for (i
= 0; i
<= 2; i
++) {
441 int tx
= move
.x
+ i
*move
.dx
;
442 int ty
= move
.y
+ i
*move
.dy
;
443 update_moves(grid
, w
, h
, tx
, ty
, trees
);
449 while ((m
= delpos234(trees
->bymove
, 0)) != NULL
) {
450 del234(trees
->bycost
, m
);
453 freetree234(trees
->bymove
);
454 freetree234(trees
->bycost
);
457 static void pegs_generate(unsigned char *grid
, int w
, int h
, random_state
*rs
)
462 memset(grid
, GRID_OBST
, w
*h
);
463 grid
[(h
/2) * w
+ (w
/2)] = GRID_PEG
;
464 #ifdef GENERATION_DIAGNOSTICS
465 printf("beginning move selection\n");
467 pegs_genmoves(grid
, w
, h
, rs
);
468 #ifdef GENERATION_DIAGNOSTICS
469 printf("finished move selection\n");
473 for (y
= 0; y
< h
; y
++) {
474 if (grid
[y
*w
+0] != GRID_OBST
)
476 if (grid
[y
*w
+w
-1] != GRID_OBST
)
479 for (x
= 0; x
< w
; x
++) {
480 if (grid
[0*w
+x
] != GRID_OBST
)
482 if (grid
[(h
-1)*w
+x
] != GRID_OBST
)
488 #ifdef GENERATION_DIAGNOSTICS
489 printf("insufficient extent; trying again\n");
492 #ifdef GENERATION_DIAGNOSTICS
497 /* ----------------------------------------------------------------------
498 * End of board generation code. Now for the client code which uses
499 * it as part of the puzzle.
502 static char *new_game_desc(game_params
*params
, random_state
*rs
,
503 char **aux
, int interactive
)
505 int w
= params
->w
, h
= params
->h
;
510 grid
= snewn(w
*h
, unsigned char);
511 if (params
->type
== TYPE_RANDOM
) {
512 pegs_generate(grid
, w
, h
, rs
);
516 for (y
= 0; y
< h
; y
++)
517 for (x
= 0; x
< w
; x
++) {
518 v
= GRID_OBST
; /* placate optimiser */
519 switch (params
->type
) {
523 if (cx
== 0 && cy
== 0)
525 else if (cx
> 1 && cy
> 1)
533 if (cx
+ cy
> 1 + max(w
,h
)/2)
542 if (params
->type
== TYPE_OCTAGON
) {
544 * The octagonal (European) solitaire layout is
545 * actually _insoluble_ with the starting hole at the
546 * centre. Here's a proof:
548 * Colour the squares of the board diagonally in
549 * stripes of three different colours, which I'll call
550 * A, B and C. So the board looks like this:
560 * Suppose we keep running track of the number of pegs
561 * occuping each colour of square. This colouring has
562 * the property that any valid move whatsoever changes
563 * all three of those counts by one (two of them go
564 * down and one goes up), which means that the _parity_
565 * of every count flips on every move.
567 * If the centre square starts off unoccupied, then
568 * there are twelve pegs on each colour and all three
569 * counts start off even; therefore, after 35 moves all
570 * three counts would have to be odd, which isn't
571 * possible if there's only one peg left. []
573 * This proof works just as well if the starting hole
574 * is _any_ of the thirteen positions labelled B. Also,
575 * we can stripe the board in the opposite direction
576 * and rule out any square labelled B in that colouring
577 * as well. This leaves:
587 * where the ns are squares we've proved insoluble, and
588 * the Ys are the ones remaining.
590 * That doesn't prove all those starting positions to
591 * be soluble, of course; they're merely the ones we
592 * _haven't_ proved to be impossible. Nevertheless, it
593 * turns out that they are all soluble, so when the
594 * user requests an Octagon board the simplest thing is
595 * to pick one of these at random.
597 * Rather than picking equiprobably from those twelve
598 * positions, we'll pick equiprobably from the three
599 * equivalence classes
601 switch (random_upto(rs
, 3)) {
603 /* Remove a random corner piece. */
607 dx
= random_upto(rs
, 2) * 2 - 1; /* +1 or -1 */
608 dy
= random_upto(rs
, 2) * 2 - 1; /* +1 or -1 */
609 if (random_upto(rs
, 2))
613 grid
[(3+dy
)*w
+(3+dx
)] = GRID_HOLE
;
617 /* Remove a random piece two from the centre. */
620 dx
= 2 * (random_upto(rs
, 2) * 2 - 1);
621 if (random_upto(rs
, 2))
625 grid
[(3+dy
)*w
+(3+dx
)] = GRID_HOLE
;
628 default /* case 2 */:
629 /* Remove a random piece one from the centre. */
632 dx
= random_upto(rs
, 2) * 2 - 1;
633 if (random_upto(rs
, 2))
637 grid
[(3+dy
)*w
+(3+dx
)] = GRID_HOLE
;
645 * Encode a game description which is simply a long list of P
646 * for peg, H for hole or O for obstacle.
648 ret
= snewn(w
*h
+1, char);
649 for (i
= 0; i
< w
*h
; i
++)
650 ret
[i
] = (grid
[i
] == GRID_PEG ?
'P' :
651 grid
[i
] == GRID_HOLE ?
'H' : 'O');
659 static char *validate_desc(game_params
*params
, char *desc
)
661 int len
= params
->w
* params
->h
;
663 if (len
!= strlen(desc
))
664 return "Game description is wrong length";
665 if (len
!= strspn(desc
, "PHO"))
666 return "Invalid character in game description";
671 static game_state
*new_game(midend_data
*me
, game_params
*params
, char *desc
)
673 int w
= params
->w
, h
= params
->h
;
674 game_state
*state
= snew(game_state
);
679 state
->completed
= 0;
680 state
->grid
= snewn(w
*h
, unsigned char);
681 for (i
= 0; i
< w
*h
; i
++)
682 state
->grid
[i
] = (desc
[i
] == 'P' ? GRID_PEG
:
683 desc
[i
] == 'H' ? GRID_HOLE
: GRID_OBST
);
688 static game_state
*dup_game(game_state
*state
)
690 int w
= state
->w
, h
= state
->h
;
691 game_state
*ret
= snew(game_state
);
695 ret
->completed
= state
->completed
;
696 ret
->grid
= snewn(w
*h
, unsigned char);
697 memcpy(ret
->grid
, state
->grid
, w
*h
);
702 static void free_game(game_state
*state
)
708 static char *solve_game(game_state
*state
, game_state
*currstate
,
709 char *aux
, char **error
)
714 static char *game_text_format(game_state
*state
)
716 int w
= state
->w
, h
= state
->h
;
720 ret
= snewn((w
+1)*h
+ 1, char);
722 for (y
= 0; y
< h
; y
++) {
723 for (x
= 0; x
< w
; x
++)
724 ret
[y
*(w
+1)+x
] = (state
->grid
[y
*w
+x
] == GRID_HOLE ?
'-' :
725 state
->grid
[y
*w
+x
] == GRID_PEG ?
'*' : ' ');
726 ret
[y
*(w
+1)+w
] = '\n';
734 int dragging
; /* boolean: is a drag in progress? */
735 int sx
, sy
; /* grid coords of drag start cell */
736 int dx
, dy
; /* pixel coords of current drag posn */
739 static game_ui
*new_ui(game_state
*state
)
741 game_ui
*ui
= snew(game_ui
);
743 ui
->sx
= ui
->sy
= ui
->dx
= ui
->dy
= 0;
744 ui
->dragging
= FALSE
;
749 static void free_ui(game_ui
*ui
)
754 static char *encode_ui(game_ui
*ui
)
759 static void decode_ui(game_ui
*ui
, char *encoding
)
763 static void game_changed_state(game_ui
*ui
, game_state
*oldstate
,
764 game_state
*newstate
)
767 * Cancel a drag, in case the source square has become
770 ui
->dragging
= FALSE
;
773 #define PREFERRED_TILE_SIZE 33
774 #define TILESIZE (ds->tilesize)
775 #define BORDER (TILESIZE / 2)
777 #define HIGHLIGHT_WIDTH (TILESIZE / 16)
779 #define COORD(x) ( BORDER + (x) * TILESIZE )
780 #define FROMCOORD(x) ( ((x) + TILESIZE - BORDER) / TILESIZE - 1 )
782 struct game_drawstate
{
784 blitter
*drag_background
;
785 int dragging
, dragx
, dragy
;
792 static char *interpret_move(game_state
*state
, game_ui
*ui
, game_drawstate
*ds
,
793 int x
, int y
, int button
)
795 int w
= state
->w
, h
= state
->h
;
797 if (button
== LEFT_BUTTON
) {
801 * Left button down: we attempt to start a drag.
805 * There certainly shouldn't be a current drag in progress,
806 * unless the midend failed to send us button events in
807 * order; it has a responsibility to always get that right,
808 * so we can legitimately punish it by failing an
811 assert(!ui
->dragging
);
815 if (tx
>= 0 && tx
< w
&& ty
>= 0 && ty
< h
&&
816 state
->grid
[ty
*w
+tx
] == GRID_PEG
) {
822 return ""; /* ui modified */
824 } else if (button
== LEFT_DRAG
&& ui
->dragging
) {
826 * Mouse moved; just move the peg being dragged.
830 return ""; /* ui modified */
831 } else if (button
== LEFT_RELEASE
&& ui
->dragging
) {
836 * Button released. Identify the target square of the drag,
837 * see if it represents a valid move, and if so make it.
839 ui
->dragging
= FALSE
; /* cancel the drag no matter what */
842 if (tx
< 0 || tx
>= w
|| ty
< 0 || ty
>= h
)
843 return ""; /* target out of range */
846 if (max(abs(dx
),abs(dy
)) != 2 || min(abs(dx
),abs(dy
)) != 0)
847 return ""; /* move length was wrong */
851 if (state
->grid
[ty
*w
+tx
] != GRID_HOLE
||
852 state
->grid
[(ty
-dy
)*w
+(tx
-dx
)] != GRID_PEG
||
853 state
->grid
[ui
->sy
*w
+ui
->sx
] != GRID_PEG
)
854 return ""; /* grid contents were invalid */
857 * We have a valid move. Encode it simply as source and
858 * destination coordinate pairs.
860 sprintf(buf
, "%d,%d-%d,%d", ui
->sx
, ui
->sy
, tx
, ty
);
866 static game_state
*execute_move(game_state
*state
, char *move
)
868 int w
= state
->w
, h
= state
->h
;
872 if (sscanf(move
, "%d,%d-%d,%d", &sx
, &sy
, &tx
, &ty
)) {
875 if (sx
< 0 || sx
>= w
|| sy
< 0 || sy
>= h
)
876 return NULL
; /* source out of range */
877 if (tx
< 0 || tx
>= w
|| ty
< 0 || ty
>= h
)
878 return NULL
; /* target out of range */
882 if (max(abs(dx
),abs(dy
)) != 2 || min(abs(dx
),abs(dy
)) != 0)
883 return NULL
; /* move length was wrong */
887 if (state
->grid
[sy
*w
+sx
] != GRID_PEG
||
888 state
->grid
[my
*w
+mx
] != GRID_PEG
||
889 state
->grid
[ty
*w
+tx
] != GRID_HOLE
)
890 return NULL
; /* grid contents were invalid */
892 ret
= dup_game(state
);
893 ret
->grid
[sy
*w
+sx
] = GRID_HOLE
;
894 ret
->grid
[my
*w
+mx
] = GRID_HOLE
;
895 ret
->grid
[ty
*w
+tx
] = GRID_PEG
;
898 * Opinion varies on whether getting to a single peg counts as
899 * completing the game, or whether that peg has to be at a
900 * specific location (central in the classic cross game, for
901 * instance). For now we take the former, rather lax position.
903 if (!ret
->completed
) {
905 for (i
= 0; i
< w
*h
; i
++)
906 if (ret
->grid
[i
] == GRID_PEG
)
917 /* ----------------------------------------------------------------------
921 static void game_compute_size(game_params
*params
, int tilesize
,
924 /* Ick: fake up `ds->tilesize' for macro expansion purposes */
925 struct { int tilesize
; } ads
, *ds
= &ads
;
926 ads
.tilesize
= tilesize
;
928 *x
= TILESIZE
* params
->w
+ 2 * BORDER
;
929 *y
= TILESIZE
* params
->h
+ 2 * BORDER
;
932 static void game_set_size(game_drawstate
*ds
, game_params
*params
,
935 ds
->tilesize
= tilesize
;
937 assert(TILESIZE
> 0);
939 if (ds
->drag_background
)
940 blitter_free(ds
->drag_background
);
941 ds
->drag_background
= blitter_new(TILESIZE
, TILESIZE
);
944 static float *game_colours(frontend
*fe
, game_state
*state
, int *ncolours
)
946 float *ret
= snewn(3 * NCOLOURS
, float);
948 game_mkhighlight(fe
, ret
, COL_BACKGROUND
, COL_HIGHLIGHT
, COL_LOWLIGHT
);
950 ret
[COL_PEG
* 3 + 0] = 0.0F
;
951 ret
[COL_PEG
* 3 + 1] = 0.0F
;
952 ret
[COL_PEG
* 3 + 2] = 1.0F
;
954 *ncolours
= NCOLOURS
;
958 static game_drawstate
*game_new_drawstate(game_state
*state
)
960 int w
= state
->w
, h
= state
->h
;
961 struct game_drawstate
*ds
= snew(struct game_drawstate
);
963 ds
->tilesize
= 0; /* not decided yet */
965 /* We can't allocate the blitter rectangle for the drag background
966 * until we know what size to make it. */
967 ds
->drag_background
= NULL
;
968 ds
->dragging
= FALSE
;
972 ds
->grid
= snewn(w
*h
, unsigned char);
973 memset(ds
->grid
, 255, w
*h
);
981 static void game_free_drawstate(game_drawstate
*ds
)
983 if (ds
->drag_background
)
984 blitter_free(ds
->drag_background
);
989 static void draw_tile(frontend
*fe
, game_drawstate
*ds
,
990 int x
, int y
, int v
, int bgcolour
)
993 draw_rect(fe
, x
, y
, TILESIZE
, TILESIZE
, bgcolour
);
996 if (v
== GRID_HOLE
) {
997 draw_circle(fe
, x
+TILESIZE
/2, y
+TILESIZE
/2, TILESIZE
/4,
998 COL_LOWLIGHT
, COL_LOWLIGHT
);
999 } else if (v
== GRID_PEG
) {
1000 draw_circle(fe
, x
+TILESIZE
/2, y
+TILESIZE
/2, TILESIZE
/3,
1004 draw_update(fe
, x
, y
, TILESIZE
, TILESIZE
);
1007 static void game_redraw(frontend
*fe
, game_drawstate
*ds
, game_state
*oldstate
,
1008 game_state
*state
, int dir
, game_ui
*ui
,
1009 float animtime
, float flashtime
)
1011 int w
= state
->w
, h
= state
->h
;
1015 if (flashtime
> 0) {
1016 int frame
= (int)(flashtime
/ FLASH_FRAME
);
1017 bgcolour
= (frame
% 2 ? COL_LOWLIGHT
: COL_HIGHLIGHT
);
1019 bgcolour
= COL_BACKGROUND
;
1022 * Erase the sprite currently being dragged, if any.
1025 assert(ds
->drag_background
);
1026 blitter_load(fe
, ds
->drag_background
, ds
->dragx
, ds
->dragy
);
1027 draw_update(fe
, ds
->dragx
, ds
->dragy
, TILESIZE
, TILESIZE
);
1028 ds
->dragging
= FALSE
;
1033 TILESIZE
* state
->w
+ 2 * BORDER
,
1034 TILESIZE
* state
->h
+ 2 * BORDER
, COL_BACKGROUND
);
1037 * Draw relief marks around all the squares that aren't
1040 for (y
= 0; y
< h
; y
++)
1041 for (x
= 0; x
< w
; x
++)
1042 if (state
->grid
[y
*w
+x
] != GRID_OBST
) {
1044 * First pass: draw the full relief square.
1047 coords
[0] = COORD(x
+1) + HIGHLIGHT_WIDTH
- 1;
1048 coords
[1] = COORD(y
) - HIGHLIGHT_WIDTH
;
1049 coords
[2] = COORD(x
) - HIGHLIGHT_WIDTH
;
1050 coords
[3] = COORD(y
+1) + HIGHLIGHT_WIDTH
- 1;
1051 coords
[4] = COORD(x
) - HIGHLIGHT_WIDTH
;
1052 coords
[5] = COORD(y
) - HIGHLIGHT_WIDTH
;
1053 draw_polygon(fe
, coords
, 3, COL_HIGHLIGHT
, COL_HIGHLIGHT
);
1054 coords
[4] = COORD(x
+1) + HIGHLIGHT_WIDTH
- 1;
1055 coords
[5] = COORD(y
+1) + HIGHLIGHT_WIDTH
- 1;
1056 draw_polygon(fe
, coords
, 3, COL_LOWLIGHT
, COL_LOWLIGHT
);
1058 for (y
= 0; y
< h
; y
++)
1059 for (x
= 0; x
< w
; x
++)
1060 if (state
->grid
[y
*w
+x
] != GRID_OBST
) {
1062 * Second pass: draw everything but the two
1065 draw_rect(fe
, COORD(x
) - HIGHLIGHT_WIDTH
,
1066 COORD(y
) - HIGHLIGHT_WIDTH
,
1067 TILESIZE
+ HIGHLIGHT_WIDTH
,
1068 TILESIZE
+ HIGHLIGHT_WIDTH
, COL_HIGHLIGHT
);
1069 draw_rect(fe
, COORD(x
),
1071 TILESIZE
+ HIGHLIGHT_WIDTH
,
1072 TILESIZE
+ HIGHLIGHT_WIDTH
, COL_LOWLIGHT
);
1074 for (y
= 0; y
< h
; y
++)
1075 for (x
= 0; x
< w
; x
++)
1076 if (state
->grid
[y
*w
+x
] != GRID_OBST
) {
1078 * Third pass: draw a trapezium on each edge.
1081 int dx
, dy
, s
, sn
, c
;
1083 for (dx
= 0; dx
< 2; dx
++) {
1085 for (s
= 0; s
< 2; s
++) {
1087 c
= s ? COL_LOWLIGHT
: COL_HIGHLIGHT
;
1089 coords
[0] = COORD(x
) + (s
*dx
)*(TILESIZE
-1);
1090 coords
[1] = COORD(y
) + (s
*dy
)*(TILESIZE
-1);
1091 coords
[2] = COORD(x
) + (s
*dx
+dy
)*(TILESIZE
-1);
1092 coords
[3] = COORD(y
) + (s
*dy
+dx
)*(TILESIZE
-1);
1093 coords
[4] = coords
[2] - HIGHLIGHT_WIDTH
* (dy
-sn
*dx
);
1094 coords
[5] = coords
[3] - HIGHLIGHT_WIDTH
* (dx
-sn
*dy
);
1095 coords
[6] = coords
[0] + HIGHLIGHT_WIDTH
* (dy
+sn
*dx
);
1096 coords
[7] = coords
[1] + HIGHLIGHT_WIDTH
* (dx
+sn
*dy
);
1097 draw_polygon(fe
, coords
, 4, c
, c
);
1101 for (y
= 0; y
< h
; y
++)
1102 for (x
= 0; x
< w
; x
++)
1103 if (state
->grid
[y
*w
+x
] != GRID_OBST
) {
1105 * Second pass: draw everything but the two
1108 draw_rect(fe
, COORD(x
),
1111 TILESIZE
, COL_BACKGROUND
);
1116 draw_update(fe
, 0, 0,
1117 TILESIZE
* state
->w
+ 2 * BORDER
,
1118 TILESIZE
* state
->h
+ 2 * BORDER
);
1122 * Loop over the grid redrawing anything that looks as if it
1125 for (y
= 0; y
< h
; y
++)
1126 for (x
= 0; x
< w
; x
++) {
1129 v
= state
->grid
[y
*w
+x
];
1131 * Blank the source of a drag so it looks as if the
1132 * user picked the peg up physically.
1134 if (ui
->dragging
&& ui
->sx
== x
&& ui
->sy
== y
&& v
== GRID_PEG
)
1136 if (v
!= GRID_OBST
&&
1137 (bgcolour
!= ds
->bgcolour
|| /* always redraw when flashing */
1138 v
!= ds
->grid
[y
*w
+x
])) {
1139 draw_tile(fe
, ds
, COORD(x
), COORD(y
), v
, bgcolour
);
1144 * Draw the dragging sprite if any.
1147 ds
->dragging
= TRUE
;
1148 ds
->dragx
= ui
->dx
- TILESIZE
/2;
1149 ds
->dragy
= ui
->dy
- TILESIZE
/2;
1150 blitter_save(fe
, ds
->drag_background
, ds
->dragx
, ds
->dragy
);
1151 draw_tile(fe
, ds
, ds
->dragx
, ds
->dragy
, GRID_PEG
, -1);
1154 ds
->bgcolour
= bgcolour
;
1157 static float game_anim_length(game_state
*oldstate
, game_state
*newstate
,
1158 int dir
, game_ui
*ui
)
1163 static float game_flash_length(game_state
*oldstate
, game_state
*newstate
,
1164 int dir
, game_ui
*ui
)
1166 if (!oldstate
->completed
&& newstate
->completed
)
1167 return 2 * FLASH_FRAME
;
1172 static int game_wants_statusbar(void)
1177 static int game_timing_state(game_state
*state
)
1183 #define thegame pegs
1186 const struct game thegame
= {
1187 "Pegs", "games.pegs",
1194 TRUE
, game_configure
, custom_params
,
1202 TRUE
, game_text_format
,
1210 PREFERRED_TILE_SIZE
, game_compute_size
, game_set_size
,
1213 game_free_drawstate
,
1217 game_wants_statusbar
,
1218 FALSE
, game_timing_state
,
1219 0, /* mouse_priorities */