interpreters/nitfol/op_save.c

   1 /*  Nitfol - z-machine interpreter using Glk for output.
   2     Copyright (C) 1999  Evin Robertson
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  17
  18     The author can be reached at nitfol@deja.com
  19 */
  20 #include "nitfol.h"
  21
  22 BOOL savegame(void)
  23 {
  24   BOOL result;
  25   strid_t file;
  26
  27   if(automap_unexplore())
  28     return FALSE;
  29
  30   file = n_file_prompt(fileusage_SavedGame | fileusage_BinaryMode,
  31                        filemode_Write);
  32   if(!file)
  33     return FALSE;
  34
  35   result = savequetzal(file);
  36
  37   glk_stream_close(file, NULL);
  38
  39   return result;
  40 }
  41
  42
  43 void op_save1(void)
  44 {
  45   if(!savegame()) {
  46     mop_skip_branch();
  47   } else {
  48     mop_take_branch();
  49   }
  50 }
  51
  52
  53 void op_save4(void)
  54 {
  55   if(!savegame()) {
  56     mop_store_result(0);
  57   } else {
  58     mop_store_result(1);
  59   }
  60 }
  61
  62
  63 void op_save5(void)
  64 {
  65   unsigned i;
  66   char filename[256];
  67   unsigned length;
  68   strid_t file = NULL;
  69   offset end;
  70   switch(numoperands) {
  71   case 0:
  72     op_save4();
  73     return;
  74   case 1:
  75     n_show_error(E_INSTR, "call save with bad number of operands", numoperands);
  76     mop_store_result(0);
  77     return;
  78   case 2:
  79     file = n_file_prompt(fileusage_Data | fileusage_BinaryMode,
  80                          filemode_Write);
  81     break;
  82   default:
  83     length = LOBYTE(operand[2]);
  84     if(length > 13)
  85       n_show_port(E_INSTR, "save with filename > 13 characters", length);
  86     for(i = 0; i < length; i++)
  87       filename[i] = glk_char_to_upper(LOBYTE(operand[2] + 1 + i));
  88     filename[length] = 0;
  89     file = n_file_name(fileusage_Data | fileusage_BinaryMode,
  90                        filemode_Write, filename);
  91     break;
  92   }
  93   if(!file) {
  94     mop_store_result(0);
  95     return;
  96   }
  97   end = ((offset) operand[0]) + operand[1];
  98   if(end > 65535 || end > total_size) {
  99     n_show_error(E_MEMORY, "attempt to save data out of range", end);
 100     mop_store_result(0);
 101     return;
 102   }
 103
 104   w_glk_put_buffer_stream(file, (char *) z_memory + operand[0], operand[1]);
 105   glk_stream_close(file, NULL);
 106
 107   mop_store_result(1);
 108 }
 109
 110
 111 BOOL restoregame(void)
 112 {
 113   BOOL result;
 114   strid_t file;
 115
 116   if(automap_unexplore())
 117     return FALSE;
 118
 119   file = n_file_prompt(fileusage_SavedGame | fileusage_BinaryMode,
 120                        filemode_Read);
 121   if(!file)
 122     return FALSE;
 123
 124   result = restorequetzal(file);
 125
 126   glk_stream_close(file, NULL);
 127
 128   if(result) {
 129     glui32 wid, hei;
 130     z_find_size(&wid, &hei);
 131     set_header(wid, hei);
 132   }
 133
 134   return result;
 135 }
 136
 137
 138 void op_restore1(void)
 139 {
 140   if(!restoregame())
 141     mop_skip_branch();
 142   else
 143     mop_take_branch();
 144 }
 145
 146 void op_restore4(void)
 147 {
 148   if(!restoregame())
 149     mop_store_result(0);
 150   else
 151     mop_store_result(2);
 152 }
 153
 154
 155 void op_restore5(void)
 156 {
 157   int i;
 158   char filename[256];
 159   int length;
 160   strid_t file;
 161   offset end;
 162   switch(numoperands) {
 163   case 0:
 164     op_restore4();
 165     return;
 166   case 1:
 167     n_show_error(E_INSTR, "call restore with bad number of operands", numoperands);
 168     mop_store_result(0);
 169     return;
 170   case 2:
 171     file = n_file_prompt(fileusage_Data | fileusage_BinaryMode,
 172                          filemode_Read);
 173     break;
 174   default:
 175     length = LOBYTE(operand[2]);
 176     if(length > 13)
 177       n_show_port(E_INSTR, "save with filename > 13 characters", length);
 178     for(i = 0; i < length; i++)
 179       filename[i] = glk_char_to_upper(LOBYTE(operand[2] + 1 + i));
 180     filename[length] = 0;
 181     file = n_file_name(fileusage_Data | fileusage_BinaryMode,
 182                        filemode_Read, filename);
 183   }
 184   if(!file) {
 185     mop_store_result(0);
 186     return;
 187   }
 188   end = ((offset) operand[0]) + operand[1];
 189   if(end > 65535 || end > dynamic_size) {
 190     n_show_error(E_MEMORY, "attempt to restore data out of range", end);
 191     mop_store_result(0);
 192     return;
 193   }
 194
 195   length = glk_get_buffer_stream(file, (char *) z_memory + operand[0],
 196                                  operand[1]);
 197   glk_stream_close(file, NULL);
 198   mop_store_result(length);
 199 }
 200
 201
 202 void op_restart(void)
 203 {
 204   if(automap_unexplore())
 205     return;
 206   z_init(current_zfile);
 207 }
 208
 209
 210 void op_save_undo(void)
 211 {
 212   if(saveundo(TRUE)) {
 213     mop_store_result(1);
 214   } else {
 215     mop_store_result(0);
 216   }
 217 }
 218
 219
 220 void op_restore_undo(void)
 221 {
 222   if(!restoreundo())
 223     mop_store_result(0);
 224 }
 225
 226
 227 void op_quit(void)
 228 {
 229   if(automap_unexplore())
 230     return;
 231   z_close();
 232   /* puts("@quit\n"); */
 233   glk_exit();
 234 }
 235
 236
 237 BOOL check_game_for_save(strid_t gamefile, zword release, const char serial[6],
 238                          zword checksum)
 239 {
 240   int i;
 241   unsigned char header[64];
 242   glk_stream_set_position(gamefile, 0, seekmode_Start);
 243   if(glk_get_buffer_stream(gamefile, (char *) header, 64) != 64)
 244     return FALSE;
 245   if(header[HD_ZVERSION] == 0 || header[HD_ZVERSION] > 8)
 246     return FALSE;
 247   if(MSBdecodeZ(header + HD_RELNUM) != release)
 248     return FALSE;
 249   if(MSBdecodeZ(header + HD_CHECKSUM) != checksum)
 250     return FALSE;
 251   for(i = 0; i < 6; i++) {
 252     if(header[HD_SERNUM + i] != serial[i])
 253       return FALSE;
 254   }
 255   return TRUE;
 256 }