Katyusha's blog

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <stdbool.h>
5
#include <assert.h>
6
#include <testkit.h>
7
#include "labyrinth.h"
8
#include <getopt.h>
9

10
int main(int argc, char *argv[]) {
11
    // TODO: Implement this function
12
    optind = 0;
13
    opterr = 0;
14
    optopt = 0;
15
    optarg = NULL;
16

17
    char *args[argc + 1];
18
    for (int i = 0; i < argc; i++) args[i] = argv[i];
19
    args[argc] = NULL;
20

21
    static struct option long_options[] = {
22
        {"map", required_argument, 0, 'm'},
23
        {"player", required_argument, 0, 'p'},
24
        {"version", no_argument, 0, 'v'},
25
        {"move", required_argument, 0, 'M'},
26
        {0, 0, 0, 0}
27
    };
28

29
    int opt;
30
    char *mp_path = NULL, *dir = NULL, *player = NULL;
31
    bool vers = 0;
32
    while ((opt = getopt_long(argc, args, "", long_options, NULL)) != -1) {
33
        switch (opt) {
34
            case 'm':
35
                if (vers) return 1;
36
                mp_path = optarg;
37
                break;
38
            case 'p':
39
                if (vers) return 1;
40
                player = optarg;
41
                break;
42
            case 'v':
43
                vers = 1;
44
                if (mp_path != NULL || player != NULL || dir != NULL) return 1;
45
                break;
46
            case 'M':
47
                if (vers) return 1;
48
                dir = optarg;
49
                break;
50
            case '?':
51
                return 1;
52
            case ':':
53
                return 1;
54
        }
55
    }
56
    if (optind < argc && strcmp(args[optind], "./labyrinth") == 0) optind++;
57
    if (optind != argc) return 1;
58

59
    if (vers) {
60
        printVersion();
61
        return 0;
62
    }
63

64
    if (mp_path == NULL || player == NULL) return 1;
65
    if (strlen(player) >= 2 || !isValidPlayer(player[0])) return 1;
66

67
    Labyrinth mp = {0};
68
    if (!loadMap(&mp, mp_path)) return 1;
69
    if (!isConnected(&mp)) return 1;
70
    if (dir == NULL) {
71
        printMap(&mp);
72
        return 0;
73
    }
74
    if (!movePlayer(&mp, player[0], dir)) return 1;
75
    if (!saveMap(&mp, mp_path)) return 1;
76
    return 0;
77
}
78

79
void printVersion() {
80
    printf("This is Labyrinth Game\n");
81
}
82

83
void printUsage() {
84
    printf("Usage:\n");
85
    printf("  labyrinth --map map.txt --player id\n");
86
    printf("  labyrinth -m map.txt -p id\n");
87
    printf("  labyrinth --map map.txt --player id --move direction\n");
88
    printf("  labyrinth --version\n");
89
}
90

91
bool isValidPlayer(char playerId) {
92
    // TODO: Implement this function
93
    if ('0' <= playerId && playerId <= '9') return true;
94
    return false;
95
}
96

97
bool loadMap(Labyrinth *labyrinth, const char *filename) {
98
    // TODO: Implement this function
99
    if (labyrinth == NULL || filename == NULL) return false;
100
    FILE *fp = fopen(filename, "r");
101
    if (fp == NULL) return false;
102
    static char buf[1024];
103
    int expected_cols = -1;
104
    while (fgets(buf, sizeof(buf), fp) != NULL) {
105
        if (labyrinth->rows == MAX_ROWS) {
106
            fclose(fp);
107
            return false;
108
        }
109

110
        size_t len = strcspn(buf, "\n");
111
        if (buf[len] == '\n') buf[len] = '\0';
112
        if ((int)len > MAX_COLS) {
113
            fclose(fp);
114
            return false;
115
        }
116

117
        if (expected_cols == -1) expected_cols = (int)len;
118
        if ((int)len != expected_cols) {
119
            fclose(fp);
120
            return false;
121
        }
122

123
        labyrinth->cols = (int)len;
124
        memcpy(labyrinth->map[labyrinth->rows], buf, len + 1);
125
        labyrinth->rows++;
126
    }
127
    fclose(fp);
128
    return true;
129
}
130

131
Position findPlayer(Labyrinth *labyrinth, char playerId) {
132
    // TODO: Implement this function
133
    Position pos = {-1, -1};
134
    for (int i = 0; i < labyrinth->rows; i++) {
135
        for (int j = 0; j < labyrinth->cols; j++) {
136
            if (labyrinth->map[i][j] == playerId) {
137
                pos.row = i;
138
                pos.col = j;
139
            }
140
        }
141
    }
142
    return pos;
143
}
144

