engine/game.c

Go to the documentation of this file.

#include "engine.h"

#define MONSTMOVETIME ((current_map.gamerules==RULESET_KYE92)?(3):(6))
engine_map current_map;
int player_x, player_y;
int scroll_x=0, scroll_y=0;
int current_level_num = 0;
int advance_to_level = 0;
int round;
int num_diamonds;
int have_moved = 0;

#if 0
//{{{
void game_loop(void)
{
    draw_current_map();
    
    OSFreeTimer(USER_TIMER);
    OSRegisterTimer(USER_TIMER, DELAY_TIME);
    
    do
    {
        if(!delay_and_input())
            return;
        clear_effects();
        if(current_map.gamerules == RULESET_DCKYE)
            turn_sliders();
        set_magnet_skips();
        
        advance();
        round++;
        
        if(advance_to_level != current_level_num)
        {
            if(!level_advance(advance_to_level))
                return;
        }
    } while(1);
}
//}}}
//{{{
int delay_and_input(void)
{
    short input;
    short early_exit = 0;
    int have_received_input = 0;
    static int previous_move = 0;
    static int block_move = 0;
    
    have_moved = 0;
    
    if(OSTimerCurVal(USER_TIMER) > 5) {
        OSFreeTimer(USER_TIMER);
        OSRegisterTimer(USER_TIMER, DELAY_TIME);
    }
    
    do {
        GrayIdle();
        
        if(have_moved==0) {
            input = poll_char() & ~0x800;
            if(!input) continue;
            have_received_input = 1;
            if(input != previous_move) {
                previous_move = input;
                block_move = MOVE_DELAY;
                if(!make_move(input))
                    return 0;
                else
                    early_exit = 1;
            }
            else if(!block_move) {
                if(!make_move(input)) return 0;
                else early_exit = 1;
            }
        }
        if(early_exit && OSTimerCurVal(USER_TIMER)+1 < DELAY_TIME)
            break;
    } while(!OSTimerExpired(USER_TIMER));
    OSFreeTimer(USER_TIMER);
    
    if(have_moved == 0 && block_move==0) previous_move = 0;
    if(have_received_input == 0) {
        previous_move = 0;
        block_move = 0;
    }
    if(block_move) block_move--;

    flush_input();
    
    // Register timer for *next* cycle
    OSRegisterTimer(USER_TIMER, DELAY_TIME);
    
    return 1;
}
//}}}
#else
//{{{
void game_loop(void)
{
    int input;
    
    draw_current_map();
    
    OSFreeTimer(USER_TIMER);
    OSRegisterTimer(USER_TIMER, DELAY_TIME);
    
    do
    {
        have_moved = 0;
        input = read_char_with_timeout() & ~0x800;
        if(input) {
            if( make_move(input) == 0 )
                return;
        }
        
        OSTimerRestart(USER_TIMER);
        
        clear_effects();
        set_magnet_skips();
        advance();
        round++;
        
        if(advance_to_level != current_level_num) {
            if(!level_advance(advance_to_level))
                return;
        }
    } while(1);
}
//}}}
#endif

//{{{
int level_advance(int level)
{
    int input;
    do {
        current_level_num = level;
        if(!load_kyelib(current_level_num))
            return 0;
        
        input = show_splash();
        if(input=='+') {
            level++;
        } else if(input=='-') {
            if(current_level_num==0)
                break;
            level = current_level_num-1;
        } else {
            break;
        }
    } while(1);
    advance_to_level = level;
    begin_level();
    draw_current_map();
    return 1;
}
//}}}

//{{{
int make_move(int key)
{
    if(have_moved) return 1;
    have_moved = 1;
    if     (key == KEY_RIGHT) kye_move(1, 0);
    else if(key == KEY_DOWN) kye_move(0, 1);
    else if(key == KEY_LEFT) kye_move(-1, 0);
    else if(key == KEY_UP)   kye_move(0, -1);
    else if(key == KEY_ESC)  return 0;
    else if(key == KEY_F1 || key == KEY_CLEAR) restart_level();
    else if(key == '+')      advance_to_level = current_level_num + 1;
    else if(key == '-') {
        if(current_level_num > 0)
            advance_to_level = current_level_num - 1;
        else restart_level();
    } else if(key == KEY_F2) {
        if( strlen(current_map.hint)>0 )
            message(current_map.hint);
        draw_current_map();
    }
    
    return 1;
}
//}}}

