engine/util.c

Go to the documentation of this file.

#include "engine.h"

//{{{
int read_char(void)
{
    // NOTE: The contents of this function have a large effect on battery
    // usage.
    unsigned short key;
    void *kbq = kbd_queue();
    
    OSTimerRestart(APD_TIMER);
    
    if(GrayCheckRunning())
    {
        while(OSdequeue (&key, kbq)) {
            GrayIdle();
            if(OSTimerExpired(APD_TIMER)) {
                off();
                OSTimerRestart(APD_TIMER);
            }
        }
    } else {
        while(OSdequeue (&key, kbq)) {
            idle();
            if(OSTimerExpired(APD_TIMER)) {
                off();
                OSTimerRestart(APD_TIMER);
            }
        }
    }
    return key;
}
//}}}
//{{{
int read_char_with_timeout()
{
    // NOTE: The contents of this function have a large effect on battery
    // usage.
    unsigned short key;
    void *kbq = kbd_queue();
    
    while(OSdequeue (&key, kbq)) {
        GrayIdle();
        if(OSTimerExpired(APD_TIMER)) {
            off();
            OSTimerRestart(APD_TIMER);
        }
        if(OSTimerExpired(USER_TIMER)) {
            key = 0;
            break;
        }
    }
    
    if(key) {
        OSTimerRestart(APD_TIMER); // APD timer is restarted IFF a key was hit
    }
    
    return key;
}
//}}}
//{{{
// A non-blocking version of read_char. Returns 0 if no input is ready.
int poll_char(void)
{
    unsigned short key;
    if( OSdequeue (&key, kbd_queue()) )
        return 0;
    else
        return key;
}
//}}}
//{{{
void flush_input(void)
{
    OSqclear(kbd_queue());
}
//}}}

//{{{
void delay(void)
{
    OSRegisterTimer(USER_TIMER, 2);
    
    if(GrayCheckRunning())
    {
        do {
            GrayIdle();
        } while(!OSTimerExpired(USER_TIMER));
    } else {
        do {
            idle();
        } while(!OSTimerExpired(USER_TIMER));
    }
    OSFreeTimer(USER_TIMER);
}
//}}}

