1 /* Project 16 Source Code~
\r
2 * Copyright (C) 2012-2017 sparky4 & pngwen & andrius4669 & joncampbell123 & yakui-lover
\r
4 * This file is part of Project 16.
\r
6 * Project 16 is free software; you can redistribute it and/or modify
\r
7 * it under the terms of the GNU General Public License as published by
\r
8 * the Free Software Foundation; either version 3 of the License, or
\r
9 * (at your option) any later version.
\r
11 * Project 16 is distributed in the hope that it will be useful,
\r
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
14 * GNU General Public License for more details.
\r
16 * You should have received a copy of the GNU General Public License
\r
17 * along with this program. If not, see <http://www.gnu.org/licenses/>, or
\r
18 * write to the Free Software Foundation, Inc., 51 Franklin Street,
\r
19 * Fifth Floor, Boston, MA 02110-1301 USA.
\r
23 #include "src/lib/16_map.h"
\r
25 // Ideally, preprocess json during compilation and read serialized data
\r
27 int jsoneq(const char *json, jsmntok_t *tok, const char *s) {
\r
28 if (tok->type == JSMN_STRING && (int) strlen(s) == tok->end - tok->start &&
\r
29 strncmp(json + tok->start, s, tok->end - tok->start) == 0) {
\r
35 /*//this function is quite messy ^^; sorry! it is a quick and dirty fix~
\r
36 word dump(const char *js, jsmntok_t *t, size_t count, word indent, char *js_sv, map_t *map, dword q) {
\r
43 fprintf(stdout, "%s\n", js);
\r
44 fprintf(stdout, "\n");
\r
47 #ifdef DEBUG_DUMPVARS
\r
48 fprintf(stdout, "t->size=[%d] ", t->size);
\r
49 fprintf(stdout, "q=[%d] ", q);
\r
50 fprintf(stdout, "indent= [%d] ", indent);
\r
51 fprintf(stdout, "js_sv= [%s]\n", js_sv);
\r
56 // We may want to do strtol() here to get numeric value
\r
57 //0000fprintf(stderr, "t->type=%d\n", t->type);
\r
58 if (t->type == JSMN_PRIMITIVE) {
\r
59 if(strstr(js_sv, "data"))
\r
62 // here we should recursivly call dump again here to skip over the array until we get the width of the map.
\r
63 // so we can initiate the map which allocates the facking map->tiles ->data->data properly and THEN we can return
\r
64 // here to read the data.... That is my design for this... wwww
\r
66 // well i am stuck.... wwww
\r
68 map->data[q] = (byte)atoi(js+t->start);
\r
69 #ifdef DEBUG_MAPDATA
\r
70 fprintf(stdout, "%d[%d]", q, map->data[q]);
\r
74 if(strstr(js_sv, "height"))
\r
76 map->height = atoi(js+t->start);
\r
78 fprintf(stdout, "indent= [%d] ", indent);
\r
79 fprintf(stdout, "h:[%d]\n", map->height);
\r
81 }else if(strstr(js_sv, "width"))
\r
83 map->width = atoi(js+t->start);
\r
85 fprintf(stdout, "indent= [%d] ", indent);
\r
86 fprintf(stdout, "w:[%d]\n", map->width);
\r
90 // We may use strndup() to fetch string value
\r
91 } else if (t->type == JSMN_STRING) {
\r
92 if(jsoneq(js, t, "data") == 0)
\r
94 // fprintf(stdout, "[[[[%d|%d]]]]\n", &(t+1)->size, (t+1)->size);
\r
95 // fprintf(stdout, "\n%.*s[xx[%d|%d]xx]\n", (t+1)->end - (t+1)->start, js+(t+1)->start, &(t+1)->size, (t+1)->size);
\r
96 map->data = malloc(sizeof(byte) * (t+1)->size);
\r
97 map->tiles = malloc(sizeof(tiles_t));
\r
98 map->tiles->btdata = malloc(sizeof(bitmap_t));
\r
99 //fix this to be far~
\r
100 //0000 bp = bitmapLoadPcx("data/ed.pcx");
\r
101 // bp = bitmapLoadPcx("data/koishi^^.pcx");
\r
102 map->tiles->btdata = &bp;
\r
103 //---- map->tiles->data = planar_buf_from_bitmap(&bp);
\r
104 //map->tiles->data->data = malloc((16)*16);
\r
105 //map->tiles->data->width = (16/);
\r
106 //map->tiles->data->height= 16;
\r
107 map->tiles->tileHeight = 16;
\r
108 map->tiles->tileWidth = 16;
\r
109 map->tiles->rows = 1;
\r
110 map->tiles->cols = 1;
\r
111 #ifdef __DEBUG_MAP__
\r
114 strcpy(js_sv, "data");//strdup(js+t->start);//, t->end - t->start);
\r
117 if (jsoneq(js, t, "height") == 0 && indent<=1)
\r
119 strcpy(js_sv, "height");//strdup(js+t->start);//, t->end - t->start);
\r
121 if(jsoneq(js, t, "width") == 0 && indent<=1)
\r
123 strcpy(js_sv, "width");//strdup(js+t->start);//, t->end - t->start);
\r
124 }else strcpy(js_sv, "\0");
\r
126 } else if (t->type == JSMN_OBJECT) {
\r
127 //fprintf(stdout, "\n");
\r
129 for (i = 0; i < t->size; i++) {
\r
130 //for (k = 0; k < indent; k++) fprintf(stdout, "\t");
\r
131 j += dump(js, t+1+j, count-j, indent+1, js_sv, map, i);
\r
132 //fprintf(stdout, ": ");
\r
133 j += dump(js, t+1+j, count-j, indent+1, js_sv, map, i);
\r
134 //fprintf(stdout, "\n");
\r
137 } else if (t->type == JSMN_ARRAY) {
\r
139 //fprintf(stdout, "==\n");
\r
140 for (i = 0; i < t->size; i++) {
\r
141 //for (k = 0; k < indent-1; k++) fprintf(stdout, "\t");
\r
142 //fprintf(stdout, "\t-");
\r
143 j += dump(js, t+1+j, count-j, indent+1, js_sv, map, i);
\r
144 //fprintf(stdout, "==\n");
\r
151 int loadmap(char *mn, map_t *map, global_game_variables_t *gvar)
\r
154 static word incr=0;
\r
155 int eof_expected = 0;
\r
159 static char js_ss[16];
\r
163 size_t tokcount = 2;
\r
165 FILE *fh = fopen(mn, "r");
\r
170 // Allocate some tokens as a start
\r
171 //0000fprintf(stderr, "tok malloc\n");
\r
172 tok = malloc(sizeof(*tok) * tokcount);
\r
174 fprintf(stderr, "malloc(): errno=%d\n", errno);
\r
179 // Read another chunk
\r
180 //0000fprintf(stderr, "read\n");
\r
181 r = fread(buf, 1, sizeof(buf), fh);
\r
183 fprintf(stderr, "fread(): %d, errno=%d\n", r, errno);
\r
187 if (eof_expected != 0) {
\r
190 fprintf(stderr, "fread(): unexpected EOF\n");
\r
194 //0000fprintf(stdout, "r= [%d] BUFSIZ=%d\n", r, BUFSIZ);
\r
195 //0000fprintf(stderr, "js alloc~\n");
\r
196 js = realloc(js, jslen + r + 1);
\r
198 fprintf(stderr, "*js=%Fp\n", *js);
\r
199 fprintf(stderr, "realloc(): errno = %d\n", errno);
\r
202 strncpy(js + jslen, buf, r);
\r
206 //0000fprintf(stdout, " parse~ tok=%zu jslen=%zu r=%d _memavl()=%u BUFSIZ=%d~\n", tokcount, jslen, r, _memavl(), BUFSIZ);
\r
207 //0000fprintf(stdout, "p=[%u] [%u] [%d]\n", p.pos, p.toknext, p.toksuper);
\r
209 // I think it crashes on the line below when it tries to parse the data of huge maps... wwww this is a jsmn problem wwww
\r
211 r = jsmn_parse(&p, js, jslen, tok, tokcount);
\r
212 //0000fprintf(stdout, "r= [%d]\n", r);
\r
214 if (r == JSMN_ERROR_NOMEM) {
\r
215 tokcount = tokcount * 2;
\r
216 //0000fprintf(stderr, "tok realloc~ %zu\n", tokcount);
\r
217 tok = realloc(tok, sizeof(*tok) * tokcount);
\r
219 fprintf(stderr, "realloc(): errno=%d\n", errno);
\r
225 //printf("js=%Fp\n", (js));
\r
226 //printf("*js=%Fp\n", (*(js)));
\r
227 //printf("&*js=%s\n", &(*(js)));
\r
228 //printf("&buf=[%Fp]\n", &buf);
\r
229 //printf("&buf_seg=[%x]\n", FP_SEG(&buf));
\r
230 //printf("&buf_off=[%x]\n", FP_OFF(&buf));
\r
231 //printf("&buf_fp=[%Fp]\n", MK_FP(FP_SEG(&buf), FP_OFF(&buf)));
\r
232 //printf("buf=[\n%s\n]\n", buf);
\r
233 //printf("buff=[%Fp]\n", buff);
\r
234 //printf("(*buff)=[%Fp]\n", (*buff));
\r
235 //printf("&(*buff)=[\n%s\n]\n", &(*buff));
\r
236 #ifdef DEBUG_DUMPVARS
\r
237 fprintf(stdout, "running dump~\n");
\r
239 dump(js, tok, p.toknext, incr, &js_ss, map, 0);
\r
251 void extract_map(const char *js, jsmntok_t *t, size_t count, map_t *map) {
\r
252 int i, j, k, indent=0, inner_end;
\r
258 if(jsoneq(js, &(t[i]), "layers") == 0) {
\r
260 //map->layerdata = malloc(sizeof(byte*) * t[i].size);
\r
261 inner_end = t[i].end;
\r
263 while(t[i].start < inner_end) {
\r
264 #ifdef DEBUG_DUMPVARS
\r
265 printf("t[%d].start=%d, %d\n", i, t[i].start, inner_end);
\r
267 if(jsoneq(js, &(t[i]), "data") == 0) {
\r
268 #ifdef DEBUG_MAPDATA
\r
269 printf("Layer %d data: [\n", k);
\r
271 map->layerdata[k].data = malloc(sizeof(byte) * t[i+1].size);
\r
272 // map->data = (map->layerdata[k].data); //for backwards compatibility for rest of code
\r
273 for(j = 0; j < t[i+1].size; j++) {
\r
274 //map->layerdata[k][j] = (byte)atoi(js + t[i+2+j].start);
\r
275 map->layerdata[k].data[j] = (byte)atoi(js + t[i+2+j].start);
\r
276 #ifdef DEBUG_MAPDATA
\r
277 //printf("[%d,%d]%d", k, j, map->MAPDATAPTK[j]);
\r
278 printf("%c", map->MAPDATAPTK[j]+44);
\r
279 //fprintf(stdout, "%c", map->data[j]+44);
\r
284 #ifdef DEBUG_MAPDATA
\r
292 if(jsoneq(js, &(t[i]), "tilesets") == 0) {
\r
294 inner_end = t[i].end;
\r
296 while(t[i].start < inner_end) {
\r
297 if(jsoneq(js, &(t[i]), "image") == 0) {
\r
298 map->MAPTILESPTK = malloc(sizeof(tiles_t));
\r
299 s = remove_ext((char *)js+t[i+1].start, '.', '/');
\r
300 strcpy(map->MAPTILESPTK->imgname, s);
\r
301 //And move to vrs, probably
\r
302 // bp = bitmapLoadPcx("data/ed.pcx");
\r
303 // map->MAPTILESPTK->btdata = &bp;
\r
304 //map->MAPTILESPTK->btdata = malloc(sizeof(bitmap_t));
\r
305 map->MAPTILESPTK->rows = 1;
\r
306 map->MAPTILESPTK->cols = 1;
\r
307 #ifdef __DEBUG_MAP__
\r
311 }else if(jsoneq(js, &(t[i]), "tileheight") == 0) {
\r
312 map->MAPTILESPTK->tileHeight = atoi(js + t[i+1].start);
\r
313 #ifdef DEBUG_MAPVAR
\r
314 printf("Tile Height: %d\n", map->MAPTILESPTK->tileHeight);
\r
317 }else if(jsoneq(js, &(t[i]), "tilewidth") == 0) {
\r
318 map->MAPTILESPTK->tileWidth = atoi(js + t[i+1].start);
\r
319 #ifdef DEBUG_MAPVAR
\r
320 printf("Tile Width: %d\n", map->MAPTILESPTK->tileWidth);
\r
329 if (jsoneq(js, &(t[i]), "height") == 0 && indent<=1) {
\r
330 map->height = atoi(js + t[i+1].start);
\r
331 #ifdef DEBUG_MAPVAR
\r
332 printf("Height: %d\n", map->height);
\r
336 else if(jsoneq(js, &(t[i]), "width") == 0 && indent<=1) {
\r
337 map->width = atoi(js + t[i+1].start);
\r
338 #ifdef DEBUG_MAPVAR
\r
339 printf("Width: %d\n", map->width);
\r
347 int newloadmap(char *mn, map_t *map) {
\r
351 jsmntok_t *tok = NULL;
\r
352 size_t tokcount, file_s;
\r
354 FILE *fh = fopen(mn, "r");
\r
357 /* Prepare parser */
\r
360 file_s = filesize(fh);
\r
361 js = malloc(file_s);
\r
363 fprintf(stderr, "malloc(): errno = %d", 2);
\r
367 if(fread(js, 1, file_s, fh) != file_s) {
\r
368 fprintf(stderr, "Map read error");
\r
373 tokcount = jsmn_parse(&p, js, file_s, NULL, 0);
\r
374 tok = malloc(tokcount*sizeof(jsmntok_t));
\r
375 printf("Allocated %d tokens", tokcount);
\r
377 if((status = jsmn_parse(&p, js, file_s, tok, tokcount)) < 0)
\r
379 printf("Error: %d\n", status);
\r
382 else if(status != tokcount) { printf("Warning: used %d tok\n", status);}
\r
383 extract_map(js, tok, tokcount, map);
\r
396 #define MAPBUFINLM (gvar->ca.camap.mapsegs)
\r
397 int CA_loadmap(char *mn, map_t *map, global_game_variables_t *gvar)
\r
400 jsmntok_t *tok = NULL;
\r
401 size_t tokcount, file_s;
\r
403 FILE *fh = fopen(mn, "r");
\r
406 /* Prepare parser */
\r
409 file_s = filesize(fh);
\r
410 CA_LoadFile(mn, &MAPBUFINLM, gvar);
\r
411 tokcount = jsmn_parse(&p, MAPBUFINLM, file_s, NULL, 0);
\r
412 tok = malloc(tokcount*sizeof(jsmntok_t));
\r
413 // printf("Allocated %d tokens", tokcount);
\r
415 if((status = jsmn_parse(&p, MAPBUFINLM, file_s, tok, tokcount)) < 0)
\r
417 printf("Error: %d\n", status);
\r
420 else if(status != tokcount) { printf("Warning: used %d tok\n", status);}
\r
421 extract_map(MAPBUFINLM, tok, tokcount, map);
\r