← Back to branch summary

~ubuntu-branches/ubuntu/natty/freecell-solver/natty

« back to all changes in this revision

Viewing changes to test_multi.c

  • Committer: Bazaar Package Importer
  • Author(s): RISKO Gergely
  • Date: 2005-03-30 20:12:47 UTC
  • mfrom: (1.1.1 upstream) (2.1.1 warty)
  • Revision ID: james.westby@ubuntu.com-20050330201247-8qdt6jhg7kxr3gjy
Tags: 2.8.10-1
* New upstream release
* fixed override disparity

Show diffs side-by-side

added added

removed removed

Lines of Context:
test_multi.c
1
 
#include <stdio.h>
2
 
#include <stdlib.h>
3
 
#include <string.h>
4
 
 
5
 
#include "fcs_user.h"
6
 
 
7
 
#ifdef DMALLOC
8
 
#include "dmalloc.h"
9
 
#endif
10
 
 
11
 
 
12
 
struct microsoft_rand_struct
13
 
{
14
 
    long seed;
15
 
};
16
 
 
17
 
typedef struct microsoft_rand_struct microsoft_rand_t;
18
 
 
19
 
microsoft_rand_t * microsoft_rand_alloc(unsigned int seed)
20
 
{
21
 
    microsoft_rand_t * ret;
22
 
 
23
 
    ret = malloc(sizeof(microsoft_rand_t));
24
 
    ret->seed = (long)seed;
25
 
 
26
 
    return ret;
27
 
}
28
 
 
29
 
void microsoft_rand_free(microsoft_rand_t * rand)
30
 
{
31
 
    free(rand);
32
 
}
33
 
 
34
 
int microsoft_rand_rand(microsoft_rand_t * rand)
35
 
{
36
 
    rand->seed = (rand->seed * 214013 + 2531011);
37
 
    return (rand->seed >> 16) & 0x7fff;
38
 
}
39
 
 
40
 
typedef int CARD;
41
 
 
42
 
#define     BLACK           0               /* COLOUR(card) */
43
 
#define     RED             1
44
 
 
45
 
#define     ACE             0               /*  VALUE(card) */
46
 
#define     DEUCE           1
47
 
 
48
 
#define     CLUB            0               /*  SUIT(card)  */
49
 
#define     DIAMOND         1
50
 
#define     HEART           2
51
 
#define     SPADE           3
52
 
 
53
 
#define     SUIT(card)      ((card) % 4)
54
 
#define     VALUE(card)     ((card) / 4)
55
 
#define     COLOUR(card)    (SUIT(card) == DIAMOND || SUIT(card) == HEART)
56
 
 
57
 
#define     MAXPOS         21
58
 
#define     MAXCOL          9    /* includes top row as column 0 */
59
 
 
60
 
char * card_to_string(char * s, CARD card, int not_append_ws)
61
 
{
62
 
    int suit = SUIT(card);
63
 
    int v = VALUE(card)+1;
64
 
 
65
 
    if (v == 1)
66
 
    {
67
 
        strcpy(s, "A");
68
 
    }
69
 
    else if (v <= 10)
70
 
    {
71
 
        sprintf(s, "%i", v);
72
 
    }
73
 
    else
74
 
    {
75
 
        strcpy(s, (v == 11)?"J":((v == 12)?"Q":"K"));
76
 
    }
77
 
 
78
 
    switch (suit)
79
 
    {
80
 
        case CLUB:
81
 
            strcat(s, "C");
82
 
            break;
83
 
        case DIAMOND:
84
 
            strcat(s, "D");
85
 
            break;
86
 
        case HEART:
87
 
            strcat(s, "H");
88
 
            break;
89
 
        case SPADE:
90
 
            strcat(s, "S");
91
 
            break;
92
 
    }
93
 
    if (!not_append_ws)
94
 
    {
95
 
        strcat(s, " ");
96
 
    }
97
 
 
98
 
 
99
 
    return s;
100
 
}
101
 
 
102
 
char * get_board(int gamenumber)
103
 
