static void clear_board_block(struct board *dest_board, int dest_offset,
int block_width, int block_height)
{
char *level_id = dest_board->level_id;
char *level_param = dest_board->level_param;
char *level_color = dest_board->level_color;
char *level_under_id = dest_board->level_under_id;
char *level_under_param = dest_board->level_under_param;
char *level_under_color = dest_board->level_under_color;
int dest_width = dest_board->board_width;
int dest_skip = dest_width - block_width;
enum thing dest_id;
int dest_param;
int i, i2;
for(i = 0; i < block_height; i++)
{
for(i2 = 0; i2 < block_width; i2++)
{
dest_id = (enum thing)level_id[dest_offset];
if(dest_id != PLAYER)
{
dest_param = level_param[dest_offset];
if(dest_id == SENSOR)
{
clear_sensor_id(dest_board, dest_param);
}
else
if(is_signscroll(dest_id))
{
clear_scroll_id(dest_board, dest_param);
}
else
if(is_robot(dest_id))
{
clear_robot_id(dest_board, dest_param);
}
level_id[dest_offset] = (char)SPACE;
level_param[dest_offset] = 0;
level_color[dest_offset] = 7;
}
level_under_id[dest_offset] = (char)SPACE;
level_under_param[dest_offset] = 0;
level_under_color[dest_offset] = 7;
dest_offset++;
}
dest_offset += dest_skip;
}
}
static void save_mzm_common(struct world *mzx_world, int start_x, int start_y, int width,
int height, int mode, int savegame, void *(*alloc)(size_t, void **), void **storage)
{
int storage_mode = 0;
void *buffer;
unsigned char *bufferPtr;
size_t mzm_size;
int num_robots_alloc = 0;
if(mode)
storage_mode = 1;
if(savegame)
savegame = 1;
// Before saving the MZM, we first calculate its file size
// Then we allocate the memory needed to store the MZM
mzm_size = 20;
// Add on the storage space required to store all tiles
if (storage_mode == 0) {
mzm_size += width * height * 6;
} else {
mzm_size += width * height * 2;
}
if (mode == 0)
{
// Allocate memory for robots
struct board *src_board = mzx_world->current_board;
struct robot **robot_list = src_board->robot_list_name_sorted;
int num_robots_active = src_board->num_robots_active;
int i;
for (i = 0; i < num_robots_active; i++)
{
struct robot *cur_robot = robot_list[i];
if (cur_robot)
{
if (cur_robot->xpos >= start_x && cur_robot->ypos >= start_y &&
cur_robot->xpos < start_x + width && cur_robot->ypos < start_y + height)
{
mzm_size += save_robot_calculate_size(mzx_world, cur_robot,
savegame, WORLD_VERSION);
num_robots_alloc++;
}
}
}
}
// Now, we need to add the total overhead of the zip file.
// File names are all "r##", so the max name length is 3.
mzm_size += zip_bound_total_header_usage(num_robots_alloc, 3);
buffer = alloc(mzm_size, storage);
bufferPtr = buffer;
memcpy(bufferPtr, "MZM3", 4);
bufferPtr += 4;
mem_putw(width, &bufferPtr);
mem_putw(height, &bufferPtr);
// Come back here later if there's robot information
mem_putd(0, &bufferPtr);
mem_putc(0, &bufferPtr);
mem_putc(storage_mode, &bufferPtr);
mem_putc(0, &bufferPtr);
mem_putw(WORLD_VERSION, &bufferPtr);
bufferPtr += 3;
switch(mode)
{
// Board, raw
case 0:
{
struct zip_archive *zp;
struct board *src_board = mzx_world->current_board;
int board_width = src_board->board_width;
char *level_id = src_board->level_id;
char *level_param = src_board->level_param;
char *level_color = src_board->level_color;
char *level_under_id = src_board->level_under_id;
char *level_under_param = src_board->level_under_param;
char *level_under_color = src_board->level_under_color;
int x, y;
int offset = start_x + (start_y * board_width);
int line_skip = board_width - width;
int num_robots = 0;
int robot_numbers[256];
int robot_table_position;
enum thing current_id;
int i;
for(y = 0; y < height; y++)
{
for(x = 0; x < width; x++, offset++)
{
current_id = (enum thing)level_id[offset];
if(is_robot(current_id))
{
// Robot
robot_numbers[num_robots] = level_param[offset];
num_robots++;
mem_putc(current_id, &bufferPtr);
mem_putc(0, &bufferPtr);
mem_putc(level_color[offset], &bufferPtr);
mem_putc(level_under_id[offset], &bufferPtr);
mem_putc(level_under_param[offset], &bufferPtr);
mem_putc(level_under_color[offset], &bufferPtr);
}
else
if((current_id == SENSOR) || is_signscroll(current_id) ||
(current_id == PLAYER))
{
// Sensor, scroll, sign, or player
// Put customblock fake
mem_putc((int)CUSTOM_BLOCK, &bufferPtr);
mem_putc(get_id_char(src_board, offset), &bufferPtr);
mem_putc(get_id_color(src_board, offset), &bufferPtr);
mem_putc(level_under_id[offset], &bufferPtr);
mem_putc(level_under_param[offset], &bufferPtr);
mem_putc(level_under_color[offset], &bufferPtr);
}
else
{
mem_putc(current_id, &bufferPtr);
mem_putc(level_param[offset], &bufferPtr);
mem_putc(level_color[offset], &bufferPtr);
mem_putc(level_under_id[offset], &bufferPtr);
mem_putc(level_under_param[offset], &bufferPtr);
mem_putc(level_under_color[offset], &bufferPtr);
}
}
offset += line_skip;
}
// Get the zip redy 2 go
zp = zip_open_mem_write(buffer, mzm_size);
robot_table_position = bufferPtr - (unsigned char *)buffer;
// Get the zip in position. Won't alter the bufferPtr
zseek(zp, robot_table_position, SEEK_SET);
// Go back to header to put robot table information
if(num_robots)
{
struct robot **robot_list = src_board->robot_list;
char name[4];
bufferPtr = buffer;
bufferPtr += 8;
// Where the robots will be stored
// (not actually necessary anymore)
mem_putd(robot_table_position, &bufferPtr);
// Number of robots
mem_putc(num_robots, &bufferPtr);
// Skip board storage mode
bufferPtr += 1;
// Savegame mode for robots
mem_putc(savegame, &bufferPtr);
// Write robots into the zip
for(i = 0; i < num_robots; i++)
{
sprintf(name, "r%2.2X", i);
// Save each robot
save_robot(mzx_world, robot_list[robot_numbers[i]], zp,
savegame, WORLD_VERSION, name, FPROP_ROBOT, 0, i);
}
}
zip_close(zp, NULL);
break;
}
// Overlay/Vlayer
case 1:
case 2:
{
struct board *src_board = mzx_world->current_board;
int board_width;
int x, y;
int offset;
int line_skip;
char *chars;
char *colors;
if(mode == 1)
{
// Overlay
if(!src_board->overlay_mode)
setup_overlay(src_board, 3);
chars = src_board->overlay;
colors = src_board->overlay_color;
board_width = src_board->board_width;
}
else
{
// Vlayer
chars = mzx_world->vlayer_chars;
colors = mzx_world->vlayer_colors;
board_width = mzx_world->vlayer_width;
}
offset = start_x + (start_y * board_width);
line_skip = board_width - width;
for(y = 0; y < height; y++)
{
for(x = 0; x < width; x++, offset++)
{
mem_putc(chars[offset], &bufferPtr);
mem_putc(colors[offset], &bufferPtr);
}
offset += line_skip;
}
break;
}
// Board, char based
case 3:
{
struct board *src_board = mzx_world->current_board;
int board_width = src_board->board_width;
int x, y;
int offset = start_x + (start_y * board_width);
int line_skip = board_width - width;
for(y = 0; y < height; y++)
{
for(x = 0; x < width; x++, offset++)
{
mem_putc(get_id_char(src_board, offset), &bufferPtr);
mem_putc(get_id_color(src_board, offset), &bufferPtr);
}
offset += line_skip;
}
break;
}
}
}
static int load_mzm_common(struct world *mzx_world, const void *buffer, int file_length, int start_x,
int start_y, int mode, int savegame, char *name)
{
const unsigned char *bufferPtr = buffer;
char magic_string[5];
int storage_mode;
int width, height;
int savegame_mode;
int num_robots;
int robots_location;
int data_start;
int expected_data_size;
// MegaZeux 2.83 is the last version that won't save the ver,
// so if we don't have a ver, just act like it's 2.83
int mzm_world_version = 0x0253;
if (file_length < 4)
goto err_invalid;
memcpy(magic_string, bufferPtr, 4);
bufferPtr += 4;
magic_string[4] = 0;
if(!strncmp(magic_string, "MZMX", 4))
{
// An MZM1 file is always storage mode 0
storage_mode = 0;
savegame_mode = 0;
num_robots = 0;
robots_location = 0;
if (file_length < 16) goto err_invalid;
width = mem_getc(&bufferPtr);
height = mem_getc(&bufferPtr);
bufferPtr += 10;
}
else
if(!strncmp(magic_string, "MZM2", 4))
{
if (file_length < 16) goto err_invalid;
width = mem_getw(&bufferPtr);
height = mem_getw(&bufferPtr);
robots_location = mem_getd(&bufferPtr);
num_robots = mem_getc(&bufferPtr);
storage_mode = mem_getc(&bufferPtr);
savegame_mode = mem_getc(&bufferPtr);
bufferPtr += 1;
}
else
if(!strncmp(magic_string, "MZM3", 4))
{
if (file_length < 20) goto err_invalid;
// MZM3 is like MZM2, except the robots are stored as source code if
// savegame_mode is 0 and version >= VERSION_PROGRAM_SOURCE.
width = mem_getw(&bufferPtr);
height = mem_getw(&bufferPtr);
robots_location = mem_getd(&bufferPtr);
num_robots = mem_getc(&bufferPtr);
storage_mode = mem_getc(&bufferPtr);
savegame_mode = mem_getc(&bufferPtr);
mzm_world_version = mem_getw(&bufferPtr);
bufferPtr += 3;
}
else
goto err_invalid;
data_start = bufferPtr - (const unsigned char *)buffer;
expected_data_size = (width * height) * (storage_mode ? 2 : 6);
// Validate
if(
(savegame_mode > 1) || (savegame_mode < 0) // Invalid save mode
|| (storage_mode > 1) || (storage_mode < 0) // Invalid storage mode
|| (file_length - data_start < expected_data_size) // not enough space to store data
|| (file_length < robots_location) // The end of file is before the robot offset
|| (robots_location && (expected_data_size + data_start > robots_location)) // robots offset before data end
)
goto err_invalid;
// If the mzm version is newer than the MZX version, show a message and continue.
if(mzm_world_version > WORLD_VERSION)
{
error_message(E_MZM_FILE_VERSION_TOO_RECENT, mzm_world_version, name);
}
// If the MZM is a save MZM but we're not loading at runtime, show a message and continue.
if(savegame_mode > savegame)
{
error_message(E_MZM_FILE_FROM_SAVEGAME, 0, name);
}
switch(mode)
{
// Write to board
case 0:
{
struct board *src_board = mzx_world->current_board;
int board_width = src_board->board_width;
int board_height = src_board->board_height;
int effective_width = width;
int effective_height = height;
int file_line_skip;
int line_skip;
int x, y;
int offset = start_x + (start_y * board_width);
char *level_id = src_board->level_id;
char *level_param = src_board->level_param;
char *level_color = src_board->level_color;
char *level_under_id = src_board->level_under_id;
char *level_under_param = src_board->level_under_param;
char *level_under_color = src_board->level_under_color;
enum thing src_id;
// Clip
if((effective_width + start_x) >= board_width)
effective_width = board_width - start_x;
if((effective_height + start_y) >= board_height)
effective_height = board_height - start_y;
line_skip = board_width - effective_width;
switch(storage_mode)
{
case 0:
{
// Board style, write as is
enum thing current_id;
int current_robot_loaded = 0;
int robot_x_locations[256];
int robot_y_locations[256];
int width_difference;
int i;
width_difference = width - effective_width;
for(y = 0; y < effective_height; y++)
{
for(x = 0; x < effective_width; x++, offset++)
{
current_id = (enum thing)mem_getc(&bufferPtr);
if(current_id >= SENSOR)
{
if(is_robot(current_id))
{
robot_x_locations[current_robot_loaded] = x + start_x;
robot_y_locations[current_robot_loaded] = y + start_y;
current_robot_loaded++;
}
// Wipe a bunch of crap we don't want in MZMs with spaces
else
current_id = 0;
}
src_id = (enum thing)level_id[offset];
if(src_id >= SENSOR)
{
if(src_id == SENSOR)
clear_sensor_id(src_board, level_param[offset]);
else
if(is_signscroll(src_id))
clear_scroll_id(src_board, level_param[offset]);
else
if(is_robot(src_id))
clear_robot_id(src_board, level_param[offset]);
}
// Don't allow the player to be overwritten
if(src_id != PLAYER)
{
level_id[offset] = current_id;
level_param[offset] = mem_getc(&bufferPtr);
level_color[offset] = mem_getc(&bufferPtr);
level_under_id[offset] = mem_getc(&bufferPtr);
level_under_param[offset] = mem_getc(&bufferPtr);
level_under_color[offset] = mem_getc(&bufferPtr);
// We don't want this on the under layer, thanks
if(level_under_id[offset] >= SENSOR)
{
level_under_id[offset] = 0;
level_under_param[offset] = 0;
level_under_color[offset] = 7;
}
}
else
{
bufferPtr += 5;
}
}
offset += line_skip;
// Gotta run through and mark the next robots to be skipped
for(i = 0; i < width_difference; i++)
{
current_id = (enum thing)mem_getc(&bufferPtr);
bufferPtr += 5;
if(is_robot(current_id))
{
robot_x_locations[current_robot_loaded] = -1;
current_robot_loaded++;
}
}
}
for(i = current_robot_loaded; i < num_robots; i++)
{
robot_x_locations[i] = -1;
}
if(num_robots)
{
struct zip_archive *zp;
unsigned int file_id;
unsigned int robot_id;
int result;
struct robot *cur_robot;
int current_x, current_y;
int offset;
int new_param;
int robot_calculated_size = 0;
int robot_partial_size = 0;
int current_position;
int dummy = 0;
// We suppress the errors that will generally occur here and barely
// error check the zip functions. Why? This needs to run all the way
// through, regardless of whether it finds errors. Otherwise, we'll
// get invalid robots with ID=0 littered around the board.
set_error_suppression(E_WORLD_ROBOT_MISSING, 1);
set_error_suppression(E_BOARD_ROBOT_CORRUPT, 1);
// Reset the error count.
get_and_reset_error_count();
if(mzm_world_version <= WORLD_LEGACY_FORMAT_VERSION)
{
robot_partial_size =
legacy_calculate_partial_robot_size(savegame_mode,
mzm_world_version);
bufferPtr = buffer;
bufferPtr += robots_location;
zp = NULL;
}
else
{
zp = zip_open_mem_read(buffer, file_length);
zip_read_directory(zp);
assign_fprops(zp, 1);
}
// If we're loading a "runtime MZM" then it means that we're loading
// bytecode. And to do this we must both be in-game and must be
// running the same version this was made in. But since loading
// dynamically created MZMs in the editor is still useful, we'll just
// dummy out the robots.
if((savegame_mode > savegame) ||
(WORLD_VERSION < mzm_world_version))
{
dummy = 1;
}
for(i = 0; i < num_robots; i++)
{
cur_robot = cmalloc(sizeof(struct robot));
current_x = robot_x_locations[i];
current_y = robot_y_locations[i];
// TODO: Skipped legacy robots aren't checked for, so the loaded
// chars for dummy robots on clipped MZMs might be off. This
// shouldn't matter too often though.
if(mzm_world_version <= WORLD_LEGACY_FORMAT_VERSION)
{
create_blank_robot(cur_robot);
current_position = bufferPtr - (const unsigned char *)buffer;
// If we fail, we have to continue, or robots won't be dummied
// correctly. In this case, seek to the end.
if(current_position + robot_partial_size <= file_length)
{
robot_calculated_size =
legacy_load_robot_calculate_size(bufferPtr, savegame_mode,
mzm_world_version);
if(current_position + robot_calculated_size <= file_length)
{
legacy_load_robot_from_memory(mzx_world, cur_robot, bufferPtr,
savegame_mode, mzm_world_version, (int)current_position);
}
else
{
bufferPtr = (const unsigned char*)buffer + file_length;
dummy = 1;
}
}
else
{
bufferPtr = (const unsigned char*)buffer + file_length;
dummy = 1;
}
bufferPtr += robot_calculated_size;
}
// Search the zip until a robot is found.
else do
{
result = zip_get_next_prop(zp, &file_id, NULL, &robot_id);
if(result != ZIP_SUCCESS)
{
// We have to continue, or we'll get screwed up robots.
create_blank_robot(cur_robot);
create_blank_robot_program(cur_robot);
dummy = 1;
break;
}
else
if(file_id != FPROP_ROBOT || (int)robot_id < i)
{
// Not a robot or is a skipped robot
zip_skip_file(zp);
}
else
if((int)robot_id > i)
{
// There's a robot missing.
create_blank_robot(cur_robot);
create_blank_robot_program(cur_robot);
break;
}
else
{
load_robot(mzx_world, cur_robot, zp, savegame_mode,
mzm_world_version);
break;
}
}
while(1);
if(dummy)
{
// Unfortunately, getting the actual character for the robot is
// kind of a lot of work right now. We have to load it then
// throw it away.
// If this is from a futer version and the format changed, we'll
// just end up with an 'R' char, but this shouldn't happen again
if(current_x != -1)
{
offset = current_x + (current_y * board_width);
level_id[offset] = CUSTOM_BLOCK;
level_param[offset] = cur_robot->robot_char;
}
clear_robot(cur_robot);
}
else
{
cur_robot->world_version = mzx_world->version;
cur_robot->xpos = current_x;
cur_robot->ypos = current_y;
#ifdef CONFIG_DEBYTECODE
// If we're loading source code at runtime, we need to compile it
if(savegame_mode < savegame)
prepare_robot_bytecode(mzx_world, cur_robot);
#endif
if(current_x != -1)
{
new_param = find_free_robot(src_board);
offset = current_x + (current_y * board_width);
if(new_param != -1)
{
if((enum thing)level_id[offset] != PLAYER)
{
add_robot_name_entry(src_board, cur_robot,
cur_robot->robot_name);
src_board->robot_list[new_param] = cur_robot;
cur_robot->xpos = current_x;
cur_robot->ypos = current_y;
level_param[offset] = new_param;
}
else
{
clear_robot(cur_robot);
}
}
else
{
clear_robot(cur_robot);
level_id[offset] = 0;
level_param[offset] = 0;
level_color[offset] = 7;
}
}
else
{
clear_robot(cur_robot);
}
}
}
if(mzm_world_version > WORLD_LEGACY_FORMAT_VERSION)
{
zip_close(zp, NULL);
}
// If any errors were encountered, report
if(get_and_reset_error_count())
goto err_robots;
}
break;
}
case 1:
{
// Compact style; expand to customblocks
// Board style, write as is
file_line_skip = (width - effective_width) * 2;
for(y = 0; y < effective_height; y++)
{
for(x = 0; x < effective_width; x++, offset++)
{
src_id = (enum thing)level_id[offset];
if(src_id == SENSOR)
clear_sensor_id(src_board, level_param[offset]);
else
if(is_signscroll(src_id))
clear_scroll_id(src_board, level_param[offset]);
else
if(is_robot(src_id))
clear_robot_id(src_board, level_param[offset]);
// Don't allow the player to be overwritten
if(src_id != PLAYER)
{
level_id[offset] = CUSTOM_BLOCK;
level_param[offset] = mem_getc(&bufferPtr);
level_color[offset] = mem_getc(&bufferPtr);
level_under_id[offset] = 0;
level_under_param[offset] = 0;
level_under_color[offset] = 0;
}
else
{
bufferPtr += 2;
}
}
offset += line_skip;
bufferPtr += file_line_skip;
}
break;
}
}
break;
}
// Overlay/vlayer
case 1:
case 2:
{
struct board *src_board = mzx_world->current_board;
int dest_width = src_board->board_width;
int dest_height = src_board->board_height;
char *dest_chars;
char *dest_colors;
int effective_width = width;
int effective_height = height;
int file_line_skip;
int line_skip;
int x, y;
int offset;
if(mode == 1)
{
// Overlay
if(!src_board->overlay_mode)
setup_overlay(src_board, 3);
dest_chars = src_board->overlay;
dest_colors = src_board->overlay_color;
dest_width = src_board->board_width;
dest_height = src_board->board_height;
}
else
{
// Vlayer
dest_chars = mzx_world->vlayer_chars;
dest_colors = mzx_world->vlayer_colors;
dest_width = mzx_world->vlayer_width;
dest_height = mzx_world->vlayer_height;
}
offset = start_x + (start_y * dest_width);
// Clip
if((effective_width + start_x) >= dest_width)
effective_width = dest_width - start_x;
if((effective_height + start_y) >= dest_height)
effective_height = dest_height - start_y;
line_skip = dest_width - effective_width;
switch(storage_mode)
{
case 0:
{
// Coming from board storage; for now use param as char
file_line_skip = (width - effective_width) * 6;
for(y = 0; y < effective_height; y++)
{
for(x = 0; x < effective_width; x++, offset++)
{
// Skip ID
bufferPtr += 1;
dest_chars[offset] = mem_getc(&bufferPtr);
dest_colors[offset] = mem_getc(&bufferPtr);
// Skip under parts
bufferPtr += 3;
}
offset += line_skip;
bufferPtr += file_line_skip;
}
break;
}
case 1:
{
// Coming from layer storage; transfer directly
file_line_skip = (width - effective_width) * 2;
for(y = 0; y < effective_height; y++)
{
for(x = 0; x < effective_width; x++, offset++)
{
dest_chars[offset] = mem_getc(&bufferPtr);
dest_colors[offset] = mem_getc(&bufferPtr);
}
offset += line_skip;
bufferPtr += file_line_skip;
}
break;
}
}
break;
}
}
// Clear none of the validation error suppressions:
// 1) in combination with poor practice, they could lock MZX,
// 2) they'll get reset after reloading the world.
return 0;
err_robots:
// The main file loaded fine, but there was a problem handling robots
error_message(E_MZM_ROBOT_CORRUPT, 0, name);
return 0;
err_invalid:
error_message(E_MZM_FILE_INVALID, 0, name);
return -1;
}