//{{{
void kye_move(int dx, int dy)
{
    int x = player_x+dx, y = player_y+dy;
    int block;
    if(!is_in_bounds(x, y))
        return;
    block = current_map.t[y][x].v;
    if(block==TILE_DIAMOND) {
        current_map.t[y][x].v = TILE_EMPTY;
        check_diamonds();
    } else if(block==TILE_EMPTY) {
        ;
    } else if(block==TILE_FUZZY) {
        current_map.t[y][x].v = TILE_EMPTY;
    } else if(can_shove(x, y, dx, dy)) {
        shove(x, y, dx, dy);
    } else if(block==DOOR_EW) {
        if(dx!=1) return;
    } else if(block==DOOR_WE) {
        if(dx!=-1) return;
    } else if(block==DOOR_NS) {
        if(dy!=1) return;
    } else if(block==DOOR_SN) {
        if(dy!=-1) return;
    } else {
        return;
    }
    
    if(current_map.t[player_y][player_x].v != TILE_KYE)
    {
        ;
    }
    else if(dx && is_in_bounds(player_x-dx, player_y) &&
       (current_map.t[player_y][player_x-dx].v == TILE_STICKY_EW ||
        current_map.t[player_y][player_x-dx].v == TILE_MAGNET_EW) )
    {
        current_map.t[player_y][player_x].v =
            current_map.t[player_y][player_x-dx].v;
        current_map.t[player_y][player_x-dx].v = TILE_EMPTY;
        draw_map_tile(player_x-dx, player_y);
        if(can_shove(player_x-dx-dx, player_y, dx, 0))
            shove(player_x-dx-dx, player_y, dx, 0);
    }
    else if(dy && is_in_bounds(player_x, player_y-dy) &&
            (current_map.t[player_y-dy][player_x].v == TILE_STICKY_NS ||
             current_map.t[player_y-dy][player_x].v == TILE_MAGNET_NS) )
    {
        current_map.t[player_y][player_x].v =
            current_map.t[player_y-dy][player_x].v;
        current_map.t[player_y-dy][player_x].v = TILE_EMPTY;
        draw_map_tile(player_x, player_y-dy);
        if(can_shove(player_x, player_y-dy-dy, 0, dy))
            shove(player_x, player_y-dy-dy, 0, dy);
    } else {
        current_map.t[player_y][player_x].v = TILE_EMPTY;
    }
    player_x += dx;
    player_y += dy;
    draw_map_tile(player_x-dx, player_y-dy);
    if(current_map.t[player_y][player_x].v==TILE_EMPTY)
        current_map.t[player_y][player_x].v = TILE_KYE;
    if(current_map.t[player_y][player_x].effect.duration > 0) {
        current_map.t[player_y][player_x].effect.sprite = EFFECT_NONE;
        current_map.t[player_y][player_x].effect.duration = 0;
    }
    draw_map_tile(player_x, player_y);
    scroll_viewport();
}
//}}}
//{{{
void scroll_viewport(void)
{
    int new_x=scroll_x, new_y=scroll_y;
    
    if(player_x < scroll_x+EDGE_X)
        new_x = max(scroll_x-SCROLL_INCR_X, 0);
    if(player_y < scroll_y+EDGE_Y)
        new_y = max(scroll_y-SCROLL_INCR_Y, 0);
    if(player_x+EDGE_X >= scroll_x+VIEWPORT_WIDTH)
        new_x = min(scroll_x+SCROLL_INCR_X, FIELD_WIDTH-VIEWPORT_WIDTH);
    if(player_y+EDGE_Y >= scroll_y+VIEWPORT_HEIGHT)
        new_y = min(scroll_y+SCROLL_INCR_Y, FIELD_HEIGHT-VIEWPORT_HEIGHT);
    
    if(new_x != scroll_x || new_y != scroll_y) {
        scroll_x = new_x;
        scroll_y = new_y;
        draw_current_map();
    }
}
//}}}
//{{{
void center_viewport(void)
{
    int new_x, new_y;
    
    new_x = player_x - VIEWPORT_WIDTH/2;
    new_y = player_y - VIEWPORT_HEIGHT/2;
    if(new_x+VIEWPORT_WIDTH>=FIELD_WIDTH) new_x=FIELD_WIDTH-VIEWPORT_WIDTH;
    if(new_y+VIEWPORT_HEIGHT>=FIELD_HEIGHT) new_y=FIELD_HEIGHT-VIEWPORT_HEIGHT;
    if(new_x < 0) new_x = 0;
    if(new_y < 0) new_y = 0;
    
    scroll_x = new_x;
    scroll_y = new_y;
}
//}}}

