static void ase_file_write_mask_chunk(FILE *f, Mask *mask)
{
int c, u, v, byte;
const gfx::Rect& bounds(mask->getBounds());
ase_file_write_start_chunk(f, ASE_FILE_CHUNK_MASK);
fputw(bounds.x, f);
fputw(bounds.y, f);
fputw(bounds.w, f);
fputw(bounds.h, f);
ase_file_write_padding(f, 8);
// Name
ase_file_write_string(f, mask->getName().c_str());
// Bitmap
for (v=0; v<bounds.h; v++)
for (u=0; u<(bounds.w+7)/8; u++) {
byte = 0;
for (c=0; c<8; c++)
if (image_getpixel(mask->getBitmap(), u*8+c, v))
byte |= (1<<(7-c));
fputc(byte, f);
}
ase_file_write_close_chunk(f);
}
static void ase_file_write_string(FILE *f, const std::string& string)
{
fputw(string.size(), f);
for (size_t c=0; c<string.size(); ++c)
fputc(string[c], f);
}
static void ase_file_write_close_chunk(FILE *f)
{
int chunk_end = ftell(f);
int chunk_size = chunk_end - chunk_start;
fseek(f, chunk_start, SEEK_SET);
fputl(chunk_size, f);
fputw(chunk_type, f);
fseek(f, chunk_end, SEEK_SET);
}
static void ase_file_write_frame_header(FILE *f, ASE_FrameHeader *frame_header)
{
int pos = frame_header->size;
int end = ftell(f);
frame_header->size = end-pos;
fseek(f, pos, SEEK_SET);
fputl(frame_header->size, f);
fputw(frame_header->magic, f);
fputw(frame_header->chunks, f);
fputw(frame_header->duration, f);
ase_file_write_padding(f, 6);
fseek(f, end, SEEK_SET);
current_frame_header = NULL;
}
static void ase_file_write_layer_chunk(FILE *f, Layer *layer)
{
ase_file_write_start_chunk(f, ASE_FILE_CHUNK_LAYER);
// Flags
fputw(layer->getFlags(), f);
/* layer type */
fputw(layer->is_image() ? 0: (layer->is_folder() ? 1: -1), f);
/* layer child level */
LayerFolder* parent = layer->get_parent();
int child_level = -1;
while (parent != NULL) {
child_level++;
parent = parent->get_parent();
}
fputw(child_level, f);
/* default width & height, and blend mode */
fputw(0, f);
fputw(0, f);
fputw(layer->is_image() ? static_cast<LayerImage*>(layer)->getBlendMode(): 0, f);
/* padding */
ase_file_write_padding(f, 4);
/* layer name */
ase_file_write_string(f, layer->getName());
ase_file_write_close_chunk(f);
/* fop_error(fop, "Layer name \"%s\" child level: %d\n", layer->name, child_level); */
}
/* saves an Animator Pro COL file */
bool save_col_file(const Palette *pal, const char *filename)
{
FILE *f = fopen(filename, "wb");
if (!f)
return false;
fputl(8+768, f); /* file size */
fputw(PROCOL_MAGIC_NUMBER, f); /* file format identifier */
fputw(0, f); /* version file */
uint32_t c;
for (int i=0; i<256; i++) {
c = pal->getEntry(i);
fputc(_rgba_getr(c), f);
fputc(_rgba_getg(c), f);
fputc(_rgba_getb(c), f);
if (ferror(f))
break;
}
fclose(f);
return true;
}
/* write header for relocatable output format */
int h_write(FILE *fp, int tbase, int tlen, int dbase, int dlen,
int bbase, int blen, int zbase, int zlen) {
fputc(1, fp); /* version byte */
fputc(0, fp); /* hi address 0 -> no C64 */
fputc("o", fp);
fputc("6", fp);
fputc("5", fp);
fputc(0, fp); /* format version */
fputw(mode, fp); /* file mode */
fputw(tbase,fp); /* text base */
fputw(tlen,fp); /* text length */
fputw(dbase,fp); /* data base */
fputw(dlen,fp); /* data length */
fputw(bbase,fp); /* bss base */
fputw(blen,fp); /* bss length */
fputw(zbase,fp); /* zerop base */
fputw(zlen,fp); /* zerop length */
o_write(fp);
return 0;
}
/* writes the original color chunk in FLI files for the entire palette "pal" */
static void ase_file_write_color2_chunk(FILE *f, Palette *pal)
{
int c, color;
ase_file_write_start_chunk(f, ASE_FILE_CHUNK_FLI_COLOR2);
fputw(1, f); // number of packets
// First packet
fputc(0, f); // skip 0 colors
fputc(pal->size() == 256 ? 0: pal->size(), f); // number of colors
for (c=0; c<pal->size(); c++) {
color = pal->getEntry(c);
fputc(_rgba_getr(color), f);
fputc(_rgba_getg(color), f);
fputc(_rgba_getb(color), f);
}
ase_file_write_close_chunk(f);
}
static void ase_file_write_header(FILE *f, ASE_Header *header)
{
header->size = ftell(f)-header->pos;
fseek(f, header->pos, SEEK_SET);
fputl(header->size, f);
fputw(header->magic, f);
fputw(header->frames, f);
fputw(header->width, f);
fputw(header->height, f);
fputw(header->depth, f);
fputl(header->flags, f);
fputw(header->speed, f);
fputl(header->next, f);
fputl(header->frit, f);
fputc(header->transparent_index, f);
fputc(header->ignore[0], f);
fputc(header->ignore[1], f);
fputc(header->ignore[2], f);
fputw(header->ncolors, f);
fseek(f, header->pos+header->size, SEEK_SET);
}
int save_board(struct board *cur_board, FILE *fp, int savegame, int version)
{
int num_robots, num_scrolls, num_sensors;
int start_location = ftell(fp);
int board_width = cur_board->board_width;
int board_height = cur_board->board_height;
int board_size = board_width * board_height;
int i;
// Board mode is now ignored, put 0
fputc(0, fp);
// Put overlay mode
if(cur_board->overlay_mode)
{
fputc(0, fp);
fputc(cur_board->overlay_mode, fp);
fputw(cur_board->board_width, fp);
fputw(cur_board->board_height, fp);
save_RLE2_plane(cur_board->overlay, fp, board_size);
fputw(cur_board->board_width, fp);
fputw(cur_board->board_height, fp);
save_RLE2_plane(cur_board->overlay_color, fp, board_size);
}
fputw(board_width, fp);
fputw(board_height, fp);
save_RLE2_plane(cur_board->level_id, fp, board_size);
fputw(board_width, fp);
fputw(board_height, fp);
save_RLE2_plane(cur_board->level_color, fp, board_size);
fputw(board_width, fp);
fputw(board_height, fp);
save_RLE2_plane(cur_board->level_param, fp, board_size);
fputw(board_width, fp);
fputw(board_height, fp);
save_RLE2_plane(cur_board->level_under_id, fp, board_size);
fputw(board_width, fp);
fputw(board_height, fp);
save_RLE2_plane(cur_board->level_under_color, fp, board_size);
fputw(board_width, fp);
fputw(board_height, fp);
save_RLE2_plane(cur_board->level_under_param, fp, board_size);
// Save board parameters
{
size_t len = strlen(cur_board->mod_playing);
fputw((int)len, fp);
if(len)
fwrite(cur_board->mod_playing, len, 1, fp);
}
fputc(cur_board->viewport_x, fp);
fputc(cur_board->viewport_y, fp);
fputc(cur_board->viewport_width, fp);
fputc(cur_board->viewport_height, fp);
fputc(cur_board->can_shoot, fp);
fputc(cur_board->can_bomb, fp);
fputc(cur_board->fire_burn_brown, fp);
fputc(cur_board->fire_burn_space, fp);
fputc(cur_board->fire_burn_fakes, fp);
fputc(cur_board->fire_burn_trees, fp);
fputc(cur_board->explosions_leave, fp);
fputc(cur_board->save_mode, fp);
fputc(cur_board->forest_becomes, fp);
fputc(cur_board->collect_bombs, fp);
fputc(cur_board->fire_burns, fp);
for(i = 0; i < 4; i++)
{
fputc(cur_board->board_dir[i], fp);
}
fputc(cur_board->restart_if_zapped, fp);
fputw(cur_board->time_limit, fp);
if(savegame)
{
size_t len;
fputc(cur_board->last_key, fp);
fputw(cur_board->num_input, fp);
fputw((int)cur_board->input_size, fp);
len = strlen(cur_board->input_string);
fputw((int)len, fp);
if(len)
fwrite(cur_board->input_string, len, 1, fp);
fputc(cur_board->player_last_dir, fp);
len = strlen(cur_board->bottom_mesg);
fputw((int)len, fp);
if(len)
fwrite(cur_board->bottom_mesg, len, 1, fp);
fputc(cur_board->b_mesg_timer, fp);
fputc(cur_board->lazwall_start, fp);
fputc(cur_board->b_mesg_row, fp);
fputc(cur_board->b_mesg_col, fp);
fputw(cur_board->scroll_x, fp);
fputw(cur_board->scroll_y, fp);
fputw(cur_board->locked_x, fp);
fputw(cur_board->locked_y, fp);
}
fputc(cur_board->player_ns_locked, fp);
fputc(cur_board->player_ew_locked, fp);
fputc(cur_board->player_attack_locked, fp);
if(savegame)
{
fputc(cur_board->volume, fp);
fputc(cur_board->volume_inc, fp);
fputc(cur_board->volume_target, fp);
}
// Save robots
num_robots = cur_board->num_robots;
fputc(num_robots, fp);
if(num_robots)
{
struct robot *cur_robot;
for(i = 1; i <= num_robots; i++)
{
cur_robot = cur_board->robot_list[i];
save_robot(cur_robot, fp, savegame, version);
}
}
// Save scrolls
num_scrolls = cur_board->num_scrolls;
putc(num_scrolls, fp);
if(num_scrolls)
{
struct scroll *cur_scroll;
for(i = 1; i <= num_scrolls; i++)
{
cur_scroll = cur_board->scroll_list[i];
save_scroll(cur_scroll, fp, savegame);
}
}
// Save sensors
num_sensors = cur_board->num_sensors;
fputc(num_sensors, fp);
if(num_sensors)
{
struct sensor *cur_sensor;
for(i = 1; i <= num_sensors; i++)
{
cur_sensor = cur_board->sensor_list[i];
save_sensor(cur_sensor, fp, savegame);
}
}
return (ftell(fp) - start_location);
}
static void ase_file_write_cel_chunk(FILE *f, Cel *cel, LayerImage *layer, Sprite *sprite)
{
int layer_index = sprite->layerToIndex(layer);
int cel_type = ASE_FILE_COMPRESSED_CEL;
ase_file_write_start_chunk(f, ASE_FILE_CHUNK_CEL);
fputw(layer_index, f);
fputw(cel->getX(), f);
fputw(cel->getY(), f);
fputc(cel->getOpacity(), f);
fputw(cel_type, f);
ase_file_write_padding(f, 7);
switch (cel_type) {
case ASE_FILE_RAW_CEL: {
Image* image = sprite->getStock()->getImage(cel->getImage());
if (image) {
// Width and height
fputw(image->w, f);
fputw(image->h, f);
// Pixel data
switch (image->getPixelFormat()) {
case IMAGE_RGB:
write_raw_image<RgbTraits>(f, image);
break;
case IMAGE_GRAYSCALE:
write_raw_image<GrayscaleTraits>(f, image);
break;
case IMAGE_INDEXED:
write_raw_image<IndexedTraits>(f, image);
break;
}
}
else {
// Width and height
fputw(0, f);
fputw(0, f);
}
break;
}
case ASE_FILE_LINK_CEL:
// Linked cel to another frame
//fputw(link->frame, f);
fputw(0, f);
break;
case ASE_FILE_COMPRESSED_CEL: {
Image* image = sprite->getStock()->getImage(cel->getImage());
if (image) {
// Width and height
fputw(image->w, f);
fputw(image->h, f);
// Pixel data
switch (image->getPixelFormat()) {
case IMAGE_RGB:
write_compressed_image<RgbTraits>(f, image);
break;
case IMAGE_GRAYSCALE:
write_compressed_image<GrayscaleTraits>(f, image);
break;
case IMAGE_INDEXED:
write_compressed_image<IndexedTraits>(f, image);
break;
}
}
else {
// Width and height
fputw(0, f);
fputw(0, f);
}
break;
}
}
ase_file_write_close_chunk(f);
}
int save_world(struct world *mzx_world, const char *file, int savegame)
{
int i, num_boards;
int gl_rob_position, gl_rob_save_position;
int board_offsets_position, board_begin_position, board_end_position;
int board_size;
unsigned int *size_offset_list;
unsigned char *charset_mem;
unsigned char r, g, b;
struct board *cur_board;
FILE *fp;
int meter_target = 2 + mzx_world->num_boards, meter_curr = 0;
#ifdef CONFIG_DEBYTECODE
if(!savegame)
{
fp = fopen(file, "rb");
if(fp)
{
if(!fseek(fp, 0x1A, SEEK_SET))
{
char tmp[3];
if(fread(tmp, 1, 3, fp) == 3)
{
// If it's not a 2.90 world, abort the save
if(world_magic(tmp) < 0x025A)
{
error("Save would overwrite older world. Aborted.", 0, 1, 1337);
goto exit_close;
}
}
}
fclose(fp);
}
}
#endif
fp = fopen(file, "wb");
if(!fp)
{
error("Error saving world", 1, 8, 0x0D01);
return -1;
}
meter_initial_draw(meter_curr, meter_target, "Saving...");
if(savegame)
{
// Write this MZX's version string
fputs("MZS", fp);
fputc((WORLD_VERSION >> 8) & 0xff, fp);
fputc(WORLD_VERSION & 0xff, fp);
// Write the version of the loaded world for this SAV
fputw(mzx_world->version, fp);
fputc(mzx_world->current_board_id, fp);
}
else
{