//{{{
void clear_screen(void)
{
    if( GrayCheckRunning() ) {
        GraySetAMSPlane(LIGHT_PLANE);
        clrscr();
        GraySetAMSPlane(DARK_PLANE);
    }
    clrscr();
}
//}}}
//{{{
void clear_line_range(int top, int bottom)
{
    if(GrayCheckRunning())
    {
        memset((char*)GrayGetPlane(LIGHT_PLANE) + top*30, 0, (bottom-top)*30);
        memset((char*)GrayGetPlane(DARK_PLANE) + top*30, 0, (bottom-top)*30);
    }
    memset((char*)LCD_MEM + top*30, 0, (bottom-top)*30);
}
//}}}
//{{{
void draw_sprite(const char *spr, int x, int y)
{
    char *lightpos, *darkpos;
    int ii;
    
    x >>= 3;
    
    if( GrayCheckRunning() ) {
        lightpos = (char*)GrayGetPlane(LIGHT_PLANE) + y*30 + x;
        darkpos  = (char*)GrayGetPlane(DARK_PLANE)  + y*30 + x;
        spr += 8;
        for(ii=0; ii<8; ii++) {
            *darkpos  = *(spr++);
            *lightpos = *(spr++);
            darkpos  += 30;
            lightpos += 30;
        }
    } else {
        lightpos = LCD_MEM + y*30 + x;
        for(ii=0; ii<8; ii++) {
            *lightpos = *(spr++);
            lightpos += 30;
        }
    }
}
//}}}
//{{{
void draw_sprite_xor(const char *spr, int x, int y)
{
    char *lightpos, *darkpos;
    int ii;
    
    x >>= 3;
    
    if( GrayCheckRunning() ) {
        lightpos = (char*)GrayGetPlane(LIGHT_PLANE) + y*30 + x;
        darkpos  = (char*)GrayGetPlane(DARK_PLANE)  + y*30 + x;
        spr += 8;
        for(ii=0; ii<8; ii++) {
            *darkpos  ^= *(spr++);
            *lightpos ^= *(spr++);
            darkpos  += 30;
            lightpos += 30;
        }
    } else {
        lightpos = LCD_MEM + y*30 + x;
        for(ii=0; ii<8; ii++) {
            *lightpos ^= *(spr++);
            lightpos += 30;
        }
    }
}
//}}}
//{{{
void draw_line(short x0, short y0, short x1, short y1, short Attr)
{
    if(GrayCheckRunning())
    {
        GraySetAMSPlane(LIGHT_PLANE);
        DrawLine(x0, y0, x1, y1, Attr);
        GraySetAMSPlane(DARK_PLANE);
    }
    DrawLine(x0, y0, x1, y1, Attr);
}
//}}}
//{{{
void draw_string(const char *str, short x, short y, short font)
{
    FontSetSys(font);
    if(GrayCheckRunning())
    {
        GraySetAMSPlane(LIGHT_PLANE);
        DrawStr(x, y, str, A_NORMAL);
        GraySetAMSPlane(DARK_PLANE);
    }
    DrawStr(x, y, str, A_NORMAL);
}
//}}}
//{{{
void clear_rect(int left, int top, int width, int height)
{
    SCR_RECT r = {{ left, top, left+width-1, top+height-1}};
    
    if(GrayCheckRunning())
    {
        GraySetAMSPlane(LIGHT_PLANE);
        ScrRectFill(&r, &r, A_REVERSE);
        GraySetAMSPlane(DARK_PLANE);
    }
    ScrRectFill(&r, &r, A_REVERSE);
}
//}}}
//{{{
// draw_rect: Draws a rectangle with a black border and a white interior
void draw_rect(int left, int top, int width, int height)
{
    clear_rect(left, top, width, height);
    width--;
    height--;
    draw_line(left, top, left+width, top, A_NORMAL);
    draw_line(left+width, top, left+width, top+height, A_NORMAL);
    draw_line(left+width, top+height, left, top+height, A_NORMAL);
    draw_line(left, top+height, left, top, A_NORMAL);
}
//}}}
//{{{
void xor_rect(int left, int top, int width, int height)
{
    SCR_RECT r = {{ left, top, left+width-1, top+height-1}};
    
    if(GrayCheckRunning())
    {
        GraySetAMSPlane(LIGHT_PLANE);
        ScrRectFill(&r, &r, A_XOR);
        GraySetAMSPlane(DARK_PLANE);
    }
    ScrRectFill(&r, &r, A_XOR);
}
//}}}
/*
//{{{
// freadstr: Read a null-terminated string from fp. This is different from
// fgets only in what marks the end of the string.
char *freadstr(char *s, int n, FILE *fp)
{
    // Source: tigcclib, with modifications
    short c=EOF;
    char *cs=s;
    while(--n>0&&(c=fgetc(fp))!=EOF) {
        if ((*cs++=c)=='\0') break;
    }
    *cs=0;
    return ((c==EOF&&cs==s)?0:s);
}
//}}}
*/

//{{{
void freadstr(char *s, int n, FILE *fp)
{
    char *end = (char*)fp->base+peek_w(fp->base)+2;
    
    do {
        if(fp->fpos > end) {
            fp->fpos = end;
            break;
        }
        *(s++) = *(fp->fpos);
        n--;
        fp->fpos ++;
    } while( *(fp->fpos-1) != '\0' && n>1 );
    *s = '\0';
}
//}}}
//{{{
unsigned short fread_fast(void *ptr, short size, short n, FILE *f)
{
    unsigned short bytes_remaining =
        peek_w(f->base) + (char*)f->base - (char*)f->fpos + 2;
    
    if(f->flags&_F_ERR) return 0;
    if(!(f->flags&_F_READ)) __FERROR(f);

    if(size*n > bytes_remaining) // More data requested than available
        n = bytes_remaining/size;
    else if(size*n == bytes_remaining)
        f->flags|=_F_EOF;
    
    size *= n;
    memcpy(ptr, f->fpos, size);
    f->fpos += size;
    return n;
}
//}}}
//{{{
// Somewhat less general, in that this omits support for ASCII junk, or
// unget, or EOF tracking, or much error handling at all.
short fseek_fast(FILE *f, long offset, short wh)
{
    char *start = (char*)f->base+2;
    char *end = (char*)f->base+peek_w(f->base)+2;
    char *pos = ((wh==SEEK_SET)?start:((wh==SEEK_CUR)?(f->fpos):end))+offset;
    if(pos<start||pos>end) __FERROR(f);
    f->fpos=pos;
    return 0;
}
//}}}

---