//{{{
static inline void _drawtile(int x, int y)
{
    int xpos = (x-scroll_x)<<3;
    int ypos = (y-scroll_y)<<3;
    
    if(x==player_x && y==player_y)
        draw_sprite(tile_sprites[ TILE_KYE ], xpos, ypos);
    else if(current_map.t[y][x].effect.sprite == EFFECT_NONE)
        draw_sprite(tile_sprites[ current_map.t[y][x].v ], xpos, ypos);
    else
        draw_sprite(effects[ current_map.t[y][x].effect.sprite ], xpos, ypos);

}
//}}}
//{{{
void draw_current_map(void)
{
    int xi, yi;
    int xmax, ymax;
    
    clear_screen();
    
    xmax = scroll_x + VIEWPORT_WIDTH;
    ymax = scroll_y + VIEWPORT_HEIGHT;
    if(xmax > FIELD_WIDTH) xmax = FIELD_WIDTH;
    if(ymax > FIELD_HEIGHT) ymax = FIELD_HEIGHT;
    
    // If the field is *smaller*, then it needs a border around it
    if(FIELD_WIDTH < VIEWPORT_WIDTH) {
        draw_line(FIELD_WIDTH*8+1, 0, FIELD_WIDTH*8+1,
                  ymax*8, A_NORMAL);
    }
    if(FIELD_HEIGHT < VIEWPORT_HEIGHT) {
        draw_line(0, ymax*8+1, FIELD_WIDTH*8+1,
                  ymax*8+1, A_NORMAL);
    }
    
    for(xi=scroll_x; xi<xmax; xi++)
    for(yi=scroll_y; yi<ymax; yi++)
    {
        _drawtile(xi, yi);
    }
    
    draw_line(0, LCD_HEIGHT-11, (LCD_WIDTH-1), LCD_HEIGHT-11, A_NORMAL);
    redraw_status_bar();
}
//}}}
//{{{
void draw_map_tile(int x, int y)
{
    if( x<scroll_x || y<scroll_y || x>=scroll_x+VIEWPORT_WIDTH ||
        y>=scroll_y+VIEWPORT_HEIGHT) // Off-screen tile
        return;
    
    _drawtile(x, y);
}
//}}}
//{{{
void redraw_status_bar(void)
{
    char buf[32];
    clear_line_range(LCD_HEIGHT-10, LCD_HEIGHT-1);
    draw_string("Diamonds: ", 2, LCD_HEIGHT-7, F_4x6);
    sprintf(buf, "%i", (int)num_diamonds);
    draw_string(buf, 40, LCD_HEIGHT-7, F_4x6);
    draw_string("Level: ", 100, LCD_HEIGHT-7, F_4x6);
    sprintf(buf, "%i", (int)(current_level_num+1));
    draw_string(buf, 125, LCD_HEIGHT-7, F_4x6);
}
//}}}