{
104
 
 
105
 
    CARD    card[MAXCOL][MAXPOS];    /* current layout of cards, CARDs are ints */
106
 
 
107
 
    int  i, j;                /*  generic counters */
108
 
    int  wLeft = 52;          /*  cards left to be chosen in shuffle */
109
 
    CARD deck[52];            /* deck of 52 unique cards */
110
 
    char * ret;
111
 
 
112
 
    microsoft_rand_t * randomizer;
113
 
 
114
 
 
115
 
    ret = malloc(1024);
116
 
    ret[0] = '\0';
117
 
 
118
 
    /* shuffle cards */
119
 
 
120
 
    for (i = 0; i < 52; i++)      /* put unique card in each deck loc. */
121
 
    {
122
 
        deck[i] = i;
123
 
    }
124
 
 
125
 
    randomizer = microsoft_rand_alloc(gamenumber);            /* gamenumber is seed for rand() */
126
 
    for (i = 0; i < 52; i++)
127
 
    {
128
 
        j = microsoft_rand_rand(randomizer) % wLeft;
129
 
        card[(i%8)+1][i/8] = deck[j];
130
 
        deck[j] = deck[--wLeft];
131
 
    }
132
 
 
133
 
    microsoft_rand_free(randomizer);
134
 
 
135
 
 
136
 
    {
137
 
        int stack;
138
 
        int c;
139
 
 
140
 
        char card_string[10];
141
 
 
142
 
        for(stack=1 ; stack<9 ; stack++ )
143
 
        {
144
 
            for(c=0 ; c < (6+(stack<5)) ; c++)
145
 
            {
146
 
                sprintf(ret+strlen(ret), "%s",
147
 
                    card_to_string(
148
 
                        card_string,
149
 
                        card[stack][c],
150
 
                        (c == (6+(stack<5)))
151
 
                    )
152
 
                );
153
 
            }
154
 
            sprintf(ret+strlen(ret), "%s", "\n");
155
 
        }
156
 
    }
157
 
 
158
 
    return ret;
159
 
}
160
 
 
161
 
#define LIMIT_STEP 500
162
 
#define LIMIT_MAX 50000
163
 
 
164
 
int main(int argc, char * argv[])
165
 
{
166
 
    void * user;
167
 
    /* char buffer[2048]; */
168
 
    int ret;
169
 
#if 0
170
 
    fcs_move_t move;
171
 
#endif
172
 
    int board_num;
173
 
    char * buffer;
174
 
    int limit;
175
 
    int start_board, end_board, stop_at;
176
 
    char line[80];
177
 
 
178
 
 
179
 
    start_board = atoi(argv[1]);
180
 
    end_board = atoi(argv[2]);
181
 
    stop_at = atoi(argv[3]);
182
 
 
183
 
    /* for(board_num=1;board_num<100000;board_num++) */
184
 
    for(board_num=start_board;board_num<=end_board;board_num++)
185
 
    {
186
 
        user = freecell_solver_user_alloc();
187
 
        freecell_solver_user_set_solving_method(
188
 
            user,
189
 
            FCS_METHOD_A_STAR
190
 
            );
191
 
 
192
 
#if 0
193
 
        freecell_solver_user_set_solution_optimization(
194
 
            user,
195
 
            1
196
 
            );
197
 
#endif
198
 
 
199
 
        buffer = get_board(board_num);
200
 
 
201
 
        limit = LIMIT_STEP;
202
 
 
203
 
        freecell_solver_user_limit_iterations(user, limit);
204
 
 
205
 
        ret = freecell_solver_user_solve_board(user, buffer);
206
 
 
207
 
        printf("%i, %i\n", board_num, limit);
208
 
        fflush(stdout);
209
 
 
210
 
        free(buffer);
211
 
 
212
 
        while ((ret == FCS_STATE_SUSPEND_PROCESS) && (limit < LIMIT_MAX))
213
 
        {
214
 
            limit += LIMIT_STEP;
215
 
            freecell_solver_user_limit_iterations(user, limit);
216
 
            ret = freecell_solver_user_resume_solution(user);
217
 
            printf("%i, %i\n", board_num, limit);
218
 
            fflush(stdout);
219
 
 
220
 
        }
221
 
 
222
 
#if 0
223
 
        if (ret == FCS_STATE_WAS_SOLVED)
224
 
        {
225
 
            while (freecell_solver_user_get_next_move(user, &move) == 0)
226
 
            {
227
 
                printf("%i\n", (int)fcs_move_get_type(move)); printf("%i\n",
228
 
                (int)fcs_move_get_num_cards_in_seq(move));
229
 
            }
230
 
        }
231
 
#endif
232
 
        printf("\n");
233
 
        fflush(stdout);
234
 
 
235
 
        freecell_solver_user_free(user);
236
 
 
237
 
        if (board_num % stop_at == 0)
238
 
        {
239
 
            printf ("Press Return to continue:\n");
240
 
            fgets(line, sizeof(line), stdin);
241
 
        }
242
 
    }
243
 
 
244
 
    return 0;
245
 
}