src/tilefield.c

Go to the documentation of this file.

/* {{{
 * CalcRogue, a roguelike game for PCs, calculators and PDAs
 * Copyright (C) 2003 Jim Babcock
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * }}} */
// tilefield.c

#include "crogue.h"

static void _UI_TF_DrawTile(int x, int y, UI_TF_TileInfo tile);

static UI_Tilefield tf;

//{{{
void UI_TF_MoveCamera(int x, int y)
{
    int oldx=tf.viewoffset.x, oldy=tf.viewoffset.y;
        // Previous x,y offset, to compare later to see if it's changed
    uint threshhold_x, threshhold_y;
    
    threshhold_x = tf.window.x / 3 - 1;
    threshhold_y = tf.window.y / 3 - 1;
    
    // Scroll X
    if( x-threshhold_x <= tf.viewoffset.x || x+threshhold_x-tf.viewoffset.x >= tf.window.x )
    {
        tf.viewoffset.x = max(x - ((sint)tf.window.x)/2, 0);
        if(tf.viewoffset.x + tf.window.x > tf.size.x)
            tf.viewoffset.x = tf.size.x - tf.window.x;
    }
    
    // Scroll Y
    if( y-threshhold_y <= tf.viewoffset.y || y+threshhold_y-tf.viewoffset.y >= tf.window.y )
    {
        tf.viewoffset.y = max(y - ((sint)tf.window.y)/2, 0);
        if(tf.viewoffset.y + tf.window.y > tf.size.y)
            tf.viewoffset.y = tf.size.y - tf.window.y;
    }
    
    if( tf.viewoffset.x != oldx || tf.viewoffset.y != oldy ) UI_TF_FullRedraw();
}
//}}}
//{{{
void UI_TF_PlaceCamera(int x, int y)
{
    tf.viewoffset.x = max(x - ((sint)tf.window.x)/2, 0);
    tf.viewoffset.y = max(y - ((sint)tf.window.y)/2, 0);
    if(tf.viewoffset.x + tf.window.x > tf.size.x)
        tf.viewoffset.x = tf.size.x - tf.window.x;
    if(tf.viewoffset.y + tf.window.y > tf.size.y)
        tf.viewoffset.y = tf.size.y - tf.window.y;
    return;
}
//}}}
//{{{
void UI_TF_Scroll(int x, int y)
{
    signed int new_x, new_y;
    
    if(w->time == 0)
    {
        message(gettext("Use the number keys (1-9) to move."));
        return;
    }
    
    new_x = tf.viewoffset.x + x;
    new_y = tf.viewoffset.y + y;
    if(new_x<0) new_x = 0;
    if(new_y<0) new_y = 0;
    if(new_x + tf.window.x > tf.size.x) new_x = tf.size.x - tf.window.x;
    if(new_y + tf.window.y > tf.size.y) new_y = tf.size.y - tf.window.y;
    
    tf.viewoffset.x = new_x;
    tf.viewoffset.y = new_y;
    
    UI_TF_FullRedraw();
}
//}}}
//{{{
void UI_TF_Init(coord size)
{
    tf.size = size;
    tf.viewoffset = COORD(0,0);
    
    // Recalculate pos and window
    tf.window = tf.full_window;
    tf.pos = tf.full_pos;
    if(tf.window.x > tf.size.x) {
        tf.window.x = tf.size.x;
        tf.pos.x += (tf.full_window.x - tf.size.x)/2;
    }
    if(tf.window.y > tf.size.y) {
        tf.window.y = tf.size.y;
        tf.pos.y += (tf.full_window.y - tf.size.y)/2;
    }
}
//}}}
//{{{
void UI_TF_Place(coord pos, coord window, const uchar *graphics,
    uchar tileheight, uchar tilewidth)
{
    tf.full_pos = pos;
    tf.full_window = window;
    tf.graphics = graphics;
    tf.tileheight = tileheight;
    tf.tilewidth = tilewidth;
    
    UI_TF_Init(tf.size);
}
//}}}
//{{{
void UI_TF_Deinit(void)
{
}
//}}}
//{{{
void UI_TF_PutTile(int x, int y, uchar tnum, uchar lighting)
{
    int tx, ty;
    UI_TF_TileInfo tile;
    tx = x - tf.viewoffset.x;
    ty = y - tf.viewoffset.y;
    
    tile.tile = tnum;
    tile.lighting = lighting;
    
    if(tx<0 || ty<0 || tx>=tf.window.x || ty>=tf.window.y) return;
    
    _UI_TF_DrawTile(tx, ty, tile);
}
//}}}
#ifdef SUPPORT_COLOR
//{{{
void UI_TF_PutTile_Color(int x, int y, uchar tnum, uchar lighting, colorinfo color)
{
    int tx, ty;
    UI_TF_TileInfo tile;
    tx = x - tf.viewoffset.x;
    ty = y - tf.viewoffset.y;
    
    tile.tile = tnum;
    tile.lighting = lighting;
    tile.color = color;
    
    if(tx<0 || ty<0 || tx>=tf.window.x || ty>=tf.window.y) return;
    
    _UI_TF_DrawTile(tx, ty, tile);
}
//}}}
#endif
//{{{
void UI_TF_FullRedraw()
{
    int i, ii;
    
    for(i=0; i<tf.window.y; i++)
    {
#ifdef REALCOMPUTER
        clear_line(i+tf.pos.y);
#endif
        for(ii=0; ii<tf.window.x; ii++)
            draw_tile(ii+tf.viewoffset.x, i+tf.viewoffset.y);
    }
}
//}}}
#if 0
//{{{
const uchar tiles[128] = {
0,   ' ', 2,   '.', '.', '#', '~', '.', '.', '^', '^', '-', '|', '\\','/', 't',
'%', ' ', '}', '*', '*', 21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  
32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  
48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  
64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  
80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  
96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
}; 
//}}}
#endif
//{{{
static void _UI_TF_DrawTile(int x, int y, UI_TF_TileInfo tile)
{
#ifdef IS_CALCULATOR
    void *light;
    void *dark;
    const uchar *lighttile;
    const uchar *darktile;
    
    if(w->options[OPTION_GRAYSCALE] == OPTION_GRAY_ON)
    {
        light = GrayGetPlane(LIGHT_PLANE);
        dark = GrayGetPlane(DARK_PLANE);
        switch(tile.lighting)
        {
            case LIGHTING_LIT:
                lighttile = darktile = tf.graphics + tile.tile*tf.tileheight;
                break;
            case LIGHTING_DARK:
                lighttile = tf.graphics + (tf.tileheight * blacktile);
                darktile = tf.graphics + tile.tile*tf.tileheight;
                break;
            case LIGHTING_UNEXPLORED:
                lighttile = tf.graphics + (tf.tileheight * whitetile);
                darktile = tf.graphics + (tf.tileheight * blacktile);
                break;
            default:
                return;
        }
        GraySprite8_BLIT(tf.pos.x + x * tf.tilewidth,
            tf.pos.y + y * tf.tileheight,
            tf.tileheight,
            lighttile,
            darktile,
            0xFF >> tf.tileheight,
            light,
            dark);
    } else {
        switch(tile.lighting)
        {
            case LIGHTING_LIT:
                if(tile.tile == 3) tile.tile = 4;
            case LIGHTING_DARK:
                darktile = tf.graphics + tile.tile * tf.tileheight;
                break;
            case LIGHTING_UNEXPLORED:
                darktile = tf.graphics + 17 * tf.tileheight;
                break;
            default:
                return;
        }
        GraySprite8_BLIT(tf.pos.x + x * tf.tilewidth,
            tf.pos.y + y * tf.tileheight,
            tf.tileheight,
            darktile,
            darktile,
            0xFF >> tf.tileheight,
            LCD_MEM,
            LCD_MEM);
    }
#endif
#ifdef USE_CURSES
    uchar target_color;
    if(tile.lighting == LIGHTING_LIT)
        target_color = tile.color.lit;
    else
        target_color = tile.color.dark;
    attroff(COLOR_PAIR(DEFAULT_COLOR));
    if(target_color & COLOR_BOLD)
        attron(A_BOLD);
    attron(COLOR_PAIR((target_color&~COLOR_BOLD)+1));
    mvaddch(y+tf.pos.y, x+tf.pos.x, tiles[tile.tile]);
    if(target_color & COLOR_BOLD)
        attroff(A_BOLD);
    attroff(COLOR_PAIR((target_color&~COLOR_BOLD)+1));
    attron(COLOR_PAIR(DEFAULT_COLOR));
#endif
#ifdef IS_PALM
    Graph_ClearRect(tf.pos.x + x*tf.tilewidth, tf.pos.y + y*tf.tileheight,
                    tf.tilewidth, tf.tileheight);
    Graph_DrawChar(tf.pos.x + x*tf.tilewidth, tf.pos.y + y*tf.tileheight,
                   tiles[tile.tile]);
#endif
}
//}}}

#ifdef REALCOMPUTER
//{{{
void UI_TF_PlaceCursor(int x, int y)
{
    move(y+tf.pos.y-tf.viewoffset.y, x+tf.pos.x-tf.viewoffset.x);
}
//}}}
#endif
//{{{
void UI_TF_DrawEffect(sshort x, sshort y, ushort tnum)
{
    UI_TF_TileInfo t;
    t.tile = tnum;
    if(!(w->t[y][x].flags & TFLAG_EXPLORED))
        t.lighting = LIGHTING_UNEXPLORED;
    else if(w->t[y][x].flags & TFLAG_LIT)
        t.lighting = LIGHTING_LIT;
    else
        t.lighting = LIGHTING_DARK;
    
#ifdef SUPPORT_COLOR
    t.color.lit = t.color.dark = COLOR_BOLD + 7;
#endif
#ifdef USE_CURSES
    UI_TF_PlaceCursor(x, y);
#endif
    x -= tf.viewoffset.x;
    y -= tf.viewoffset.y;
    _UI_TF_DrawTile(x, y, t);
}
//}}}
//{{{
void UI_TF_ClearEffects(void)
{
    UI_TF_FullRedraw();
}
//}}}

---