//{{{
void advance(void)
{
    int xi, yi;
    int xmax = FIELD_WIDTH;
    int ymax = FIELD_HEIGHT;
    
    // Move sliders, monsters, etc.
    for(yi=0; yi<ymax; yi++)
    for(xi=0; xi<xmax; xi++)
    {
        switch(current_map.t[yi][xi].v)
        {
            case TILE_SLIDER_S: move_slider(xi, yi, 0, 0, 1); break;
            case TILE_SLIDER_E: move_slider(xi, yi, 0, 1, 0); break;
            case TILE_SLIDER_N: move_slider(xi, yi, 0, 0, -1); break;
            case TILE_SLIDER_W: move_slider(xi, yi, 0, -1, 0); break;
            case TILE_ROCKY_S:  move_slider(xi, yi, 1, 0, 1); break;
            case TILE_ROCKY_E:  move_slider(xi, yi, 1, 1, 0); break;
            case TILE_ROCKY_N:  move_slider(xi, yi, 1, 0, -1); break;
            case TILE_ROCKY_W:  move_slider(xi, yi, 1, -1, 0); break;
            
            case TILE_PUSHER_S: move_pusher(xi, yi, 0, 1); break;
            case TILE_PUSHER_E: move_pusher(xi, yi, 1, 0); break;
            case TILE_PUSHER_N: move_pusher(xi, yi, 0, -1); break;
            case TILE_PUSHER_W: move_pusher(xi, yi, -1, 0); break;
            
            case TILE_MAGNET_NS:
                if(can_shove(xi, yi-2, 0, 1))
                    shove(xi, yi-2, 0, 1);
                if(current_map.t[yi-2][xi].v==TILE_KYE && can_shove(xi,yi,0,-1))
                    shove(xi, yi, 0, -1);
                if(can_shove(xi, yi+2, 0, -1))
                    shove(xi, yi+2, 0, -1);
                if(current_map.t[yi+2][xi].v==TILE_KYE && can_shove(xi,yi,0,1))
                    shove(xi, yi, 0, 1);
                break;
            case TILE_MAGNET_EW:
                if(can_shove(xi-2, yi, 1, 0))
                    shove(xi-2, yi, 1, 0);
                if(current_map.t[yi][xi-2].v==TILE_KYE && can_shove(xi,yi,-1,0))
                    shove(xi, yi, -1, 0);
                if(can_shove(xi+2, yi, -1, 0))
                    shove(xi+2, yi, -1, 0);
                if(current_map.t[yi][xi+2].v==TILE_KYE && can_shove(xi,yi,1,0))
                    shove(xi, yi, 1, 0);
                break;
            
            case TILE_BLOB:    // Monsters
            case TILE_TWISTER:
            case TILE_GNASHER:
            case TILE_VIRUS:
            case TILE_SPIKE:
                if( round % MONSTMOVETIME == 0 )
                    move_monster(xi, yi);
                break;
            
#ifdef ANIMATE_DIAMONDS
            case TILE_DIAMOND:
                if( current_map.t[yi][xi].effect.duration <= 1)
                    //FIXMEFIXMEFIXME: This breaks RNG-linked maps (Roulette)!
                {
                    if(current_map.t[yi][xi].effect.sprite == EFFECT_NONE) {
                        current_map.t[yi][xi].effect.sprite = EFFECT_DIAMOND;
                        current_map.t[yi][xi].effect.duration = 25+rand()%75;
                    } else {
                        current_map.t[yi][xi].effect.sprite = EFFECT_NONE;
                        current_map.t[yi][xi].effect.duration = 25+rand()%75;
                    }
                    draw_map_tile(xi, yi);
                }
                break;
#endif
        }
    }
    
    // Check for monsters around the player
    if(   tile_is_monster(player_x-1, player_y)
       || tile_is_monster(player_x+1, player_y)
       || tile_is_monster(player_x, player_y-1)
       || tile_is_monster(player_x, player_y+1) )
    {
        message("Ouch!");
        restart_level();
    }
}
//}}}
//{{{
int tile_is_monster(int x, int y)
{
    int tile = current_map.t[y][x].v;
    if(tile==TILE_BLOB    || tile==TILE_VIRUS ||
       tile==TILE_TWISTER || tile==TILE_GNASHER ||
       tile==TILE_SPIKE )
        return 1;
    else
        return 0;
}
//}}}

