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 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;
}
void change_board_size(struct board *src_board, int new_width, int new_height)
{
int board_width = src_board->board_width;
int board_height = src_board->board_height;
if(new_width == 0)
new_width = 1;
if(new_height == 0)
new_height = 1;
if((board_width != new_width) || (board_height != new_height))
{
char *level_id = src_board->level_id;
char *level_color = src_board->level_color;
char *level_param = src_board->level_param;
char *level_under_id = src_board->level_under_id;
char *level_under_color = src_board->level_under_color;
char *level_under_param = src_board->level_under_param;
char *overlay = src_board->overlay;
char *overlay_color = src_board->overlay_color;
int overlay_mode = src_board->overlay_mode;
int board_size = board_width * board_height;
int new_size = new_width * new_height;
int i;
// Shrinking height? Remove any robots/scrolls/sensors from excess lines
if(new_height < board_height)
{
int offset;
int check_id;
for(offset = new_height * board_width; offset < board_size;
offset++)
{
check_id = level_id[offset];
if(check_id == 122)
clear_sensor_id(src_board, level_param[offset]);
else
if((check_id == 126) || (check_id == 125))
clear_scroll_id(src_board, level_param[offset]);
else
if((check_id == 123) || (check_id == 124))
clear_robot_id(src_board, level_param[offset]);
}
}
if(new_width < board_width)
{
// Take out pieces from each width, then reallocate.
// Only do this for the current height or the new height, whichever is
// less.
int src_offset, dest_offset;
int max_height = new_height;
int check_id, offset;
if(new_height > board_height)
max_height = board_height;
for(i = 0, src_offset = 0, dest_offset = 0; i < max_height;
i++, src_offset += board_width, dest_offset += new_width)
{
// First, remove any robots/scrolls/sensors from excess chunks
for(offset = src_offset + new_width; offset < src_offset + board_width;
offset++)
{
check_id = level_id[offset];
if(check_id == 122)
clear_sensor_id(src_board, level_param[offset]);
else
if((check_id == 126) || (check_id == 125))
clear_scroll_id(src_board, level_param[offset]);
else
if((check_id == 123) || (check_id == 124))
clear_robot_id(src_board, level_param[offset]);
}
memmove(level_id + dest_offset, level_id + src_offset, new_width);
memmove(level_param + dest_offset, level_param + src_offset, new_width);
memmove(level_color + dest_offset, level_color + src_offset, new_width);
memmove(level_under_id + dest_offset,
level_under_id + src_offset, new_width);
memmove(level_under_param + dest_offset,
level_under_param + src_offset, new_width);
memmove(level_under_color + dest_offset,
level_under_color + src_offset, new_width);
}
// Resize layers
src_board->level_id = crealloc(level_id, new_size);
src_board->level_color = crealloc(level_color, new_size);
src_board->level_param = crealloc(level_param, new_size);
src_board->level_under_id = crealloc(level_under_id, new_size);
src_board->level_under_color = crealloc(level_under_color, new_size);
src_board->level_under_param = crealloc(level_under_param, new_size);
level_id = src_board->level_id;
level_color = src_board->level_color;
level_param = src_board->level_param;
level_under_id = src_board->level_under_id;
level_under_color = src_board->level_under_color;
level_under_param = src_board->level_under_param;
// Do the overlay too, if it exists
if(overlay_mode)
{
for(i = 0, src_offset = 0, dest_offset = 0; i < max_height;
i++, src_offset += board_width, dest_offset += new_width)
{
memmove(overlay + dest_offset, overlay + src_offset, new_width);
memmove(overlay_color + dest_offset, overlay_color + src_offset, new_width);
}
src_board->overlay = crealloc(overlay, new_size);
src_board->overlay_color = crealloc(overlay_color, new_size);
overlay = src_board->overlay;
overlay_color = src_board->overlay_color;
}
}
else
if(new_width > board_width)
{
// Reallocate first, then copy over pieces, padding in widths
// Only do this for the current height or the new height, whichever is
// less.
int src_offset, dest_offset;
int max_height = new_height;
int width_difference = new_width - board_width;
if(new_height > board_height)
max_height = board_height;
// Resize first this time.
src_board->level_id = crealloc(level_id, new_size);
src_board->level_color = crealloc(level_color, new_size);
src_board->level_param = crealloc(level_param, new_size);
src_board->level_under_id = crealloc(level_under_id, new_size);
src_board->level_under_color = crealloc(level_under_color, new_size);
src_board->level_under_param = crealloc(level_under_param, new_size);
// Resize the overlay too, if it exists
if(overlay_mode)
{
src_board->overlay = crealloc(overlay, new_size);
src_board->overlay_color = crealloc(overlay_color, new_size);
overlay = src_board->overlay;
overlay_color = src_board->overlay_color;
}
level_id = src_board->level_id;
level_color = src_board->level_color;
level_param = src_board->level_param;
level_under_id = src_board->level_under_id;
level_under_color = src_board->level_under_color;
level_under_param = src_board->level_under_param;
// And start at the end instead of the beginning
src_offset = board_width * (max_height - 1);
dest_offset = new_width * (max_height - 1);
for(i = 0; i < max_height; i++, src_offset -= board_width, dest_offset -= new_width)
{
memmove(level_id + dest_offset, level_id + src_offset, board_width);
memmove(level_param + dest_offset, level_param + src_offset, board_width);
memmove(level_color + dest_offset, level_color + src_offset, board_width);
memmove(level_under_id + dest_offset,
level_under_id + src_offset, board_width);
memmove(level_under_param + dest_offset,
level_under_param + src_offset, board_width);
memmove(level_under_color + dest_offset,
level_under_color + src_offset, board_width);
// And fill in the remainder with blanks
memset(level_id + dest_offset + board_width, 0, width_difference);
memset(level_param + dest_offset + board_width, 0, width_difference);
memset(level_color + dest_offset + board_width, 7, width_difference);
memset(level_under_id + dest_offset + board_width, 0, width_difference);
memset(level_under_param + dest_offset + board_width, 0, width_difference);
memset(level_under_color + dest_offset + board_width, 7, width_difference);
}
src_offset = board_width * (max_height - 1);
dest_offset = new_width * (max_height - 1);
// Do the overlay too, if it exists
if(overlay_mode)
{
for(i = 0; i < max_height; i++, src_offset -= board_width, dest_offset -= new_width)
{
memmove(overlay + dest_offset, overlay + src_offset, board_width);
memmove(overlay_color + dest_offset, overlay_color + src_offset, board_width);
// And fill in the remainder with blanks
memset(overlay + dest_offset + board_width, 32, width_difference);
memset(overlay_color + dest_offset + board_width, 7, width_difference);
}
}
}
else
{
// Width remains the same, just a straight resize
src_board->level_id = crealloc(level_id, new_size);
src_board->level_color = crealloc(level_color, new_size);
src_board->level_param = crealloc(level_param, new_size);
src_board->level_under_id = crealloc(level_under_id, new_size);
src_board->level_under_color = crealloc(level_under_color, new_size);
src_board->level_under_param = crealloc(level_under_param, new_size);
// Resize the overlay too, if it exists
if(overlay_mode)
{
src_board->overlay = crealloc(overlay, new_size);
src_board->overlay_color = crealloc(overlay_color, new_size);
}
level_id = src_board->level_id;
level_color = src_board->level_color;
level_param = src_board->level_param;
level_under_id = src_board->level_under_id;
level_under_color = src_board->level_under_color;
level_under_param = src_board->level_under_param;
overlay = src_board->overlay;
overlay_color = src_board->overlay_color;
}
// Fill in any blanks
if(new_height > board_height)
{
int offset = new_width * board_height;
int size_difference = new_size - offset;
memset(level_id + offset, 0, size_difference);
memset(level_param + offset, 0, size_difference);
memset(level_color + offset, 7, size_difference);
memset(level_under_id + offset, 0, size_difference);
memset(level_under_param + offset, 0, size_difference);
memset(level_under_color + offset, 7, size_difference);
if(overlay_mode)
{
memset(overlay + offset, 32, size_difference);
memset(overlay_color + offset, 7, size_difference);
}
}
// Set the new sizes
src_board->board_width = new_width;
src_board->board_height = new_height;
}
}
