editor/editor.c

Go to the documentation of this file.

#include "editor.h"

editor_map *current_map = NULL;
editor_map *maps = NULL;
int num_maps = 0;
int current_map_num = 0;
int select_x=0, select_y=0;
int cursor_x=0, cursor_y=0;
int edit_brush=1;

//{{{
void initialize_editor(void)
{
    set_num_maps(1);
    set_current_map(0);
}
//}}}
//{{{
void initialize_map(editor_map *M)
{
    memset(M, 0, sizeof(*M));
    strcpy(M->name, "Unnamed");
    strcpy(M->author, "Anonymous");
}
//}}}
//{{{
void cleanup_map(editor_map *M)
{
    if(M->t) free(M->t);
    M->t = NULL;
}
//}}}
//{{{
void set_level_size(int level, int width, int height)
{
    map_square **pos, *alloc_pos;
    size_t size = sizeof(map_square*)*height + sizeof(map_square)*width*height;
    int ii;
    
    if(maps[level].t) free(maps[level].t);
    
    // Pool allocation of all the rows together
    maps[level].t = pos = (map_square**)malloc_throw(size);
    memset(pos, 0, size);
    alloc_pos = (map_square*)(pos + height);
    
    for(ii=0; ii<height; ii++)
    {
        *pos = alloc_pos;
        pos++;
        alloc_pos += width;
    }
    
    maps[level].width = width;
    maps[level].height = height;
}
//}}}
//{{{
void set_num_maps(int n)
{
    int ii;
    for(ii=n; ii<num_maps; ii++) { // Removed maps
        cleanup_map(&maps[ii]);
    }
    maps = (editor_map*)realloc_throw(maps, sizeof(*maps)*n);
    for(ii=num_maps; ii<n; ii++) { // Added maps
        initialize_map(&maps[ii]);
        set_level_size(ii, 20, 11);
    }
    num_maps = n;
    if(current_map_num >= num_maps)
        current_map_num = num_maps-1;
    set_current_map(current_map_num);
}
//}}}
//{{{
void set_current_map(int n)
{
    current_map_num = n;
    current_map = &maps[n];
    draw_level_number();
}
//}}}

//{{{
void enter_edit_state(void)
{
    input_state = editing_state;
    draw_current_map();
}
//}}}
//{{{
void clear_map(void)
{
    int xi, yi;
    
    for(yi=0; yi<FIELD_HEIGHT; yi++)
    for(xi=0; xi<FIELD_WIDTH; xi++)
        current_map->t[yi][xi] = TILE_EMPTY;
}
//}}}
//{{{
void default_map(void)
{
    clear_map();
    current_map->t[0][0] = TILE_KYE;
    current_map->t[0][1] = TILE_DIAMOND;
    strcpy(current_map->name, "Unnamed");
    strcpy(current_map->author, "Anonymous");
    strcpy(current_map->hint, "");
    strcpy(current_map->congrat, "");
    current_map->gamerules = 0;
}
//}}}

#define TILEFIELD_TOP 12
//{{{
void draw_current_map(void)
{
    clear_screen();
    draw_menu_labels();
    draw_map_field();
    draw_line(0, 9, (LCD_WIDTH-1), 9, A_NORMAL);
    draw_editor_brush();
    draw_level_number();
}
//}}}

int scroll_x=0;
int scroll_y=0;

