← Back to branch summary

~kroq-gar78/ubuntu/precise/ace-of-penguins/fix-978446

« back to all changes in this revision

Viewing changes to .pc/11-include-imagelib.patch/games/spider.c

  • Committer: Bazaar Package Importer
  • Author(s): Jari Aalto
  • Date: 2010-10-31 19:13:50 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20101031191350-54kqk274tisqp0fa
Tags: 1.3-2
http://bugs.debian.org/601984
http://bugs.debian.org/601986
* debian/menu
  - Add ace-spider. Contribution Thanks to Artur Rona
    <ari-tczew@ubuntu.com> (Closes: #601984).
* debian/ace-of-penguins.6.orig.man
  - Delete. Obsoleted by POD format.
* debian/ace-of-penguins.6.pod
  - Add ace-spider. Contribution Thanks to Artur Rona
    <ari-tczew@ubuntu.com>.
* debian/patches
  - (30): New. For the spider game, Fix implicit pointer conversion.
    Patch thanks to Julien Lavergne <gilir@ubuntu.com>, forwarded by
    Artur Rona <ari-tczew@ubuntu.com> (Closes: Bug#601986).

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/11-include-imagelib.patch/games/spider.c
1
 
/* The Ace of Penguins - freecell.c
2
 
   Copyright (C) 1998, 2001 DJ Delorie
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, or (at your option)
7
 
   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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
17
 
 
18
 
#include <stdlib.h>
19
 
#include <stdio.h>
20
 
#include <string.h>
21
 
#include <time.h>
22
 
 
23
 
#include "cards.h"
24
 
//#include "imagelib.h"
25
 
 
26
 
#define W CARD_WIDTH
27
 
#define H CARD_HEIGHT
28
 
#define M CARD_MARGIN
29
 
#define F CARD_FAN_DOWN
30
 
 
31
 
static Picture *splash, *youwin, *youlose, *arrow, *no_arrow;
32
 
 
33
 
static Stack *deck;
34
 
static Stack *outcells[8];
35
 
static Stack *maincells[10];
36
 
 
37
 
static int suit_mask = 0; // 0 = one suit, 2 = two suit, 3 = four suit 
38
 
 
39
 
static void auto_move();
40
 
static void check_for_end_of_game();
41
 
static void set_arrows();
42
 
static void clear_arrows();
43
 
static int ax, adx, ay, ady;
44
 
 
45
 
static void
46
 
start_again()
47
 
{
48
 
  int i, d, s, v;
49
 
 
50
 
  clear_arrows();
51
 
 
52
 
  for (i=0; i<8; i++)
53
 
    stack_flip_stack(outcells[i], deck);
54
 
  for (i=0; i<10; i++)
55
 
    stack_flip_stack(maincells[i], deck);
56
 
 
57
 
  while(stack_take_card(deck) != -1);
58
 
  for (d=0; d<2; d++)
59
 
    for (s=0; s<4; s++)
60
 
      for (v=ACE; v<=KING; v++)
61
 
        stack_add_card(deck, MAKE_CARD(s & suit_mask, v, FACEDOWN));
62
 
 
63
 
  stack_shuffle(deck);
64
 
  stack_shuffle(deck);
65
 
  stack_shuffle(deck);
66
 
  for (i=0; i<40; i++)
67
 
    stack_move_cards(deck, stack_count_cards(deck)-1, maincells[i%10]);
68
 
  for (i=0; i<4; i++)
69
 
    stack_move_cards(deck, stack_count_cards(deck)-1, maincells[i*3]);
70
 
  for (i=0; i<10; i++)
71
 
    stack_flip_card(deck, maincells[i]);
72
 
 
73
 
  stack_undo_reset();
74
 
 
75
 
  set_arrows();
76
 
}
77
 
 
78
 
static void
79
 
init()
80
 
{
81
 
  int s;
82
 
  Picture *empty;
83
 
 
84
 
  stack_load_standard_deck();
85
 
  empty = get_picture("empty");
86
 
 
87
 
  set_centered_pic(splash);
88
 
 
89
 
  for (s=0; s<8; s++)  {
90
 
    outcells[s] = stack_create((2+s)*(W+M), M);
91
 
    stack_set_empty_picture(outcells[s], empty);
92
 
  }
93
 
 
94
 
  for (s=0; s<10; s++)  {
95
 
    maincells[s] = stack_create(M+s*(M+W), H+M);
96
 
    stack_set_offset(maincells[s], STACK_OFFSET_DOWN);
97
 
  }
98
 
 
99
 
  deck = stack_create(M, M);
100
 
 
101
 
  start_again();
102
 
}
103
 
 
104
 
static void
105
 
resize(int w, int h)
106
 
{
107
 
  int margin, offset, cw, ch, s, fd, fr, tfd, tfr;
108
 
 
109
 
  Picture *empty;
110
 
 
111
 
  stack_set_card_size (w/11, w/11*4/3);
112
 
  stack_get_card_size (&cw, &ch);
113
 
 
114
 
  empty = (Picture *)get_image("empty", cw, ch, 0);
115
 
 
116
 
  margin = (w - 10*cw) / 11;
117
 
  offset = (w - margin*11 - cw*10) / 2 + margin;
118
 
 
119
 
  for (s=0; s<8; s++) {
120
 
    stack_move(outcells[s], (s+2)*(cw+margin)+offset, margin);
121
 
    stack_set_empty_picture(outcells[s], empty);
122
 
  }
123
 
  for (s=0; s<10; s++)
124
 
    stack_move(maincells[s], offset + s*(cw+margin), ch + (offset<0?0:offset));
125
 
  stack_move(deck, margin+offset, margin);
126
 
 
127
 
  stack_get_fans(&fd, &fr, &tfd, &tfr);
128
 
 
129
 
  ax = offset + cw/2;
130
 
  adx = margin + cw;
131
 
  ay = offset + ch*2 + 2;
132
 
  ady = fd;
133
 
 
134
 
  set_arrows();
135
 
}
136
 
 
137
 
 
138
 
static int no_arrows = 0;
139
 
static int supress_arrows = 0;
140
 
static int arrowsx[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
141
 
static int arrowsy[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
142
 
 
143
 
static void
144
 
set_arrow(int column, int on)
145
 
{
146
 
  int x = ax + adx*column;
147
 
  if (supress_arrows || no_arrows) return;
148
 
  if (arrowsy[column])
149
 
    put_picture(no_arrow, arrowsx[column]-no_arrow->w/2, arrowsy[column],
150
 
                0, 0, no_arrow->w, no_arrow->h);
151
 
  
152
 
  if (on)
153
 
  {
154
 
    arrowsx[column] = x;
155
 
    arrowsy[column] = ay+ady*(stack_count_cards(maincells[column])-1);
156
 
    put_picture(arrow, arrowsx[column]-arrow->w/2, arrowsy[column],
157
 
                0, 0, arrow->w, arrow->h);
158
 
  }
159
 
  else
160
 
    arrowsy[column] = 0;
161
 
}
162
 
 
163
 
static void
164
 
redraw_arrows()
165
 
{
166
 
  int i;
167
 
  if(no_arrows) return;
168
 
  for (i=0; i<10; i++)
169
 
  {
170
 
    if (arrowsy[i])
171
 
      put_picture(arrow, arrowsx[i]-arrow->w/2, arrowsy[i],
172
 
                  0, 0, arrow->w, arrow->h);
173
 
  }
174
 
}
175
 
 
176
 
static void
177
 
clear_arrows()
178
 
{
179
 
  int i;
180
 
  for (i=0; i<10; i++)
181
 
    set_arrow(i, 0);
182
 
}
183
 
 
184
 
static void
185
 
set_arrows()
186
 
{
187
 
  int i, j, k, src_next;
188
 
  for (i=0; i<10; i++)
189
 
  {
190
 
    Stack *dest = maincells[i]; 
191
 
    int dest_count = stack_count_cards(dest);
192
 
    int dest_top = stack_get_card(dest, dest_count-1);
193
 
    int n = 0;
194
 
    int add = 0;
195
 
 
196
 
    set_arrow(i, 0);
197
 
    if (dest_count == 0) { set_arrow(i,1); add=1; };
198
 
 
199
 
    for (j=0; j<10 && add==0; j++) {
200
 
      Stack *src = maincells[j];
201
 
      int src_count = stack_count_cards(src);
202
 
      int src_top;
203
 
      int src_next;
204
 
      n = src_count;
205
 
      while (n--) {
206
 
        if ((i == j) || (src_count == 0)) n = 0;
207
 
        else {
208
 
          src_top = stack_get_card(src, n);
209
 
          src_next = stack_get_card(src, n-1);
210
 
          if (VALUE(src_top) == VALUE(dest_top)-1) {
211
 
            int better = 0;
212
 
            //possible let's see if better
213
 
            if(n == 0) better = 1;
214
 
            if (!better) {
215
 
              if (VALUE(src_top) != VALUE(src_next)-1) better = 1;
216
 
            }
217
 
            if (!better) {
218
 
              if (SUIT(src_top) != SUIT(src_next)) better = 1;
219
 
            }
220
 
            if (better) add = 1;
221
 
          }
222
 
          if (n == 0 || VALUE(src_top) != VALUE(src_next)-1 ||
223
 
              SUIT(src_top) != SUIT(src_next) ||
224
 
              FACEDOWNP(src_next) == FACEDOWN ) n = 0;
225
 
        }
226
 
      }
227
 
    }
228
 
    if (add) set_arrow(i,1);
229
 
  }
230
 
}
231
 
 
232
 
 
233
 
static void
234
 
redraw()
235
 
{
236
 
  stack_redraw();
237
 
  redraw_arrows();
238
 
}
239
 
 
240
 
extern char spider_help[];
241
 
 
242
 
static void
243
 
key(int k, int x, int y)
244
 
{
245
 
  Picture *p = get_centered_pic();
246
 
 
247
 
  set_centered_pic(0);
248
 
  if (p == splash) return;
249
 
 
250
 
  switch(k) {
251
 
  case 3:  case 27: case 'q': case 'Q':
252
 
    exit(0);
253
 
    break;
254
 
  case KEY_F(1): case 'h': case 'H':
255
 
    help("bj.html", spider_help);
256
 
    break;
257
 
  case KEY_F(2):  case 'r':
258
 
    start_again();
259
 
    break;
260
 
  case 8:  case 127:  case KEY_DELETE:
261
 
    set_centered_pic(0);
262
 
    stack_undo();
263
 
    set_arrows();
264
 
    break;
265
 
  case '1': 
266
 
    suit_mask = 0;
267
 
    start_again();
268
 
    break;
269
 
  case '2': 
270
 
    suit_mask = 2;
271
 
    start_again();
272
 
    break;
273
 
  case '4':
274
 
    suit_mask = 3;
275
 
    start_again();
276
 
    break;
277
 
  case 'a':
278
 
    if (no_arrows) {
279
 
      no_arrows = 0;
280
 
      set_arrows();
281
 
    } else {
282
 
      clear_arrows();
283
 
      no_arrows = 1;
284
 
    }
285
 
    break;
286
 
  }
287
 
}
288
 
 
289
 
static Stack *src_stack = 0;
290
 
static int src_n = 0;
291
 
 
292
 
static Stack *dest_stack;
293
 
static int last_n=-1;
294
 
 
295
 
static int
296
 
n_droppable_s(Stack *dest_stack)
297
 
{
298
 
  int src_top, dest_top, src_count, dest_count, i, src_next;
299
 
 
300
 
  src_count = stack_count_cards(src_stack);
301
 
  dest_count = stack_count_cards(dest_stack);
302
 
  dest_top = stack_get_card(dest_stack, dest_count-1);
303
 
 
304
 
  for (i=0; i<10; i++) {
305
 
    if (dest_stack == maincells[i]) {
306
 
      int n = src_count;
307
 
 
308
 
      while (n--)
309
 
      {
310
 
        src_top = stack_get_card(src_stack, n);
311
 
        if ((VALUE(src_top) == VALUE(dest_top)-1)
312
 
            || (n == src_n && dest_count == 0)) return n;
313
 
 
314
 
        src_next = stack_get_card(src_stack, n-1);
315
 
        if (n == 0 || VALUE(src_top) != VALUE(src_next)-1 ||
316
 
            SUIT(src_top) != SUIT(src_next) ||
317
 
            FACEDOWNP(src_next) == FACEDOWN ) {
318
 
          if ((dest_count == 0) || (dest_stack == src_stack))return n;
319
 
          else return src_count;
320
 
        }
321
 
      }
322
 
      return src_count;
323
 
    }
324
 
  }
325
 
  return src_count;
326
 
}
327
 
 
328
 
static int
329
 
n_droppable(int x, int y)
330
 
{
331
 
  if (!src_stack)
332
 
    return -1;
333
 
  if (!stack_drag_find(x, y, &dest_stack))
334
 
  {
335
 
    dest_stack = src_stack;
336
 
    return last_n != -1 ? last_n : src_n;
337
 
  }
338
 
  return n_droppable_s(dest_stack);
339
 
}
340
 
 
341
 
 
342
 
static void
343
 
auto_move()
344
 
{
345
 
  int i, c, s, v, f, n;
346
 
 
347
 
  for (i=0; i<10; i++) {
348
 
    n = stack_count_cards(maincells[i]);
349
 
    c = stack_get_card(maincells[i],n-1);
350
 
    if (FACEDOWNP(c)) stack_flip_card(maincells[i], maincells[i]);
351
 
    if ((VALUE(c) == ACE) && n >= 13) {
352
 
      s = SUIT(c);
353
 
      v = 2;
354
 
      f = FACEUP;
355
 
      n -= 2;
356
 
      while((n>=0)&&(stack_get_card(maincells[i],n) == MAKE_CARD(s,v,f))) {
357
 
        n--; v++;
358
 
      }
359
 
      if (v == 14) {
360
 
        //Full suit to move, first find empty outcell
361
 
        c =0;
362
 
        while(stack_count_cards(outcells[c++]) != 0);
363
 
        c--;
364
 
        for(v=ACE; v<=KING; v++) stack_animate(maincells[i],outcells[c]);
365
 
        i--; // to flip any cards in this column
366
 
      }
367
 
    }
368
 
  }
369
 
}
370
 
 
371
 
static void
372
 
check_for_end_of_game()
373
 
{
374
 
  auto_move();
375
 
  if (stack_count_cards(outcells[7]) == 13) set_centered_pic(youwin);
376
 
  if (stack_count_cards(deck) == 0) {
377
 
    int i;
378
 
    int end = 1;
379
 
    set_arrows();
380
 
    for (i=0; i<10; i++) {
381
 
      if (arrowsy[i] != 0) end = 0;
382
 
    }
383
 
    //    if (end) set_centered_pic(youlose);
384
 
  }
385
 
}
386
 
 
387
 
static void
388
 
click(int x, int y, int b)
389
 
{
390
 
  int c, f;
391
 
  Picture *cp = get_centered_pic();
392
 
 
393
 
  if (cp == splash){
394
 
    set_centered_pic(0);
395
 
    return;
396
 
  }
397
 
 
398
 
  if (cp == youwin) {
399
 
    set_centered_pic(0);
400
 
    start_again();
401
 
    return;
402
 
  }
403
 
 
404
 
  if (cp == youlose) {
405
 
    set_centered_pic(0);
406
 
    return;
407
 
  }
408
 
 
409
 
  src_stack = 0;
410
 
  f = stack_find(x, y, &src_stack, &src_n);
411
 
  if (!f) return;
412
 
 
413
 
  if (b > 1)
414
 
  {
415
 
    stack_peek_card(src_stack, src_n, 1);
416
 
    return;
417
 
  }
418
 
  last_n = -1;
419
 
 
420
 
  for (c=0; c<8; c++)
421
 
    if (src_stack == outcells[c])
422
 
      return;
423
 
 
424
 
  if (src_stack == deck) {
425
 
    int empty_stack=0;
426
 
    for (c=0; c<10; c++) {
427
 
      if (stack_count_cards(maincells[c]) == 0) empty_stack = 1;
428
 
    }
429
 
    clear_arrows();
430
 
    if (empty_stack == 0) {
431
 
      for (c=0; c<10; c++) {
432
 
        stack_flip_card(deck, maincells[c]);
433
 
      }
434
 
    }
435
 
  }
436
 
 
437
 
  if (stack_count_cards(src_stack) > 0)
438
 
    stack_begin_drag(src_stack, src_n, x, y);
439
 
  else
440
 
    src_stack = 0;
441
 
}
442
 
 
443
 
static void
444
 
drag(int x, int y, int b)
445
 
{
446
 
  if (b > 1) return;
447
 
  last_n = n_droppable(x, y);
448
 
  stack_continue_drag(last_n, x, y);
449
 
}
450
 
 
451
 
static void
452
 
drop(int x, int y, int b)
453
 
{
454
 
  last_n = n_droppable(x, y); /* also sets dest_stack */
455
 
 
456
 
  if (b > 1)
457
 
  {
458
 
    if (src_stack)
459
 
      stack_peek_card(src_stack, src_n, 0);
460
 
    return;
461
 
  }
462
 
  clear_arrows();
463
 
  stack_drop(dest_stack, last_n);
464
 
  check_for_end_of_game();
465
 
  set_arrows();
466
 
}
467
 
 
468
 
static FunctionMapping fmap[] = {
469
 
  { "click", (void *)click },
470
 
  { "drag", (void *)drag },
471
 
  { "drop", (void *)drop },
472
 
  { "init", (void *)init },
473
 
  { "key", (void *)key },
474
 
  { "redraw", (void *)redraw },
475
 
  { "resize", (void *)resize },
476
 
  { 0, 0 }
477
 
};
478
 
 
479
 
int
480
 
main(int argc, char **argv)
481
 
{
482
 
  register_imagelib(appimglib_imagelib);
483
 
  init_ace(argc, argv, fmap);
484
 
  splash = get_picture("spider");
485
 
  youwin = get_picture("youwin");
486
 
  youlose = get_picture("youlose");
487
 
  arrow = get_picture("golf-arrow");
488
 
  no_arrow = get_picture("golf-noarrow");
489
 
  if (table_width == 0 || table_height == 0)
490
 
    {
491
 
      table_width = 10*(W+M) + M;
492
 
      table_height = 480;
493
 
    }
494
 
  init_table(table_width, table_height);
495
 
  table_loop();
496
 
  return 0;
497
 
}