1 /*
2 * savedate.c �����֥ǡ����δ���
3 *
4 * Copyright (C) 1997-1998 Masaki Chikama (Wren) <chikama@kasumi.ipl.mech.nagoya-u.ac.jp>
5 * 1998- <masaki-c@is.aist-nara.ac.jp>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22 /* $Id: savedata.c,v 1.36 2003/07/21 23:06:47 chikama Exp $ */
23
24 #include "config.h"
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30
31 #include "portab.h"
32 #include "savedata.h"
33 #include "scenario.h"
34 #include "xsystem35.h"
35 #include "LittleEndian.h"
36 #include "eucsjis.h"
37 #include "filecheck.h"
38 #include "windowframe.h"
39 #include "selection.h"
40 #include "message.h"
41
42 /* �����֥ǡ��� */
43 static char *saveDataFile[SAVE_MAXNUMBER];
44 static char *saveDataPath;
45 static int savefile_sysvar_cnt = SYSVAR_MAX;
46
47 static void* saveStackInfo(Ald_stackHdr *head);
48 static void loadStackInfo(char *buf);
49 static void* saveStrVar(Ald_strVarHdr *head);
50 static void loadStrVar(char *buf);
51 static void* saveSysVar(Ald_sysVarHdr *head, int page);
52 static int loadSysVar(char *buf);
53 static void* loadGameData(int no, int *status, int *size);
54 static int saveGameData(int no, char *buf, int size);
55
56
57
58 /* savefile ������ directory ����Ͽ */
save_set_path(char * path)59 void save_set_path(char *path) {
60 nact->files.savedir = strdup(path);
61 saveDataPath = strdup(path);
62 fc_init(path);
63 }
64
65 /* savefile ����Ͽ */
save_register_file(char * name,int index)66 void save_register_file(char *name, int index) {
67 saveDataFile[index] = strdup(name);
68 }
69
70 /* savefile ���� */
save_get_file(int index)71 char *save_get_file(int index) {
72 return saveDataFile[index];
73 }
74
75 /* savefile ���� */
save_delete_file(int index)76 int save_delete_file(int index) {
77 int ret = unlink(saveDataFile[index]);
78
79 if (ret == 0) {
80 return 1;
81 }
82 return 1; /* �Ȥꤢ���� */
83 }
84
get_fullpath(char * filename)85 static char *get_fullpath(char *filename) {
86 char *fn = malloc(strlen(filename) + strlen(saveDataPath) + 3);
87 if (fn == NULL) {
88 return NULL;
89 }
90 strcpy(fn, saveDataPath);
91 strcat(fn, "/");
92 strcat(fn, filename);
93 return fn;
94 }
95
backup_oldfile(char * filename)96 static void backup_oldfile(char *filename) {
97 char *newname;
98
99 if (!filename) return;
100 newname = malloc(strlen(filename) + 3);
101
102 strcpy(newname, filename);
103 strcat(newname, ".");
104 rename(filename, newname);
105
106 free(newname);
107 }
108
fileopen(char * filename,char type)109 static FILE *fileopen(char *filename, char type) {
110 char *fc = fc_search(filename);
111 char *fullpath;
112 FILE *fp;
113
114 if (fc == NULL) { /* if file does not exist */
115 if (type == 'r') return NULL;
116 fc = fc_add(filename);
117 }
118 fullpath = get_fullpath(fc);
119
120 if (type == 'w') {
121 backup_oldfile(fullpath);
122 fp = fopen(fullpath, "w");
123 } else {
124 fp = fopen(fullpath, "r");
125 }
126 free(fullpath);
127 return fp;
128 }
129
130 /* ����ե�����ؤ��ѿ��ν����� */
save_save_var_with_file(char * filename,int * start,int cnt)131 int save_save_var_with_file(char *filename, int *start, int cnt) {
132 int status = 0, size, i;
133 FILE *fp;
134 WORD *tmp, *_tmp;
135
136 tmp = _tmp = (WORD *)malloc(cnt * sizeof(WORD));
137
138 if (tmp == NULL) {
139 WARNING("Out of memory\n");
140 return SAVE_SAVEERR;
141 }
142
143 for (i = 0; i < cnt; i++) {
144 #ifdef WORDS_BIGENDIAN
145 *tmp = swap16((WORD)*start); start++; tmp++;
146 #else
147 *tmp = (WORD)*start; start++; tmp++;
148 #endif
149 }
150
151 if (NULL == (fp = fileopen(filename, 'w'))) {
152 status = SAVE_SAVEERR; goto errexit;
153 }
154
155 size = fwrite(_tmp, sizeof(WORD), cnt, fp);
156
157 if (size != cnt) {
158 status = SAVE_OTHERERR;
159 } else {
160 status = SAVE_SAVEOK0;
161 }
162
163 fclose(fp);
164 errexit:
165 free(_tmp);
166
167 return status;
168 }
169
170 /* ����ե����뤫����ѿ����ɤ߹��� */
save_load_var_with_file(char * filename,int * start,int cnt)171 int save_load_var_with_file(char *filename, int *start, int cnt) {
172 int status = 0, size, i;
173 FILE *fp;
174 WORD *tmp, *_tmp;
175
176 tmp = _tmp = (WORD *)malloc(cnt * sizeof(WORD));
177
178 if (tmp == NULL) {
179 WARNING("Out of memory\n");
180 return SAVE_LOADERR;
181 }
182
183 if (NULL == (fp = fileopen(filename, 'r'))) {
184 status = SAVE_LOADERR; goto errexit;
185 }
186
187 size = fread(tmp, sizeof(WORD), cnt, fp);
188
189 if (size != cnt) {
190 status = SAVE_LOADSHORTAGE;
191 } else {
192 status = SAVE_LOADOK;
193 }
194
195 for (i = 0; i < cnt; i++) {
196 #ifdef WORDS_BIGENDIAN
197 *start = swap16(*tmp); start++; tmp++;
198 #else
199 *start = *tmp; start++; tmp++;
200 #endif
201 }
202
203 fclose(fp);
204 errexit:
205 free(_tmp);
206 return status;
207 }
208
209
210 /* ����ե�����ؤ�ʸ����ν�����, start = 1~ */
save_save_str_with_file(char * filename,int start,int cnt)211 int save_save_str_with_file(char *filename, int start, int cnt) {
212 int status = 0, size, _size,i;
213 FILE *fp;
214 char *tmp, *_tmp;
215
216 _tmp = tmp = malloc(strvar_cnt * strvar_len);
217 if (tmp == NULL) {
218 WARNING("Out of memory\n");
219 return SAVE_LOADSHORTAGE;
220 }
221
222 *tmp = 0;
223 for (i = 0; i < cnt; i++) {
224 strncpy(tmp, v_str(start + i - 1), strvar_len - 1);
225 tmp += v_strlen(start + i - 1) + 1;
226 }
227
228
229 if (NULL == (fp = fileopen(filename, 'w'))) {
230 status = SAVE_SAVEERR; goto errexit;
231 }
232 size = tmp - _tmp;
233 _size = fwrite(_tmp, sizeof(char), size , fp);
234
235 if (size != _size) {
236 status = SAVE_OTHERERR;
237 } else {
238 status = SAVE_SAVEOK0;
239 }
240
241 fclose(fp);
242 errexit:
243 free(_tmp);
244
245 return status;
246 }
247
248 /* ����ե����뤫���ʸ������ɤ߹��� */
save_load_str_with_file(char * filename,int start,int cnt)249 int save_load_str_with_file(char *filename, int start, int cnt) {
250 int status = 0, size, i;
251 FILE *fp;
252 char *tmp, *_tmp=NULL;
253 long filesize;
254
255 if (NULL == (fp = fileopen(filename, 'r'))) {
256 return SAVE_LOADERR;
257 }
258
259 fseek(fp, 0L, SEEK_END);
260 filesize = ftell(fp);
261 if (filesize == 0) {
262 return SAVE_LOADERR;
263 }
264
265 tmp = _tmp = (char *)malloc(filesize);
266 if (tmp == NULL) {
267 WARNING("Out of memory\n");
268 return SAVE_LOADERR;
269 }
270
271 fseek(fp, 0L, SEEK_SET);
272 size = fread(tmp, 1, filesize,fp);
273
274 if (size != filesize) {
275 status = SAVE_LOADSHORTAGE;
276 } else {
277 status = SAVE_LOADOK;
278 }
279 for (i = 0; i < cnt; i++) {
280 strncpy(v_str(start + i - 1), tmp, strvar_len);
281 tmp += v_strlen(start + i - 1) + 1;
282 }
283 fclose(fp);
284 free(_tmp);
285
286 return status;
287 }
288
289 /* �����֥ե�����Υ��ԡ� */
save_copyAll(int dstno,int srcno)290 int save_copyAll(int dstno, int srcno) {
291 char *saveTop;
292 int status, filesize;
293
294 if (dstno >= SAVE_MAXNUMBER || srcno >= SAVE_MAXNUMBER) {
295 // fprintf(stderr, "dstno or srcno is outof range\n");
296 return SAVE_SAVEERR;
297 }
298 saveTop = loadGameData(srcno, &status, &filesize);
299 if (saveTop == NULL)
300 return SAVE_SAVEERR;
301 if (((Ald_baseHdr *)saveTop)->version != SAVE_DATAVERSION) {
302 fprintf(stderr, "save_copyAll(): endian mismatch\n");
303 free(saveTop);
304 return SAVE_SAVEERR;
305 }
306 status = saveGameData(dstno, saveTop, filesize);
307
308 free(saveTop);
309
310 return status;
311 }
312
313 /* �ǡ����ΰ������� */
save_loadPartial(int no,int page,int offset,int cnt)314 int save_loadPartial(int no, int page, int offset, int cnt) {
315 Ald_baseHdr *save_base;
316 char *vtop;
317 WORD *tmp;
318 int *var;
319 char *saveTop = NULL;
320 int i, status, filesize;
321
322 if (no >= SAVE_MAXNUMBER) {
323 return SAVE_SAVEERR;
324 }
325 if (page == 0) {
326 cnt = min(cnt, SYSVAR_MAX - offset);
327 var = sysVar + offset;
328 } else {
329 cnt = min(cnt, arrayVarBuffer[page - 1].max - offset);
330 var = arrayVarBuffer[page - 1].value + offset;
331 }
332
333 saveTop = loadGameData(no, &status, &filesize);
334 if (saveTop == NULL) {
335 // fprintf(stderr, "loadGameData() faild\n");
336 return status;
337 }
338
339 if (filesize <= sizeof(Ald_baseHdr)) {
340 // fprintf(stderr, "filesize too short\n");
341 goto errexit;
342 }
343
344 save_base = (Ald_baseHdr *)saveTop;
345 if (save_base->version != SAVE_DATAVERSION) {
346 fprintf(stderr, "save_loadPartial(): endian mismatch\n");
347 goto errexit;
348 }
349
350 if (save_base->varSys[page] == 0) {
351 // fprintf(stderr, "No available Variable\n");
352 goto errexit;
353 }
354 vtop = saveTop + save_base->varSys[page] + sizeof(Ald_sysVarHdr);
355 tmp = (WORD *)vtop + offset;
356 for (i = 0; i < cnt; i++) {
357 *var = *tmp; tmp++; var++;
358 }
359 free(saveTop);
360 return SAVE_LOADOK;
361
362 errexit:
363 if (saveTop != NULL)
364 free(saveTop);
365
366 return SAVE_LOADERR;
367 }
368
369 /* �ǡ����ΰ��������� */
save_savePartial(int no,int page,int offset,int cnt)370 int save_savePartial(int no, int page, int offset, int cnt) {
371 Ald_baseHdr *save_base;
372 WORD *tmp;
373 char *vtop;
374 int *var;
375 char *saveTop = NULL;
376 int i, status, filesize;
377
378 if (no >= SAVE_MAXNUMBER) {
379 return SAVE_SAVEERR;
380 }
381 if (page == 0) {
382 cnt = min(cnt, SYSVAR_MAX - offset);
383 var = sysVar + offset;
384 } else {
385 if (arrayVarBuffer[page - 1].saveflag == FALSE)
386 goto errexit;
387 cnt = min(cnt, arrayVarBuffer[page - 1].max - offset);
388 var = arrayVarBuffer[page - 1].value + offset;
389 }
390
391 saveTop = loadGameData(no, &status, &filesize);
392 if (saveTop == NULL)
393 return status;
394 if (filesize <= sizeof(Ald_baseHdr))
395 goto errexit;
396 save_base = (Ald_baseHdr *)saveTop;
397 if (save_base->version != SAVE_DATAVERSION) {
398 fprintf(stderr, "save_savePartial(): endian mismatch\n");
399 goto errexit;
400 }
401 vtop = saveTop + save_base->varSys[page] + sizeof(Ald_sysVarHdr);
402 tmp = (WORD *)vtop + offset;
403 for (i = 0; i < cnt; i++) {
404 *tmp = (WORD)*var; tmp++; var++;
405 }
406 status = saveGameData(no, saveTop, filesize);
407 free(saveTop);
408
409 return status;
410
411 errexit:
412 if (saveTop != NULL)
413 free(saveTop);
414
415 return SAVE_SAVEERR;
416 }
417
418
419 /* �ǡ����Υ��� */
save_loadAll(int no)420 int save_loadAll(int no) {
421 Ald_baseHdr *save_base;
422 char *saveTop = NULL;
423 int i, status, filesize;
424
425 if (no >= SAVE_MAXNUMBER) {
426 return SAVE_SAVEERR;
427 }
428 saveTop = loadGameData(no, &status, &filesize);
429 if (saveTop == NULL)
430 return status;
431 if (filesize <= sizeof(Ald_baseHdr))
432 goto errexit;
433 /* �Ƽ�ǡ�����ȿ�� */
434 save_base = (Ald_baseHdr *)saveTop;
435 if (save_base->version != SAVE_DATAVERSION) {
436 fprintf(stderr, "save_loadAll(): endian mismatch\n");
437 goto errexit;
438 }
439 if (strcmp(SAVE_DATAID, save_base->ID) != 0)
440 goto errexit;
441 nact->sel.MsgFontSize = save_base->selMsgSize;
442 nact->sel.MsgFontColor = save_base->selMsgColor;
443 nact->sel.WinBackgroundColor = save_base->selBackColor;
444 nact->sel.WinFrameColor = save_base->selFrameColor;
445 nact->msg.MsgFontSize = save_base->msgMsgSize;
446 nact->msg.MsgFontColor = save_base->msgMsgColor;
447 nact->msg.WinBackgroundColor = save_base->msgBackColor;
448 nact->msg.WinFrameColor = save_base->msgFrameColor;
449 sl_jmpFar2(save_base->scoPage, save_base->scoIndex);
450
451 for (i = 0; i < SELWINMAX; i++) {
452 selWinInfo[i].x = save_base->selWinInfo[i].x;
453 selWinInfo[i].y = save_base->selWinInfo[i].y;
454 selWinInfo[i].width = save_base->selWinInfo[i].width;
455 selWinInfo[i].height = save_base->selWinInfo[i].height;
456 // selWinInfo[i].save = TRUE;
457 }
458 for (i = 0; i < MSGWINMAX; i++) {
459 msgWinInfo[i].x = save_base->msgWinInfo[i].x;
460 msgWinInfo[i].y = save_base->msgWinInfo[i].y;
461 msgWinInfo[i].width = save_base->msgWinInfo[i].width;
462 msgWinInfo[i].height = save_base->msgWinInfo[i].height;
463 // msgWinInfo[i].savedImage = NULL;
464 // msgWinInfo[i].save = FALSE;
465 }
466 /* �����å��Υ��� */
467 loadStackInfo(saveTop + save_base->stackinfo);
468 /* ʸ�����ѿ��Υ��� */
469 loadStrVar(saveTop + save_base->varStr);
470 /* ���͡������ѿ��Υ��� */
471 for (i = 0; i < 256; i++) {
472 if (save_base->varSys[i] != 0) {
473 if (SAVE_LOADOK != loadSysVar(saveTop + save_base->varSys[i]))
474 goto errexit;
475
476 }
477 }
478 free(saveTop);
479 return SAVE_LOADOK;
480 errexit:
481 free(saveTop);
482 return SAVE_LOADERR;
483 }
484
485 /* �ǡ����Υ����� */
save_saveAll(int no)486 int save_saveAll(int no) {
487 Ald_baseHdr *save_base = calloc(1, sizeof(Ald_baseHdr));
488 Ald_strVarHdr save_strHdr;
489 Ald_stackHdr save_stackHdr;
490 Ald_sysVarHdr save_sysHdr;
491 char *sd_varStr = NULL;
492 char *sd_stack = NULL;
493 char *sd_varSys = NULL;
494 int i, totalsize = sizeof(Ald_baseHdr);
495 FILE *fp;
496
497 if (no >= SAVE_MAXNUMBER)
498 return SAVE_SAVEERR;
499
500 if (save_base == NULL)
501 return SAVE_SAVEERR;
502
503 backup_oldfile(saveDataFile[no]);
504 fp = fopen(saveDataFile[no],"wb");
505
506 if (fp == NULL)
507 return SAVE_SAVEERR;
508
509 memset(&save_stackHdr, 0, sizeof(Ald_stackHdr));
510 memset(&save_strHdr, 0, sizeof(Ald_strVarHdr));
511 memset(&save_sysHdr, 0, sizeof(Ald_sysVarHdr));
512
513 /* �Ƽ�ǡ����Υ����� */
514 strncpy(save_base->ID, SAVE_DATAID, 32);
515 save_base->version = SAVE_DATAVERSION;
516 save_base->selMsgSize = (BYTE)nact->sel.MsgFontSize;
517 save_base->selMsgColor = (BYTE)nact->sel.MsgFontColor;
518 save_base->selBackColor = (BYTE)nact->sel.WinBackgroundColor;
519 save_base->selFrameColor = (BYTE)nact->sel.WinFrameColor;
520 save_base->msgMsgSize = (BYTE)nact->msg.MsgFontSize;
521 save_base->msgMsgColor = (BYTE)nact->msg.MsgFontColor;
522 save_base->msgBackColor = (BYTE)nact->msg.WinBackgroundColor;
523 save_base->msgFrameColor = (BYTE)nact->msg.WinFrameColor;
524 save_base->scoPage = sl_getPage();
525 save_base->scoIndex = sl_getIndex();
526
527 for (i = 0; i < SELWINMAX; i++) {
528 save_base->selWinInfo[i].x = (WORD)selWinInfo[i].x;
529 save_base->selWinInfo[i].y = (WORD)selWinInfo[i].y;
530 save_base->selWinInfo[i].width = (WORD)selWinInfo[i].width;
531 save_base->selWinInfo[i].height = (WORD)selWinInfo[i].height;
532 }
533
534 for (i = 0; i < MSGWINMAX; i++) {
535 save_base->msgWinInfo[i].x = (WORD)msgWinInfo[i].x;
536 save_base->msgWinInfo[i].y = (WORD)msgWinInfo[i].y;
537 save_base->msgWinInfo[i].width = (WORD)msgWinInfo[i].width;
538 save_base->msgWinInfo[i].height = (WORD)msgWinInfo[i].height;
539 }
540
541 fseek(fp, sizeof(Ald_baseHdr), SEEK_SET);
542
543 /* ��������� */
544 if (NULL == (sd_stack = saveStackInfo(&save_stackHdr)))
545 goto errexit;
546
547 if (1 != fwrite(&save_stackHdr, sizeof(save_stackHdr), 1, fp))
548 goto errexit;
549
550 if (save_stackHdr.size != 0 && 1 != fwrite(sd_stack, save_stackHdr.size, 1, fp))
551 goto errexit;
552
553 save_base->stackinfo = totalsize;
554 totalsize += save_stackHdr.size + sizeof(Ald_stackHdr);
555
556 /* ʸ�����ѿ� */
557 if (NULL == (sd_varStr = saveStrVar(&save_strHdr)))
558 goto errexit;
559
560 if (1 != fwrite(&save_strHdr, sizeof(Ald_strVarHdr), 1, fp))
561 goto errexit;
562
563 if (save_strHdr.size != 0 && 1 != fwrite(sd_varStr, save_strHdr.size, 1, fp))
564 goto errexit;
565
566 save_base->varStr = totalsize;
567 totalsize += save_strHdr.size + sizeof(Ald_strVarHdr);
568 free(sd_varStr);
569
570 /* �����ѿ��������ѿ� */
571 for (i = 0; i < 256; i++) {
572 sd_varSys = saveSysVar(&save_sysHdr, i);
573 if (sd_varSys == NULL) {
574 save_base->varSys[i] = 0;
575 } else {
576 if (1 != fwrite(&save_sysHdr, sizeof(Ald_sysVarHdr), 1, fp))
577 goto errexit;
578 if (1 != fwrite(sd_varSys, save_sysHdr.size, 1, fp))
579 goto errexit;
580 save_base->varSys[i] = totalsize;
581 totalsize += save_sysHdr.size + sizeof(Ald_sysVarHdr);
582 free(sd_varSys);
583 }
584 }
585
586 fseek(fp, 0, SEEK_SET);
587
588 if (1 != fwrite(save_base, sizeof(Ald_baseHdr), 1, fp))
589 goto errexit;
590
591 fclose(fp);
592 free(save_base);
593
594 return SAVE_SAVEOK1;
595
596 errexit:
597 if (fp != NULL)
598 fclose(fp);
599 if (save_base != NULL)
600 free(save_base);
601 if (sd_varStr != NULL)
602 free(sd_varStr);
603 if (sd_varSys != NULL)
604 free(sd_varSys);
605
606 return SAVE_SAVEERR;
607 }
608
609 /* �����å�����Υ����� */
saveStackInfo(Ald_stackHdr * head)610 static void *saveStackInfo(Ald_stackHdr *head) {
611 int count;
612 int *info = sl_getStackInfo(&count);
613
614 head->size = count * sizeof(int);
615 return (void *)info;
616 }
617
618 /* �����å�����Υ��� */
loadStackInfo(char * buf)619 static void loadStackInfo(char *buf) {
620 Ald_stackHdr *head = (Ald_stackHdr *)buf;
621 char *data = buf + sizeof(Ald_stackHdr);
622 sl_putStackInfo((int *)data, head->size / sizeof(int));
623 }
624
625 /* ʸ�����ѿ��Υ����� */
saveStrVar(Ald_strVarHdr * head)626 static void *saveStrVar(Ald_strVarHdr *head) {
627 int i;
628 char *tmp, *_tmp;
629 _tmp = tmp = malloc(strvar_cnt * strvar_len);
630 if (tmp == NULL) {
631 WARNING("Out of memory\n");
632 return NULL;
633 }
634 *tmp = 0;
635 for (i = 0; i < strvar_cnt; i++) {
636 strncpy(tmp, v_str(i), strvar_len - 1);
637 tmp += v_strlen(i) + 1;
638 }
639 head->size = tmp - _tmp;
640 head->count = strvar_cnt;
641 head->maxlen = strvar_len;
642 return _tmp;
643 }
644
645 /* ʸ�����ѿ��Υ��� */
loadStrVar(char * buf)646 static void loadStrVar(char *buf) {
647 Ald_strVarHdr *head = (Ald_strVarHdr *)buf;
648 int cnt, max, i;
649
650 cnt = head->count;
651 max = head->maxlen;
652 if (strvar_cnt != cnt || strvar_len != max)
653 v_initStringVars(cnt, max);
654 buf += sizeof(Ald_strVarHdr);
655 for (i = 0; i < cnt; i++) {
656 strncpy(v_str(i), buf, max - 1);
657 buf += v_strlen(i) + 1;
658 }
659 }
660
661 /* ���͡������ѿ��Υ����� */
saveSysVar(Ald_sysVarHdr * head,int page)662 static void *saveSysVar(Ald_sysVarHdr *head, int page) {
663 int *var;
664 int cnt, i;
665 WORD *tmp, *_tmp;
666 if (page == 0) { /* sysVar */
667 cnt = min(savefile_sysvar_cnt, SYSVAR_MAX);
668 var = sysVar;
669 } else if (!arrayVarBuffer[page - 1].saveflag) {
670 return NULL;
671 } else {
672 cnt = arrayVarBuffer[page - 1].max;
673 var = arrayVarBuffer[page - 1].value;
674 if (var == NULL)
675 return NULL;
676 }
677 head->size = cnt * sizeof(WORD);
678 head->pageNo = page;
679 tmp = _tmp = (WORD *)malloc(cnt * sizeof(WORD));
680 if (tmp == NULL) {
681 WARNING("Out of memory\n");
682 return NULL;
683 }
684 for (i = 0; i < cnt; i++) {
685 *tmp = (WORD)*var; var++; tmp++;
686 }
687 return _tmp;
688 }
689
690 /* ���͡������ѿ��Υ��� */
loadSysVar(char * buf)691 static int loadSysVar(char *buf) {
692 int i, cnt;
693 int *var;
694 int bool;
695 WORD *data;
696 Ald_sysVarHdr *head = (Ald_sysVarHdr *)buf;
697 int page = head->pageNo;
698
699 if (page == 0) {
700 #if 0
701 if (head->size != SYSVAR_MAX * sizeof(WORD))
702 return SAVE_LOADERR;
703 var = sysVar;
704 cnt = SYSVAR_MAX;
705 #endif
706 var = sysVar;
707 cnt = savefile_sysvar_cnt = head->size / sizeof(WORD);
708 } else {
709 cnt = head->size / sizeof(WORD);
710 if (arrayVarBuffer[page - 1].max != cnt ||
711 arrayVarBuffer[page - 1].value == NULL) {
712 /*
713 fprintf(stderr, "loadSysVar(): undef array\n");
714 return SAVE_LOADERR;
715 */
716
717 bool = v_allocateArrayBuffer(page, cnt, TRUE);
718 if (!bool) {
719 fprintf(stderr, "v_allocateArrayBuffer fail\n");
720 return SAVE_LOADERR;
721 }
722
723 }
724 var = arrayVarBuffer[page - 1].value;
725 }
726 buf += sizeof(Ald_sysVarHdr);
727 data = (WORD *)buf;
728 for (i = 0; i < cnt; i++) {
729 *var++ = *data++;
730 }
731 return SAVE_LOADOK;
732 }
733
734
735 /* ������ǡ����Υ���
736
737 no: �����֥ե������ֹ� 0~
738 *status: ���ơ�����
739 *size: �ǡ������礭�����֤��ݥ���
740
741 ���Ȥ� free(*buf)����Τ�˺��ʤ��褦��
742 */
loadGameData(int no,int * status,int * size)743 static void* loadGameData(int no, int *status, int *size) {
744 FILE *fp;
745 long filesize;
746 char *buf;
747
748 fp = fopen(saveDataFile[no], "rb");
749 if (fp == NULL)
750 goto errexit;
751 fseek(fp, 0L, SEEK_END);
752 filesize = ftell(fp);
753 if (filesize == 0)
754 goto errexit;
755
756 buf = (char *)malloc(filesize);
757 if (buf == NULL)
758 goto errexit;
759
760 fseek(fp, 0L, SEEK_SET);
761 fread(buf, filesize, 1, fp);
762 fclose(fp);
763
764 *size = (int)filesize;
765 *status = SAVE_LOADOK;
766 return buf;
767
768 errexit:
769 if (fp != NULL)
770 fclose(fp);
771 *status = SAVE_LOADERR;
772 return NULL;
773 }
774
saveGameData(int no,char * buf,int size)775 static int saveGameData(int no, char *buf, int size) {
776 FILE *fp;
777 int status = SAVE_SAVEOK1;
778
779 backup_oldfile(saveDataFile[no]);
780 fp = fopen(saveDataFile[no],"wb");
781 if (fp == NULL) {
782 return SAVE_SAVEERR;
783 }
784 if (size != fwrite(buf, size, 1, fp)) {
785 status = SAVE_SAVEERR;
786 }
787 fclose(fp);
788 return status;
789 }
790
791 /* ����ե����뤫��β������ɤ߹��� thanx tajiru@wizard */
load_cg_with_file(char * filename,int * status)792 BYTE* load_cg_with_file(char *filename, int *status){
793 int size;
794 FILE *fp;
795 static BYTE *tmp;
796 long filesize;
797
798 *status = 0;
799
800 if (NULL == (fp = fileopen(filename, 'r'))) {
801 *status = SAVE_LOADERR; return NULL;
802 }
803
804 fseek(fp, 0L, SEEK_END);
805 filesize = ftell(fp);
806 if (filesize == 0) {
807 *status = SAVE_LOADERR; return NULL;
808 }
809
810 tmp = (char *)malloc(filesize);
811 if (tmp == NULL) {
812 WARNING("Out of memory\n");
813 *status = SAVE_LOADERR; return NULL;
814 }
815 fseek(fp, 0L, SEEK_SET);
816 size = fread(tmp, 1, filesize,fp);
817
818 if (size != filesize) {
819 *status = SAVE_LOADSHORTAGE;
820 } else {
821 *status = SAVE_LOADOK;
822 }
823
824 fclose(fp);
825 return tmp;
826 }
827