145
Position findFirstEmptySpace(Labyrinth *labyrinth) {
146
    // TODO: Implement this function
147
    for (int i = 0; i < labyrinth->rows; i++) {
148
        for (int j = 0; j < labyrinth->cols; j++) {
149
            if (labyrinth->map[i][j] == '.') {
150
                Position pos = {i, j};
151
                return pos;
152
            }
153
        }
154
    }
155
    Position pos = {-1, -1};
156
    return pos;
157
}
158

159
bool isEmptySpace(Labyrinth *labyrinth, int row, int col) {
160
    // TODO: Implement this function
161
    if (labyrinth == NULL) return false;
162
    if (row < 0 || row >= labyrinth->rows || col < 0 || col >= labyrinth->cols) {
163
        return false;
164
    }
165
    return (labyrinth->map[row][col] == '.');
166
}
167

168
const Position dir_table[] = {
169
        {-1, 0}, {1, 0}, {0, -1}, {0, 1}
170
};
171

172
bool movePlayer(Labyrinth *labyrinth, char playerId, const char *direction) {
173
    // TODO: Implement this function
174

175
    int dir_opt = -1;
176
    if (strcmp(direction, "up") == 0) dir_opt = 0;
177
    else if (strcmp(direction, "down") == 0) dir_opt = 1;
178
    else if (strcmp(direction, "left") == 0) dir_opt = 2;
179
    else if (strcmp(direction, "right") == 0) dir_opt = 3;
180
    else return false;
181

182
    Position dir = dir_table[dir_opt], pos = findPlayer(labyrinth, playerId);
183
    if (pos.row == -1) pos = findFirstEmptySpace(labyrinth);
184
    if (pos.row == -1) return false;
185
    Position _pos;
186
    _pos.row = pos.row + dir.row; _pos.col = pos.col + dir.col;
187
    if (!isEmptySpace(labyrinth, _pos.row, _pos.col)) return false;
188
    labyrinth->map[pos.row][pos.col] = '.';
189
    labyrinth->map[_pos.row][_pos.col] = playerId;
190
    return true;
191
}
192

193
bool saveMap(Labyrinth *labyrinth, const char *filename) {
194
    // TODO: Implement this function
195
    FILE *fp = fopen(filename, "w");
196
    if (fp == NULL) return false;
197
    for (int i = 0; i < labyrinth->rows; i++) {
198
        if (fputs(labyrinth->map[i], fp) == EOF) {
199
            fclose(fp);
200
            return false;
201
        }
202
        if (fputc('\n', fp) == EOF) {
203
            fclose(fp);
204
            return false;
205
        }
206
    }
207
    fclose(fp);
208
    return true;
209
}
210

211
bool printMap(Labyrinth *labyrinth) {
212
    // TODO: Implement this function
213
    for (int i = 0; i < labyrinth->rows; i++) {
214
        for (int j = 0; j < labyrinth->cols; j++) {
215
            putchar(labyrinth->map[i][j]);
216
        }
217
        putchar('\n');
218
    }
219
    return 1;
220
}
221

222
// Check if all empty spaces are connected using DFS
223
void dfs(Labyrinth *labyrinth, int row, int col, bool visited[MAX_ROWS][MAX_COLS]) {
224
    // TODO: Implement this function
225
    if (visited[row][col]) return;
226
    visited[row][col] = true;
227
    for (int i = 0; i < 4; i++) {
228
        int _row = row + dir_table[i].row, _col = col + dir_table[i].col;
229
        if (isEmptySpace(labyrinth, _row, _col)) dfs(labyrinth, _row, _col, visited);
230
    }
231
}
232

233
bool isConnected(Labyrinth *labyrinth) {
234
    // TODO: Implement this function
235
    static bool visited[MAX_ROWS][MAX_COLS];
236
    memset(visited, 0, sizeof visited);
237
    Position empty_pos = findFirstEmptySpace(labyrinth);
238
    if (empty_pos.row == -1) return true;
239
    dfs(labyrinth, empty_pos.row, empty_pos.col, visited);
240
    for (int i = 0; i < labyrinth->rows; i++) {
241
        for (int j = 0; j < labyrinth->cols; j++) {
242
            if (labyrinth->map[i][j] == '.' && !visited[i][j]) return false;
243
        }
244
    }
245
    return true;
246
}