//{{{
void draw_map_field(void)
{
    int xi, yi;
    int xmax = min(VIEWPORT_WIDTH, FIELD_WIDTH-scroll_x);
    int ymax = min(VIEWPORT_HEIGHT, FIELD_HEIGHT-scroll_y);
    
    clear_line_range(10, TILEFIELD_TOP);
    
    // If the field is *smaller*, then it needs a border around it
    if(FIELD_WIDTH < VIEWPORT_WIDTH) {
        draw_line(FIELD_WIDTH*8+1, 10, FIELD_WIDTH*8+1,
                  TILEFIELD_TOP+ymax*8, A_NORMAL);
    }
    if(FIELD_HEIGHT < VIEWPORT_HEIGHT) {
        draw_line(0, TILEFIELD_TOP+ymax*8+1, FIELD_WIDTH*8+1,
                  TILEFIELD_TOP+ymax*8+1, A_NORMAL);
    }
    
    for(xi=0; xi<xmax; xi++)
    for(yi=0; yi<ymax; yi++)
        draw_map_tile(xi+scroll_x, yi+scroll_y);
}
//}}}
//{{{
void draw_map_tile(int x, int y)
{
    int xpos = (x-scroll_x)<<3;
    int ypos = ((y-scroll_y)<<3)+TILEFIELD_TOP;
    
    if(   x<scroll_x || y<scroll_y || x>=scroll_x+VIEWPORT_WIDTH
       || y>=scroll_y+VIEWPORT_HEIGHT) // Off-screen tile
        return;
    
    draw_sprite(tile_sprites[ current_map->t[y][x] ],
                xpos, ypos);
    if( ((x>=select_x && x<=cursor_x) || (x<=select_x && x>=cursor_x)) &&
        ((y>=select_y && y<=cursor_y) || (y<=select_y && y>=cursor_y)) )
        draw_sprite_xor(black_square, xpos, ypos);
}
//}}}
//{{{
void xor_tile(int x, int y)
{
    int xpos = (x-scroll_x)<<3;
    int ypos = ((y-scroll_y)<<3)+TILEFIELD_TOP;
    draw_sprite_xor(black_square, xpos, ypos);
}
//}}}
//{{{
void xor_selected_range(void)
{
    int top, bottom, left, right;
    int xi, yi;
    
    if(cursor_x == select_x && cursor_y == select_y) {
        top = bottom = cursor_y;
        left = right = cursor_x;
    } else {
        get_selected_region(&top, &left, &right, &bottom);
    }
    
    if(top < scroll_y) top = scroll_y;
    if(left < scroll_x) left = scroll_x;
    if(bottom >= scroll_y + VIEWPORT_HEIGHT)
        bottom = scroll_y + VIEWPORT_HEIGHT - 1;
    if(right >= scroll_x + VIEWPORT_WIDTH)
        bottom = scroll_x + VIEWPORT_WIDTH - 1;
    
    for(yi=top; yi<=bottom; yi++)
    for(xi=left; xi<=right; xi++)
    {
        xor_tile(xi, yi);
    }
}
//}}}
//{{{
void draw_editor_brush(void)
{
    draw_sprite(tile_sprites[ edit_brush ], 0, 0);
}
//}}}
//{{{
void draw_level_number(void)
{
    char buf[32];
    sprintf(buf, "%i/%i", current_map_num+1, num_maps);
    clear_rect(130, 0, 20, 9);
    draw_string(buf, 130, 2);
}
//}}}