//{{{
void turn_sliders(void)
{
    int xi, yi;
    for(yi=0; yi<FIELD_HEIGHT; yi++)
    for(xi=0; xi<FIELD_WIDTH; xi++)
    {
        switch(current_map.t[yi][xi].v)
        {
            case TILE_SLIDER_S:
                try_rotate(xi, yi, 0, 1, TILE_SLIDER_W, TILE_SLIDER_E);
                break;
            case TILE_SLIDER_E:
                try_rotate(xi, yi, 1, 0, TILE_SLIDER_S, TILE_SLIDER_N);
                break;
            case TILE_SLIDER_N:
                try_rotate(xi, yi, 0, -1, TILE_SLIDER_E, TILE_SLIDER_W);
                break;
            case TILE_SLIDER_W:
                try_rotate(xi, yi, -1, 0, TILE_SLIDER_N, TILE_SLIDER_S);
                break;
            case TILE_ROCKY_S:
                try_rotate(xi, yi, 0, 1, TILE_ROCKY_W, TILE_ROCKY_E);
                break;
            case TILE_ROCKY_E:
                try_rotate(xi, yi, 1, 0, TILE_ROCKY_S, TILE_ROCKY_N);
                break;
            case TILE_ROCKY_N:
                try_rotate(xi, yi, 0, -1, TILE_ROCKY_E, TILE_ROCKY_W);
                break;
            case TILE_ROCKY_W:
                try_rotate(xi, yi, -1, 0, TILE_ROCKY_N, TILE_ROCKY_S);
                break;
        }
    }
}
//}}}
//{{{
void try_rotate(int x, int y, int dx, int dy, int cw, int ccw)
{
    if(current_map.t[y+dy][x+dx].v == TILE_TWIST_CW) {
        current_map.t[y][x].v = cw;
        draw_map_tile(x, y);
    }
    else if(current_map.t[y+dy][x+dx].v == TILE_TWIST_CCW) {
        current_map.t[y][x].v = ccw;
        draw_map_tile(x, y);
    }
}
//}}}
//{{{
void move_slider(int x, int y, int slippery, int dx, int dy)
{
    int block;
    int movedir_1=0, movedir_2=0;
    
    if(current_map.t[y][x].skip)
        return;
    
    if(!is_in_bounds(x+dx, y+dy))
        return;
    
    block = current_map.t[y+dy][x+dx].v;
    
    if(block == TILE_EMPTY)
    {
        current_map.t[y+dy][x+dx].v = current_map.t[y][x].v;
        current_map.t[y+dy][x+dx].skip = 1;
        draw_map_tile(x+dx, y+dy);
        current_map.t[y][x].v = TILE_EMPTY;
        draw_map_tile(x, y);
        return;
    }
    else if(block == TILE_EXPLODER) {
        current_map.t[y][x].v = TILE_EMPTY;
        draw_map_tile(x, y);
        detonate(x+dx, y+dy);
        return;
    }
    else if(block == TILE_PIT) {
        current_map.t[y][x].v = TILE_EMPTY;
        draw_map_tile(x, y);
        current_map.t[y+dy][x+dx].v = TILE_EMPTY;
        draw_map_tile(x+dx, y+dy);
        return;
    }
    else if(block == TILE_TWIST_CW || block == TILE_TWIST_CCW)
    {
        try_rotate(x, y, dx, dy,
            rotate_cw(current_map.t[y][x].v),
            rotate_ccw(current_map.t[y][x].v));
        return;
    }
    
    else if(!slippery) return;
    
    switch(block)
    {
        case TILE_ROCKY_S:
        case TILE_ROCKY_E:
        case TILE_ROCKY_N:
        case TILE_ROCKY_W:
        case TILE_BOULDER:
            goto random_falloff;
        case TILE_WALL_3:
            if(dy==-1) goto negative_falloff;
            else if(dx==-1) goto negative_falloff;
            break;
        case TILE_WALL_9:
            if(dy==1) goto positive_falloff;
            else if(dx==-1) goto positive_falloff;
            break;
        case TILE_WALL_7:
            if(dy==1) goto negative_falloff;
            else if(dx==1) goto negative_falloff;
            break;
        case TILE_WALL_1:
            if(dy==-1) goto positive_falloff;
            else if(dx==1) goto positive_falloff;
            break;
        case TILE_WALL_2:
            if(dy==-1) goto random_falloff;
            else if(dx==1) goto positive_falloff;
            else if(dx==-1) goto negative_falloff;
            break;
        case TILE_WALL_6:
            if(dx==-1) goto random_falloff;
            else if(dy==1) goto positive_falloff;
            else if(dy==-1) goto negative_falloff;
            break;
        case TILE_WALL_8:
            if(dy==1) goto random_falloff;
            else if(dx==1) goto negative_falloff;
            else if(dx==-1) goto positive_falloff;
            break;
        case TILE_WALL_4:
            if(dx==1) goto random_falloff;
            else if(dy==1) goto negative_falloff;
            else if(dy==-1) goto positive_falloff;
            break;
    }
    return;
    
    // All of the wall cases reduce to four:
    //       v
    //    #B<--
    //        |s
    //        /
    // Vector v is (dx,dy)
    // Vector s is (dy,dx)
    // Either the block can fall to v+s, it can fall to v-s, it can fall
    // to either, or it can fall to neither. If it can fall to either, which
    // direction it falls is chosen randomly.
random_falloff:
    movedir_1 = movedir_2 = 1;
    goto evaluate_falloff;
positive_falloff:
    movedir_1 = 1;
    goto evaluate_falloff;
negative_falloff:
    movedir_2 = 1;
    goto evaluate_falloff;
    
    // And *these* cases are just the state of two binary values
    
evaluate_falloff:
    if(movedir_1 && is_in_bounds(x+dx+dy, y+dx+dy) &&
       current_map.t[y+dx][x+dy].v==TILE_EMPTY &&
       current_map.t[y+dx+dy][x+dx+dy].v==TILE_EMPTY)
        movedir_1 = 1;
    else
        movedir_1 = 0;
    if(movedir_2 && is_in_bounds(x+dx-dy, y-dx+dy) &&
       current_map.t[y-dx][x-dy].v==TILE_EMPTY &&
       current_map.t[y-dx+dy][x+dx-dy].v==TILE_EMPTY)
        movedir_2 = 1;
    else
        movedir_2 = 0;
    
    if(movedir_1 && movedir_2) {
        if(rand()%2) movedir_1 = 0;
        else         movedir_2 = 0;
    }
    if(movedir_1) {
        current_map.t[y+dx+dy][x+dx+dy].v = current_map.t[y][x].v;
        current_map.t[y+dx+dy][x+dx+dy].skip = 1;
        current_map.t[y][x].v = TILE_EMPTY;
        draw_map_tile(x+dx+dy, y+dx+dy);
        draw_map_tile(x, y);
    }
    else if(movedir_2) {
        current_map.t[y-dx+dy][x+dx-dy].v = current_map.t[y][x].v;
        current_map.t[y-dx+dy][x+dx-dy].skip = 1;
        current_map.t[y][x].v = TILE_EMPTY;
        draw_map_tile(x+dx-dy, y-dx+dy);
        draw_map_tile(x, y);
    }

}
//}}}
//{{{
int rotate_cw(int tile)
{
    switch(tile)
    {
        case TILE_SLIDER_N: return TILE_SLIDER_E;
        case TILE_SLIDER_E: return TILE_SLIDER_S;
        case TILE_SLIDER_S: return TILE_SLIDER_W;
        case TILE_SLIDER_W: return TILE_SLIDER_N;
        case TILE_ROCKY_N:  return TILE_ROCKY_E;
        case TILE_ROCKY_E:  return TILE_ROCKY_S;
        case TILE_ROCKY_S:  return TILE_ROCKY_W;
        case TILE_ROCKY_W:  return TILE_ROCKY_N;
        default: return tile;
    }
}
//}}}
//{{{
int rotate_ccw(int tile)
{
    switch(tile)
    {
        case TILE_SLIDER_N: return TILE_SLIDER_W;
        case TILE_SLIDER_E: return TILE_SLIDER_N;
        case TILE_SLIDER_S: return TILE_SLIDER_E;
        case TILE_SLIDER_W: return TILE_SLIDER_S;
        case TILE_ROCKY_N:  return TILE_ROCKY_W;
        case TILE_ROCKY_E:  return TILE_ROCKY_N;
        case TILE_ROCKY_S:  return TILE_ROCKY_E;
        case TILE_ROCKY_W:  return TILE_ROCKY_S;
        default: return tile;
    }
}
//}}}
//{{{
void move_pusher(int x, int y, int dx, int dy)
{
    if(current_map.t[y][x].skip)
        return;
    
    if(current_map.gamerules == RULESET_DCKYE) {
        if(round%10 != 0) return;
    } else {
        if(round%5 != 0) return;
    }
    
    if(!is_in_bounds(x+dx, y+dy) || current_map.t[y+dy][x+dx].v != TILE_EMPTY)
    {
        if(current_map.t[y+dy][x+dx].v == TILE_PIT) {
            current_map.t[y][x].v = TILE_EMPTY;
            draw_map_tile(x, y);
            current_map.t[y+dy][x+dx].v = TILE_EMPTY;
            draw_map_tile(x+dx, y+dy);
            return;
        }
        
        // Reverse direction
        switch(current_map.t[y][x].v)
        {
            case TILE_PUSHER_W: current_map.t[y][x].v = TILE_PUSHER_E; break;
            case TILE_PUSHER_E: current_map.t[y][x].v = TILE_PUSHER_W; break;
            case TILE_PUSHER_N: current_map.t[y][x].v = TILE_PUSHER_S; break;
            case TILE_PUSHER_S: current_map.t[y][x].v = TILE_PUSHER_N; break;
        }
        draw_map_tile(x, y);
        // Shove
        if(can_shove(x+dx, y+dy, dx, dy))
            shove(x+dx, y+dy, dx, dy);
    } else {
        shove(x, y, dx, dy);
        current_map.t[y+dy][x+dx].skip = 1;
    }
}
//}}}
//{{{
void move_monster(int x, int y)
{
    int dx, dy;
    dx=dy=0;
    // 50%: move towards player
    // 50%: move randomly
    
    if(current_map.t[y][x].skip) return;
    
    if(rand()%2 == 0) {
        // Move randomly
        switch(rand()%5) {
            case 0: dx=dy=0; break;
            case 1: dx=1,  dy=0; break;
            case 2: dx=-1, dy=0; break;
            case 3: dx=0,  dy=1; break;
            case 4: dx=0,  dy=-1; break;
        }
    } else {
        // Move towards player
        if(player_x>x) dx=1;
        else if(player_x<x) dx=-1;
        if(player_y>y) dy=1;
        if(player_y<y) dy=-1;
        if(!is_in_bounds(x+dx, y) || current_map.t[y][x+dx].v!=TILE_EMPTY) dx=0;
        if(!is_in_bounds(x, y+dy) || current_map.t[y+dy][x].v!=TILE_EMPTY) dy=0;
        if(dx && dy) {
            if( abs(player_y-y) > abs(player_x-x) )
                dx=0;
            else
                dy=0;
        }
    }
    
    current_map.t[y][x].effect = animate_monster(x, y);
    
    if((dx==0 && dy==0) || !is_in_bounds(x+dx, y+dy)
       || current_map.t[y+dy][x+dx].v != TILE_EMPTY) {
        draw_map_tile(x, y);
        return;
    }
    current_map.t[y+dy][x+dx].v = current_map.t[y][x].v;
    current_map.t[y+dy][x+dx].effect = current_map.t[y][x].effect;
    current_map.t[y+dy][x+dx].skip = 1;
    current_map.t[y][x].v = TILE_EMPTY;
    current_map.t[y][x].effect.sprite = EFFECT_NONE;
    current_map.t[y][x].effect.duration = 0;
    draw_map_tile(x+dx, y+dy);
    draw_map_tile(x, y);
}
//}}}
//{{{
effect_info animate_monster(int x, int y)
{
    effect_info ret;
    
    if((round/MONSTMOVETIME)%2 == 0) {
        ret.duration=0;
        ret.sprite = EFFECT_NONE;
        return ret;
    }
    
    ret.duration = -1;
    switch(current_map.t[y][x].v)
    {
        case TILE_BLOB:    ret.sprite=EFFECT_BLOB; break;
        case TILE_VIRUS:   ret.sprite=EFFECT_VIRUS; break;
        case TILE_TWISTER: ret.sprite=EFFECT_TWISTER; break;
        case TILE_GNASHER: ret.sprite=EFFECT_GNASHER; break;
        case TILE_SPIKE:   ret.sprite=EFFECT_SPIKE; break;
    }
    return ret;
}
//}}}
//{{{
void detonate(int x, int y)
{
    int xi, yi;
    
    // Yuck, I know. But since the effect tiles have to map into a linear
    // array for efficient rendering, this is pretty much forced.
    if(is_in_bounds(x-1, y-1)) {
        current_map.t[y-1][x-1].effect.sprite = EFFECT_EXPLODE_TOPLEFT;
        current_map.t[y-1][x-1].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x, y-1)) {
        current_map.t[y-1][x].effect.sprite = EFFECT_EXPLODE_TOP;
        current_map.t[y-1][x].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x+1, y-1)) {
        current_map.t[y-1][x+1].effect.sprite = EFFECT_EXPLODE_TOPRIGHT;
        current_map.t[y-1][x+1].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x-1, y)) {
        current_map.t[y][x-1].effect.sprite = EFFECT_EXPLODE_LEFT;
        current_map.t[y][x-1].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x, y)) {
        current_map.t[y][x].effect.sprite = EFFECT_EXPLODE_CENTER;
        current_map.t[y][x].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x+1, y)) {
        current_map.t[y][x+1].effect.sprite = EFFECT_EXPLODE_RIGHT;
        current_map.t[y][x+1].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x-1, y+1)) {
        current_map.t[y+1][x-1].effect.sprite = EFFECT_EXPLODE_BOTLEFT;
        current_map.t[y+1][x-1].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x, y+1)) {
        current_map.t[y+1][x].effect.sprite = EFFECT_EXPLODE_BOTTOM;
        current_map.t[y+1][x].effect.duration = EXPLODE_DURATION;
    }
    if(is_in_bounds(x+1, y+1)) {
        current_map.t[y+1][x+1].effect.sprite = EFFECT_EXPLODE_BOTRIGHT;
        current_map.t[y+1][x+1].effect.duration = EXPLODE_DURATION;
    }
    current_map.t[y][x].v = TILE_PIT;
    for(yi=y-1; yi<=y+1; yi++)
    for(xi=x-1; xi<=x+1; xi++)
    {
        if(!is_in_bounds(xi, yi)) continue;
        if(current_map.t[yi][xi].v!=TILE_DIAMOND // Diamonds can't be destroyed
           || current_map.t[yi][xi].v == TILE_KYE  // Kye survives explosions
           || current_map.t[yi][xi].v == TILE_PIT) // So do pits
              current_map.t[yi][xi].v = TILE_EMPTY;
        draw_map_tile(xi, yi);
    }
}
//}}}
//{{{
void clear_effects(void)
{
    int xi, yi;
    int xmax = FIELD_WIDTH;
    int ymax = FIELD_HEIGHT;
    for(yi=0; yi<ymax; yi++)
    for(xi=0; xi<xmax; xi++)
    {
        current_map.t[yi][xi].skip = 0;
        
        if(current_map.t[yi][xi].effect.duration > 0)
        {
            if(current_map.t[yi][xi].effect.duration == 1) {
                current_map.t[yi][xi].effect.duration = 0;
                current_map.t[yi][xi].effect.sprite = EFFECT_NONE;
                draw_map_tile(xi, yi);
            } else {
                current_map.t[yi][xi].effect.duration--;
            }
        }
    }
}
//}}}

