Mercurial > molko

comparison tests/test-map.c @ 215:64f24b482722

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rpg: implement tilesets separately, closes #2515 @4h While here: - Add CMake macros, - Update maps, - Add more tests.
author David Demelier <markand@malikania.fr>
date Tue, 17 Nov 2020 20:08:42 +0100
parents adcbb7ccfdee
children 76afe639fd72
comparison
equal deleted inserted replaced
214:82fd79d5019e 215:64f24b482722
27 27
28 #include <rpg/map-file.h> 28 #include <rpg/map-file.h>
29 #include <rpg/map.h> 29 #include <rpg/map.h>
30 30
31 GREATEST_TEST 31 GREATEST_TEST
32 test_sample(void) 32 test_basics_sample(void)
33 { 33 {
34 struct map_file loader = {0}; 34 struct map_file loader = {0};
35 struct map map = {0}; 35 struct map map = {0};
36 36
37 GREATEST_ASSERT(map_file_open(&loader, DIRECTORY "sample-map.map", &map)); 37 GREATEST_ASSERT(map_file_open(&loader, &map, DIRECTORY "sample-map.map"));
38 GREATEST_ASSERT_STR_EQ("This is a test map", map.title); 38 GREATEST_ASSERT_STR_EQ("This is a test map", map.title);
39 GREATEST_ASSERT_EQ(2, map.w); 39 GREATEST_ASSERT_EQ(4, map.columns);
40 GREATEST_ASSERT_EQ(2, map.h); 40 GREATEST_ASSERT_EQ(2, map.rows);
41 GREATEST_ASSERT_EQ(32, map.tile_w); 41
42 GREATEST_ASSERT_EQ(16, map.tile_h);
43 GREATEST_ASSERT_EQ(0, map.layers[0].tiles[0]); 42 GREATEST_ASSERT_EQ(0, map.layers[0].tiles[0]);
44 GREATEST_ASSERT_EQ(1, map.layers[0].tiles[1]); 43 GREATEST_ASSERT_EQ(1, map.layers[0].tiles[1]);
45 GREATEST_ASSERT_EQ(2, map.layers[0].tiles[2]); 44 GREATEST_ASSERT_EQ(2, map.layers[0].tiles[2]);
46 GREATEST_ASSERT_EQ(3, map.layers[0].tiles[3]); 45 GREATEST_ASSERT_EQ(3, map.layers[0].tiles[3]);
47 GREATEST_ASSERT_EQ(4, map.layers[1].tiles[0]); 46 GREATEST_ASSERT_EQ(4, map.layers[0].tiles[4]);
48 GREATEST_ASSERT_EQ(5, map.layers[1].tiles[1]); 47 GREATEST_ASSERT_EQ(5, map.layers[0].tiles[5]);
49 GREATEST_ASSERT_EQ(6, map.layers[1].tiles[2]); 48 GREATEST_ASSERT_EQ(6, map.layers[0].tiles[6]);
50 GREATEST_ASSERT_EQ(7, map.layers[1].tiles[3]); 49 GREATEST_ASSERT_EQ(7, map.layers[0].tiles[7]);
51 GREATEST_ASSERT_EQ(2, map.tiledefsz); 50
52 GREATEST_ASSERT_EQ(0, map.tiledefs[0].id); 51 GREATEST_ASSERT_EQ(8, map.layers[1].tiles[0]);
53 GREATEST_ASSERT_EQ(10, map.tiledefs[0].x); 52 GREATEST_ASSERT_EQ(9, map.layers[1].tiles[1]);
54 GREATEST_ASSERT_EQ(12, map.tiledefs[0].y); 53 GREATEST_ASSERT_EQ(10, map.layers[1].tiles[2]);
55 GREATEST_ASSERT_EQ(5, map.tiledefs[0].w); 54 GREATEST_ASSERT_EQ(11, map.layers[1].tiles[3]);
56 GREATEST_ASSERT_EQ(7, map.tiledefs[0].h); 55 GREATEST_ASSERT_EQ(12, map.layers[1].tiles[4]);
57 GREATEST_ASSERT_EQ(2, map.tiledefs[1].id); 56 GREATEST_ASSERT_EQ(13, map.layers[1].tiles[5]);
58 GREATEST_ASSERT_EQ(12, map.tiledefs[1].x); 57 GREATEST_ASSERT_EQ(14, map.layers[1].tiles[6]);
59 GREATEST_ASSERT_EQ(14, map.tiledefs[1].y); 58 GREATEST_ASSERT_EQ(15, map.layers[1].tiles[7]);
60 GREATEST_ASSERT_EQ(8, map.tiledefs[1].w); 59
61 GREATEST_ASSERT_EQ(10, map.tiledefs[1].h); 60 GREATEST_ASSERT_EQ(64U, map.tileset->sprite->cellw);
61 GREATEST_ASSERT_EQ(32U, map.tileset->sprite->cellh);
62
63 GREATEST_ASSERT_EQ(4, map.tileset->tiledefsz);
64
65 GREATEST_ASSERT_EQ(129, map.tileset->tiledefs[0].id);
66 GREATEST_ASSERT_EQ(8, map.tileset->tiledefs[0].x);
67 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[0].y);
68 GREATEST_ASSERT_EQ(56, map.tileset->tiledefs[0].w);
69 GREATEST_ASSERT_EQ(40, map.tileset->tiledefs[0].h);
70
71 GREATEST_ASSERT_EQ(130, map.tileset->tiledefs[1].id);
72 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[1].x);
73 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[1].y);
74 GREATEST_ASSERT_EQ(62, map.tileset->tiledefs[1].w);
75 GREATEST_ASSERT_EQ(40, map.tileset->tiledefs[1].h);
76
77 GREATEST_ASSERT_EQ(132, map.tileset->tiledefs[2].id);
78 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[2].x);
79 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[2].y);
80 GREATEST_ASSERT_EQ(64, map.tileset->tiledefs[2].w);
81 GREATEST_ASSERT_EQ(40, map.tileset->tiledefs[2].h);
82
83 GREATEST_ASSERT_EQ(133, map.tileset->tiledefs[3].id);
84 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[3].x);
85 GREATEST_ASSERT_EQ(0, map.tileset->tiledefs[3].y);
86 GREATEST_ASSERT_EQ(58, map.tileset->tiledefs[3].w);
87 GREATEST_ASSERT_EQ(40, map.tileset->tiledefs[3].h);
62 88
63 map_finish(&map); 89 map_finish(&map);
64 map_file_finish(&loader); 90 map_file_finish(&loader);
65 91
66 GREATEST_PASS(); 92 GREATEST_PASS();
70 test_error_title(void) 96 test_error_title(void)
71 { 97 {
72 struct map_file loader = {0}; 98 struct map_file loader = {0};
73 struct map map = {0}; 99 struct map map = {0};
74 100
75 GREATEST_ASSERT(!map_file_open(&loader, DIRECTORY "error-title.map", &map)); 101 GREATEST_ASSERT(!map_file_open(&loader, &map, DIRECTORY "error-title.map"));
76 102
77 map_finish(&map); 103 map_finish(&map);
78 map_file_finish(&loader); 104 map_file_finish(&loader);
79 105
80 GREATEST_PASS(); 106 GREATEST_PASS();
81 } 107 }
82 108
83 GREATEST_TEST 109 GREATEST_TEST
84 test_error_width(void) 110 test_error_columns(void)
85 { 111 {
86 struct map_file loader = {0}; 112 struct map_file loader = {0};
87 struct map map = {0}; 113 struct map map = {0};
88 114
89 GREATEST_ASSERT(!map_file_open(&loader, DIRECTORY "error-width.map", &map)); 115 GREATEST_ASSERT(!map_file_open(&loader, &map, DIRECTORY "error-columns.map"));
90 116
91 map_finish(&map); 117 map_finish(&map);
92 map_file_finish(&loader); 118 map_file_finish(&loader);
93 119
94 GREATEST_PASS(); 120 GREATEST_PASS();
95 } 121 }
96 122
97 GREATEST_TEST 123 GREATEST_TEST
98 test_error_height(void) 124 test_error_rows(void)
99 { 125 {
100 struct map_file loader = {0}; 126 struct map_file loader = {0};
101 struct map map = {0}; 127 struct map map = {0};
102 128
103 GREATEST_ASSERT(!map_file_open(&loader, DIRECTORY "error-height.map", &map)); 129 GREATEST_ASSERT(!map_file_open(&loader, &map, DIRECTORY "error-rows.map"));
104 130
105 map_finish(&map); 131 map_finish(&map);
106 map_file_finish(&loader); 132 map_file_finish(&loader);
107 133
108 GREATEST_PASS(); 134 GREATEST_PASS();
109 } 135 }
110 136
111 GREATEST_TEST 137 GREATEST_SUITE(suite_basics)
112 test_error_tilewidth(void)
113 { 138 {
114 struct map_file loader = {0}; 139 GREATEST_RUN_TEST(test_basics_sample);
115 struct map map = {0};
116
117 GREATEST_ASSERT(!map_file_open(&loader, DIRECTORY "error-tilewidth.map", &map));
118
119 map_finish(&map);
120 map_file_finish(&loader);
121
122 GREATEST_PASS();
123 } 140 }
124 141
125 GREATEST_TEST 142 GREATEST_SUITE(suite_errors)
126 test_error_tileheight(void)
127 {
128 struct map_file loader = {0};
129 struct map map = {0};
130
131 GREATEST_ASSERT(!map_file_open(&loader, DIRECTORY "error-tileheight.map", &map));
132
133 map_finish(&map);
134 map_file_finish(&loader);
135
136 GREATEST_PASS();
137 }
138
139 GREATEST_SUITE(basics)
140 {
141 GREATEST_RUN_TEST(test_sample);
142 }
143
144 GREATEST_SUITE(errors)
145 { 143 {
146 GREATEST_RUN_TEST(test_error_title); 144 GREATEST_RUN_TEST(test_error_title);
147 GREATEST_RUN_TEST(test_error_width); 145 GREATEST_RUN_TEST(test_error_columns);
148 GREATEST_RUN_TEST(test_error_height); 146 GREATEST_RUN_TEST(test_error_rows);
149 GREATEST_RUN_TEST(test_error_tilewidth);
150 GREATEST_RUN_TEST(test_error_tileheight);
151 } 147 }
152 148
153 GREATEST_MAIN_DEFS(); 149 GREATEST_MAIN_DEFS();
154 150
155 int 151 int
162 * window and all of the API. As tests sometime run on headless machine 158 * window and all of the API. As tests sometime run on headless machine
163 * we will skip if it fails to initialize. 159 * we will skip if it fails to initialize.
164 */ 160 */
165 161
166 if (core_init() && window_open("test-map", 100, 100)) { 162 if (core_init() && window_open("test-map", 100, 100)) {
167 GREATEST_RUN_SUITE(basics); 163 GREATEST_RUN_SUITE(suite_basics);
168 GREATEST_RUN_SUITE(errors); 164 GREATEST_RUN_SUITE(suite_errors);
169 } 165 }
170 166
171 GREATEST_MAIN_END(); 167 GREATEST_MAIN_END();
172 168
173 return 0; 169 return 0;