//{{{
void place_tile(int x, int y, int brush)
{
    int xi, yi;
    if(current_map->t[y][x])
        current_map->t[y][x] = TILE_EMPTY;
    else
    {
        if(brush==TILE_KYE) // Make sure there's only one Kye on the map
                            // at a time
        {
            for(yi=0; yi<FIELD_HEIGHT; yi++)
            for(xi=0; xi<FIELD_WIDTH; xi++)
                if(current_map->t[yi][xi] == TILE_KYE)
                {
                    current_map->t[yi][xi] = TILE_EMPTY;
                    draw_map_tile(xi, yi);
                }
        }
        current_map->t[y][x] = brush;
    }
    draw_map_tile(x, y);
}
//}}}
//{{{
void editing_state(int key)
{
    if(key == KEY_LEFT)                    move_cursor(-1, 0, 0);
    else if(key == KEY_UP)                 move_cursor(0, -1, 0);
    else if(key == KEY_RIGHT)              move_cursor(1, 0, 0);
    else if(key == KEY_DOWN)               move_cursor(0, 1, 0);
    else if(key == (KEY_SHIFT|KEY_LEFT))   move_cursor(-1, 0, 1);
    else if(key == (KEY_SHIFT|KEY_UP))     move_cursor(0, -1, 1);
    else if(key == (KEY_SHIFT|KEY_RIGHT))  move_cursor(1, 0, 1);
    else if(key == (KEY_SHIFT|KEY_DOWN))   move_cursor(0, 1, 1);
    else if(key == (KEY_DIAMOND|KEY_UP))   map_move_up();
    else if(key == (KEY_DIAMOND|KEY_DOWN)) map_move_down();
    else switch(key)
    {
        case KEY_ENTER:
            place_tile(cursor_x, cursor_y, edit_brush);
            break;
        case KEY_STO:
            if(current_map->t[cursor_y][cursor_x])
                edit_brush = current_map->t[cursor_y][cursor_x];
            else
                edit_brush = TILE_WALL_5;
            draw_editor_brush();
            break;
        case KEY_F1:
            enter_palette_state();
            break;
        case KEY_F2: enter_menu_state(0); break;
        case KEY_F3: enter_menu_state(1); break;
        case KEY_F4: enter_menu_state(2); break;
        case KEY_F5: enter_menu_state(3); break;
        case KEY_ESC:
            exit(0);
            break;
        // Shortcuts for things also available from menus
        case '+': map_next(); break;
        case '-': map_previous(); break;
        case 'X': edit_cut();   draw_current_map(); break;
        case 'Y': edit_copy();  draw_current_map(); break;
        case '=': edit_paste(); draw_current_map(); break;
        case 'A': edit_select_all(); draw_current_map(); break;
        case 'N': file_new(); draw_current_map(); break;
        case 'O': file_open(); draw_current_map(); break;
        case 'S': file_save(); draw_current_map(); break;
        case KEY_MODE:
            map_properties(); break;
        case 'H': transform_mirror_horizontal(); draw_current_map(); break;
        case 'V': transform_mirror_vertical();   draw_current_map(); break;
        case 'R': transform_rotate_180();        draw_current_map(); break;
        case 'C': transform_smooth();            draw_current_map(); break;
    }
}
//}}}
//{{{
void move_cursor(int dx, int dy, int shifted)
{
    int new_x = cursor_x + dx;
    int new_y = cursor_y + dy;
    int redraw = 0;
    if(new_x<0 || new_y<0 || new_x>=FIELD_WIDTH || new_y>=FIELD_HEIGHT)
        return;
    
    if(new_x < scroll_x) {
        scroll_x = max(scroll_x-SCROLL_INCR_X, 0);
        redraw = 1;
    }
    if(new_y < scroll_y) {
        scroll_y = max(scroll_y-SCROLL_INCR_Y, 0);
        redraw = 1;
    }
    if(new_x >= scroll_x+VIEWPORT_WIDTH) {
        scroll_x = min(scroll_x+SCROLL_INCR_X, FIELD_WIDTH-VIEWPORT_WIDTH);
        redraw = 1;
    }
    if(new_y >= scroll_y+VIEWPORT_HEIGHT) {
        scroll_y = min(scroll_y+SCROLL_INCR_Y, FIELD_HEIGHT-VIEWPORT_HEIGHT);
        redraw = 1;
    }
    
    if(shifted) {
        if(!redraw) // Don't do a partial-redraw if about to redraw everything
            xor_selected_range();
        cursor_x = new_x;
        cursor_y = new_y;
        if(!redraw)
            xor_selected_range();
    } else {
        if(!redraw)
            xor_selected_range();
        select_x = new_x;
        select_y = new_y;
        cursor_x = new_x;
        cursor_y = new_y;
        if(!redraw)
            xor_selected_range();
    }
    
    if(redraw) {
        draw_map_field();
    }
}
//}}}

---