Free Hero Mesh

static Uint8 replay_speed;
static Uint8 replay_time;
static Uint8 solved;
static Uint8 inserting,saved_inserting;
static sqlite3_stmt*autowin;
static size_t dum_size; // not used by Free Hero Mesh, but needed by some C library functions.

typedef struct {
  char*data;
  size_t size;
  Uint16 mark,pos;
} SaveState;

static SaveState savestates[8];
static Uint8 has_savestates;

int encode_move(FILE*fp,MoveItem v) {
  // Encodes a single move and writes the encoded move to the file.
  // Returns the number of bytes of the encoded move.
  if(v>=8 && v<256) {
    fputc(v,fp);
    return 1;
  } else if(v>=0x8000 && v<=0x8FFF) {

  SDL_LockSurface(screen);
  draw_text(0,40,buf,0xF0,0xF1);
  SDL_UnlockSurface(screen);
  SDL_Flip(screen);
}

static void save_replay(void) {
  int i;
  unsigned char*buf=0;
  size_t sz=0;
  FILE*fp;
  if(solution_replay || !replay_list || !replay_count) return;
  if(gameover==1) solved=1;
  fp=open_memstream((char**)&buf,&sz);
  if(!fp) fatal("Allocation failed\n");

      fputc(best_score>>24,fp);
    }
  }
  if(replay_mark) {
    fputc(0x42,fp);
    fputc(replay_mark,fp);
    fputc(replay_mark>>8,fp);
  }
  if(has_savestates) for(i=0;i<8;i++) if(savestates[i].data) {
    fputc(i+0x30,fp);
    fputs(savestates[i].data,fp);
    fputc(0,fp);
    if(savestates[i].mark || savestates[i].pos) {
      fputc(i+0xB0,fp);
      fputc(savestates[i].mark,fp);
      fputc(savestates[i].mark>>8,fp);
      fputc(savestates[i].pos,fp);
      fputc(savestates[i].pos>>8,fp);
    }
  }
  fclose(fp);
  if(!buf) fatal("Allocation failed\n");
  write_userstate(FIL_LEVEL,level_id,sz,buf);
  free(buf);
}

static void load_replay(void) {
  FILE*fp=0;
  unsigned char*buf=0;
  long sz;
  int i,j;
  free(replay_list);
  replay_list=0;
  replay_count=replay_mark=replay_size=0;
  free(best_list);
  best_list=0;
  if(has_savestates) {
    for(i=0;i<8;i++) {
      free(savestates[i].data);
      savestates[i].data=0;
      savestates[i].size=0;
      savestates[i].mark=savestates[i].pos=0;
    }
    has_savestates=0;
  }
  if(solution_replay) {
    gameover_score=NO_SCORE;
    if(buf=read_lump(FIL_SOLUTION,level_id,&sz)) {
      fp=fmemopen(buf,sz,"r");
      if(!fp) fatal("Allocation failed\n");
      // Solution format: version (16-bits), flag (8-bits), score (32-bits), user name (null-terminated), timestamp (64-bits), move list
      if(sz>3) {

          if(replay_list) goto skip;
          decode_move_list(fp);
          break;
        case 0x02: // Best list
          if(best_list) goto skip;
          dum_size=0;
          getdelim(&best_list,&dum_size,0,fp);
          break;
        case 0x30 ... 0x37: // Save states
          if(savestates[i&7].data) goto skip;
          getdelim(&savestates[i&7].data,&savestates[i&7].size,0,fp);
          has_savestates=1;
          break;
        case 0x41: // Solved version
          i=fgetc(fp); i|=fgetc(fp)<<8;
          if(i==level_version) solved=1;
          break;
        case 0x42: // Mark
          replay_mark=fgetc(fp);
          replay_mark|=fgetc(fp)<<8;
          break;
        case 0x81: // Best score
          best_score=fgetc(fp);
          best_score|=fgetc(fp)<<8;
          best_score|=fgetc(fp)<<16;
          best_score|=fgetc(fp)<<24;
          break;
        case 0xB0 ... 0xB7: // Save states
          savestates[i&7].mark=fgetc(fp);
          savestates[i&7].mark|=fgetc(fp)<<8;
          savestates[i&7].pos=fgetc(fp);
          savestates[i&7].pos|=fgetc(fp)<<8;
          break;
        default: skip:
          if(i<0x40) {
            while(fgetc(fp)>0);
          } else if(i<0x80) {
            fgetc(fp); fgetc(fp);
          } else if(i<0xC0) {
            for(i=0;i<4;i++) fgetc(fp);

        best_score=NO_SCORE;
      }
    }
  }
  if(fp) fclose(fp);
  free(buf);
}

static int exchange_state(int slot,int how) {
  // Return value is replay position of save state (-1 if error)
  // slot = 0 to 7
  // how = 'l' (load), 's' (save), 'x' (exchange)
  SaveState*ss=savestates+slot;
  SaveState v=*ss;
  FILE*fp;
  if(how!='s' && !v.data) {
    screen_message("Nonexisting save state");
    return -1;
  }
  if(how!='l') {
    if(ss->data) {
      if(how=='s') free(ss->data);
      ss->data=0;
      ss->size=0;
    }
    if(replay_count) {
      has_savestates=1;
      fp=open_memstream(&ss->data,&ss->size);
      if(!fp) fatal("Allocation failed\n");
      encode_move_list(fp);
      fputc(0,fp);
      fclose(fp);
    }
    ss->mark=replay_mark;
    ss->pos=replay_pos;
  }
  if(how!='s') {
    fp=fmemopen(v.data,v.size,"r");
    if(!fp) fatal("Allocation failed\n");
    decode_move_list(fp);
    fclose(fp);
    if(how=='x') free(v.data);
    replay_mark=v.mark;
  }
  return v.pos;
}

static void begin_level(int id) {
  const char*t;
  replay_time=0;
  if(replay_count) save_replay();
  inputs_count=0;
  replay_pos=0;

      return prev;
    case 'go': // Select level
      begin_level(number);
      return 1;
    case 'lo': // Locate me
      locate_me(number&63?:64,number/64?:64);
      return prev;
    case 'ls': // Load state
      if(solution_replay) {
        screen_message("You cannot load states during solution replay");
        return -3;
      }
      number=exchange_state(number&7,'l');
      if(number<0) return -3;
      goto restart;
    case 'mi': // Move list import
      if(argc<2 || solution_replay) break;
      if(replay_pos) begin_level(level_id);
      do_import_moves(sqlite3_column_text(args,1));
      return 1;
    case 'ml': // Move list load
      if(argc<2 || solution_replay) break;

    case 'rs': // Replay speed
      number+=replay_speed;
      // fall through
    case 'rS': // Replay speed (absolute)
      if(number<1) number=1; else if(number>255) number=255;
      replay_speed=number;
      return prev;
    case 'ss': // Save state
      exchange_state(number&7,'s');
      return prev;
    case 'xs': // Exchange state
      if(solution_replay) {
        screen_message("You cannot load states during solution replay");
        return -3;
      }
      number=exchange_state(number&7,'x');
      if(number<0) return -3;
      goto restart;
    case 'xy': // Coordinate input
      if(argc<3 || !has_xy_input) break;
      argc=sqlite3_column_int(args,1);
      number=sqlite3_column_int(args,2);
      if(argc<1 || argc>pfwidth || number<1 || number>pfheight) return 0;
      number=(number-1)|((argc-1)<<6)|0x8000;
      goto play;