//{{{
int is_in_bounds(int x, int y)
{
    if(x<0 || y<0 || x>=FIELD_WIDTH || y>=FIELD_HEIGHT)
        return 0;
    else
        return 1;
}
//}}}
//{{{
int can_shove(int x, int y, int dx, int dy)
{
    if(!is_in_bounds(x, y))
        return 0;
    if(!is_in_bounds(x+dx, y+dy))
        return 0;
    
    switch(current_map.t[y+dy][x+dx].v)
    {
        case TILE_EMPTY:
        case TILE_PIT:
            break;
        default:
            return 0;
    }
    
    switch(current_map.t[y][x].v)
    {
        case TILE_SLIDER_S: case TILE_SLIDER_E:  // Pushable tiles (*might* be
        case TILE_SLIDER_N: case TILE_SLIDER_W:  // passable, if there's room
        case TILE_ROCKY_S:   case TILE_ROCKY_E:  // to push them into.)
        case TILE_ROCKY_N:   case TILE_ROCKY_W:
        case TILE_BLOCK:    case TILE_BOULDER:
        case TILE_EXPLODER:
        case TILE_TWIST_CW: case TILE_TWIST_CCW:
        case TILE_STICKY_EW: case TILE_STICKY_NS:
        case TILE_MAGNET_EW: case TILE_MAGNET_NS:
        case TILE_PUSHER_W: case TILE_PUSHER_E:
        case TILE_PUSHER_N: case TILE_PUSHER_S:
        case TILE_VIRUS:    case TILE_BLOB:
        case TILE_TWISTER:  case TILE_GNASHER:
        case TILE_SPIKE:
            break;
        default:
            return 0;
    }

    return 1;
}
//}}}
//{{{
void shove(int x, int y, int dx, int dy)
{
    if(current_map.t[y+dy][x+dx].v == TILE_PIT)
    {
        current_map.t[y][x].v = TILE_EMPTY;
        current_map.t[y+dy][x+dx].v = TILE_EMPTY;
    } else {
        current_map.t[y+dy][x+dx].v = current_map.t[y][x].v;
        current_map.t[y][x].v = TILE_EMPTY;
    }
    if(current_map.t[y][x].effect.duration == -1) {
        current_map.t[y][x].effect.duration = 0;
        current_map.t[y][x].effect.sprite = 0;
    }
    draw_map_tile(x, y);
    draw_map_tile(x+dx, y+dy);
}
//}}}

//{{{
int check_diamonds(void)
{
    int xi, yi;
    int prev_diamonds = num_diamonds;
    num_diamonds = 0;
    for(yi=0; yi<FIELD_HEIGHT; yi++)
    for(xi=0; xi<FIELD_WIDTH; xi++)
    {
        if(current_map.t[yi][xi].v == TILE_DIAMOND)
            num_diamonds++;
    }
    if(num_diamonds==0) {
        advance_to_level = current_level_num+1;
        if(strlen(current_map.congrat) > 0) {
            message(current_map.congrat);
        }
        return 0;
    }
    if(num_diamonds != prev_diamonds)
        redraw_status_bar();
    return 1;
}
//}}}

//{{{
void set_magnet_skips(void)
{
    int xi, yi;
    int xmax = FIELD_WIDTH;
    int ymax = FIELD_HEIGHT;
    for(yi=0; yi<ymax; yi++)
    for(xi=0; xi<xmax; xi++)
    {
        if( current_map.t[yi][xi].v == TILE_STICKY_NS ||
                current_map.t[yi][xi].v == TILE_MAGNET_NS) {
            if(yi>0) current_map.t[yi-1][xi].skip = 1;
            if(yi+1<ymax) current_map.t[yi+1][xi].skip = 1;
        } else if( current_map.t[yi][xi].v == TILE_STICKY_EW ||
                current_map.t[yi][xi].v == TILE_MAGNET_EW) {
            if(xi>0) current_map.t[yi][xi-1].skip = 1;
            if(xi+1<xmax) current_map.t[yi][xi+1].skip = 1;
        }
    }
}
//}}}

//{{{
void restart_level(void)
{
    load_kyelib(current_level_num);
    begin_level();
    draw_current_map();
}
//}}}
//{{{
void begin_level(void)
{
    int xi, yi;
    
    round = 1;
    
    for(yi=0; yi<FIELD_HEIGHT; yi++)
    for(xi=0; xi<FIELD_WIDTH; xi++)
    {
        current_map.t[yi][xi].effect.duration = 0;
        current_map.t[yi][xi].effect.sprite = EFFECT_NONE;
        if(current_map.t[yi][xi].v == TILE_KYE) {
            player_x = xi;
            player_y = yi;
        }
    }
    
    center_viewport();
    check_diamonds();
}
//}}}

---