Changeset 147


Ignore:
Timestamp:
Nov 11, 2003, 12:38:50 AM (19 years ago)
Author:
Sam Hocevar
Message:
  • libee/graphics.c: + Moved ee_putstr() and ee_putchar() in here.
  • libee/ee.h: + Got rid of ee_goto(). + Moved <slang.h> or <curses.h> into libee.
  • Replaced ee_goto()/ee_putstr() pairs with ee_putstr().
  • Ditto for ee_putchar().
Location:
libcaca/trunk
Files:
16 edited
1 copied

Legend:

Unmodified
Added
Removed

  • libcaca/trunk/libee/Makefile.am

    r129 r147  
    77        ee.c \
    88        ee.h \
     9        graphics.c \
    910        io.c \
    1011        math.c \

  • libcaca/trunk/libee/conic.c

    r137 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include <stdlib.h>
    … …  
    100106
    101107    if((b & (0x1|0x4)) == (0x1|0x4))
    102     {
    103         ee_goto(xo + x, yo + y);
    104         ee_putchar(c);
    105     }
     108        ee_putchar(xo + x, yo + y, c);
    106109
    107110    if((b & (0x2|0x4)) == (0x2|0x4))
    108     {
    109         ee_goto(xo - x, yo + y);
    110         ee_putchar(c);
    111     }
     111        ee_putchar(xo - x, yo + y, c);
    112112
    113113    if((b & (0x1|0x8)) == (0x1|0x8))
    114     {
    115         ee_goto(xo + x, yo - y);
    116         ee_putchar(c);
    117     }
     114        ee_putchar(xo + x, yo - y, c);
    118115
    119116    if((b & (0x2|0x8)) == (0x2|0x8))
    120     {
    121         ee_goto(xo - x, yo - y);
    122         ee_putchar(c);
    123     }
     117        ee_putchar(xo - x, yo - y, c);
    124118}
    125119

  • libcaca/trunk/libee/ee.c

    r93 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include <stdlib.h>
    … …  
    128134}
    129135
    130 void ee_clear(void)
    131 {
    132 #if defined(USE_SLANG) || defined(USE_NCURSES)
    133     /* We could use SLsmg_cls(), but drawing empty lines is much faster */
    134     int x = ee_get_width(), y = ee_get_height();
    135     char *empty_line = malloc((x + 1) * sizeof(char));
    136 
    137     memset(empty_line, ' ', x);
    138     empty_line[x] = '\0';
    139 
    140     while(y--)
    141     {
    142         ee_goto(0, y);
    143         ee_putstr(empty_line);
    144     }
    145 
    146     free(empty_line);
    147 #else
    148     /* Use dummy driver */
    149 #endif
    150 }
    151 
    152136static int64_t local_time(void)
    153137{
    … …  
    166150    static int64_t local_clock = 0;
    167151    int64_t now;
    168 
    169     ee_goto(0, 0);
    170152
    171153    if(!local_clock)

  • libcaca/trunk/libee/ee.h

    r131 r147  
    2222
    2323/*
    24  * Graphics primitives
    25  */
    26 #ifdef USE_SLANG
    27 #   include <slang.h>
    28 #   define ee_color(x) SLsmg_set_color(x)
    29 #   define ee_goto(x,y) SLsmg_gotorc(y,x)
    30 #   define ee_putchar(x) SLsmg_write_char(x)
    31 #   define ee_putstr(x) SLsmg_write_string(x)
    32 #elif USE_NCURSES
    33 #   define box box_divert
    34 #   include <curses.h>
    35 #   undef box
    36 #   define ee_color(x) attrset(COLOR_PAIR(x))
    37 #   define ee_goto(x,y) move(y,x)
    38 #   define ee_putchar(x) addch(x)
    39 #   define ee_putstr(x) addstr(x)
    40 #else
    41 #   define ee_color(x) (void)(x)
    42 #   define ee_goto(x,y) do{ (void)(x); (void)(y); } while(0)
    43 #   define ee_putchar(x) (void)(x)
    44 #   define ee_putstr(x) (void)(x)
    45 #endif
    46 
    47 #define ee_putcharTO(x,y,c) do{ ee_goto(x,y); ee_putchar(c); }while(0)
    48 
    49 /*
    50  * Colours
     24 * Colors
    5125 */
    5226#define EE_BLACK 1
    … …  
    7347int ee_get_width(void);
    7448int ee_get_height(void);
    75 void ee_clear(void);
    7649void ee_refresh(void);
    7750void ee_end(void);
    7851
    7952char ee_get_key(void);
     53
     54void ee_color(int);
     55void ee_putchar(int, int, char);
     56void ee_putstr(int, int, char *);
     57void ee_clear(void);
    8058
    8159void ee_draw_line(int, int, int, int, char);

  • libcaca/trunk/libee/graphics.c

    r146 r147  
    2323#include "config.h"
    2424
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
     30
     31#include <string.h>
    2532#include <stdlib.h>
    26 #include <unistd.h>
    27 #include <string.h>
    28 #include <sys/time.h>
    29 #include <time.h>
    3033
    3134#include "ee.h"
    3235
    33 static int _ee_delay;
    34 
    35 int ee_init(void)
     36void ee_color(int color)
    3637{
    3738#ifdef USE_SLANG
    38     static char * colors[] = { "black", "green", "yellow", "white",
    39         "red", "gray", "lightgray", "blue", "cyan", "magenta", NULL };
    40     int i;
    41 
    42     /* Initialize slang library */
    43     SLsig_block_signals();
    44     SLtt_get_terminfo();
    45 
    46     if(SLkp_init() == -1)
    47     {
    48         SLsig_unblock_signals();
    49         return -1;
    50     }
    51 
    52     SLang_init_tty(-1, 0, 1);
    53 
    54     if(SLsmg_init_smg() == -1)
    55     {
    56         SLsig_unblock_signals();
    57         return -1;
    58     }
    59 
    60     SLsig_unblock_signals();
    61 
    62     SLsmg_cls();
    63     SLtt_set_cursor_visibility(0);
    64     SLsmg_refresh();
    65 
    66     for(i = 0; colors[i]; i++)
    67     {
    68         SLtt_set_color(i + 1, NULL, colors[i], "black");
    69     }
    70 
     39    SLsmg_set_color(color);
    7140#elif USE_NCURSES
    72     /* Initialize ncurses library */
    73     initscr();
    74     keypad(stdscr, TRUE);
    75     nonl();
    76     cbreak();
    77     noecho();
    78     nodelay(stdscr, TRUE);
    79     curs_set(0);
    80 
    81     start_color();
    82 
    83     init_pair(EE_BLACK, COLOR_BLACK, COLOR_BLACK);
    84     init_pair(EE_GREEN, COLOR_GREEN, COLOR_BLACK);
    85     init_pair(EE_YELLOW, COLOR_YELLOW, COLOR_BLACK);
    86     init_pair(EE_WHITE, COLOR_WHITE, COLOR_BLACK);
    87     init_pair(EE_RED, COLOR_RED, COLOR_BLACK);
    88     init_pair(EE_GRAY, COLOR_WHITE, COLOR_BLACK); // XXX
    89     init_pair(EE_LIGHTGRAY, COLOR_WHITE, COLOR_BLACK); // XXX
    90     init_pair(EE_BLUE, COLOR_BLUE, COLOR_BLACK);
    91     init_pair(EE_CYAN, COLOR_CYAN, COLOR_BLACK);
    92     init_pair(EE_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
    93 
     41    attrset(COLOR_PAIR(color));
    9442#else
    95     /* Dummy driver */
    96 
    97 #endif
    98     _ee_delay = 0;
    99 
    100     return 0;
    101 }
    102 
    103 void ee_set_delay(int delay)
    104 {
    105     _ee_delay = delay;
    106 }
    107 
    108 int ee_get_width(void)
    109 {
    110 #ifdef USE_SLANG
    111     return SLtt_Screen_Cols;
    112 #elif USE_NCURSES
    113     return COLS;
    114 #else
    115     return 80;
     43    /* Use dummy driver */
    11644#endif
    11745}
    11846
    119 int ee_get_height(void)
     47void ee_putchar(int x, int y, char c)
    12048{
    12149#ifdef USE_SLANG
    122     return SLtt_Screen_Rows;
     50    SLsmg_gotorc(y,x);
     51    SLsmg_write_char(c);
    12352#elif USE_NCURSES
    124     return LINES;
     53    move(y,x);
     54    addch(c);
    12555#else
    126     return 25;
     56    /* Use dummy driver */
     57#endif
     58}
     59
     60void ee_putstr(int x, int y, char *s)
     61{
     62#ifdef USE_SLANG
     63    SLsmg_gotorc(y,x);
     64    SLsmg_write_string(s);
     65#elif USE_NCURSES
     66    move(y,x);
     67    addstr(s);
     68#else
     69    /* Use dummy driver */
    12770#endif
    12871}
    … …  
    14083    while(y--)
    14184    {
    142         ee_goto(0, y);
    143         ee_putstr(empty_line);
     85        ee_putstr(0, y, empty_line);
    14486    }
    14587
    … …  
    15092}
    15193
    152 static int64_t local_time(void)
    153 {
    154     struct timeval tv;
    155     int64_t now;
    156 
    157     gettimeofday(&tv, NULL);
    158     now = tv.tv_sec;
    159     now *= 1000000;
    160     now += tv.tv_usec;
    161     return now;
    162 }
    163 
    164 void ee_refresh(void)
    165 {
    166     static int64_t local_clock = 0;
    167     int64_t now;
    168 
    169     ee_goto(0, 0);
    170 
    171     if(!local_clock)
    172     {
    173         /* Initialize local_clock */
    174         local_clock = local_time();
    175     }
    176 
    177     if(local_time() > local_clock + 10000)
    178     {
    179         /* If we are late, we shouldn't display anything */
    180     }
    181 
    182 #ifdef USE_SLANG
    183     SLsmg_refresh();
    184 #elif USE_NCURSES
    185     refresh();
    186 #else
    187     /* Use dummy driver */
    188 #endif
    189 
    190     now = local_time();
    191 
    192     if(now < local_clock + _ee_delay - 10000)
    193     {
    194         usleep(local_clock + _ee_delay - 10000 - now);
    195     }
    196 
    197     local_clock += _ee_delay;
    198 }
    199 
    200 void ee_end(void)
    201 {
    202 #ifdef USE_SLANG
    203     SLtt_set_cursor_visibility(1);
    204     SLang_reset_tty();
    205     SLsmg_reset_smg();
    206 #elif USE_NCURSES
    207     curs_set(1);
    208     endwin();
    209 #else
    210     /* Use dummy driver */
    211 #endif
    212 }
    213 

  • libcaca/trunk/libee/io.c

    r89 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include "ee.h"

  • libcaca/trunk/libee/line.c

    r129 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include <inttypes.h>
    … …  
    197203        for(; dx>=0; dx--)
    198204        {
    199             ee_goto(x1, y1);
    200             ee_putchar(s->c);
     205            ee_putchar(x1, y1, s->c);
    201206            if(delta > 0)
    202207            {
    … …  
    220225        for(; dy >= 0; dy--)
    221226        {
    222             ee_goto(x1, y1);
    223             ee_putchar(s->c);
     227            ee_putchar(x1, y1, s->c);
    224228            if(delta > 0)
    225229            {
    … …  
    291295        for(; dx>=0; dx--)
    292296        {
    293             ee_goto(x1, y1);
    294297            if(delta > 0)
    295298            {
    296                 ee_putchar(charmapy[1]);
     299                ee_putchar(x1, y1, charmapy[1]);
    297300                x1++;
    298301                y1 += yinc;
    … …  
    303306            {
    304307                if(prev)
    305                     ee_putchar(charmapy[0]);
     308                    ee_putchar(x1, y1, charmapy[0]);
    306309                else
    307                     ee_putchar('-');
     310                    ee_putchar(x1, y1, '-');
    308311                x1++;
    309312                delta += dpr;
    … …  
    320323        for(; dy >= 0; dy--)
    321324        {
    322             ee_goto(x1, y1);
    323325            if(delta > 0)
    324326            {
    325                 ee_putchar(charmapx[0]);
    326                 ee_putchar(charmapx[1]);
     327                ee_putchar(x1, y1, charmapx[0]);
     328                ee_putchar(x1 + 1, y1, charmapx[1]);
    327329                x1++;
    328330                y1 += yinc;
    … …  
    331333            else
    332334            {
    333                 ee_putchar('|');
     335                ee_putchar(x1, y1, '|');
    334336                y1 += yinc;
    335337                delta += dpr;

  • libcaca/trunk/libee/math.c

    r91 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include <stdlib.h>

  • libcaca/trunk/libee/sprite.c

    r139 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include <stdio.h>
    … …  
    167173            if(col >= 0)
    168174            {
    169                 ee_goto(x + i - frame->dx, y + j - frame->dy);
    170175                ee_color(col);
    171                 ee_putchar(frame->chars[frame->w * j + i]);
     176                ee_putchar(x + i - frame->dx, y + j - frame->dy,
     177                           frame->chars[frame->w * j + i]);
    172178            }
    173179        }

  • libcaca/trunk/libee/triangle.c

    r105 r147  
    2222
    2323#include "config.h"
     24
     25#ifdef USE_SLANG
     26#   include <slang.h>
     27#elif USE_NCURSES
     28#   include <curses.h>
     29#endif
    2430
    2531#include <stdlib.h>
    … …  
    8288
    8389        for(x = xa; x <= xb; x++)
    84         {
    85             ee_goto(x, y);
    86             ee_putchar(c);
    87         }
     90            ee_putchar(x, y, c);
    8891    }
    8992}

  • libcaca/trunk/src/box.c

    r121 r147  
    8686
    8787    /* FIXME: use a font */
    88     ee_goto(b->x - b->w / 2 + 12, b->y - b->h / 2 + 2);
    89     ee_putstr("XXXX.  .XXXX  X   X  .XXXX  .XXXX  XXXX.");
    90     ee_goto(b->x - b->w / 2 + 12, b->y - b->h / 2 + 3);
    91     ee_putstr("X  `X  X'  X  X   X  X'     X'     X  `X");
    92     ee_goto(b->x - b->w / 2 + 12, b->y - b->h / 2 + 4);
    93     ee_putstr("XXXX'  XXXXX  X   X  `XXX   XXXX   X   X");
    94     ee_goto(b->x - b->w / 2 + 12, b->y - b->h / 2 + 5);
    95     ee_putstr("X'     X' `X  X. ,X     `X  X'     X  ,X");
    96     ee_goto(b->x - b->w / 2 + 12, b->y - b->h / 2 + 6);
    97     ee_putstr("X      X   X  `XXXX  XXXX'  `XXXX  XXXX'");
     88    ee_putstr(b->x - b->w / 2 + 12, b->y - b->h / 2 + 2,
     89              "XXXX.  .XXXX  X   X  .XXXX  .XXXX  XXXX.");
     90    ee_putstr(b->x - b->w / 2 + 12, b->y - b->h / 2 + 3,
     91              "X  `X  X'  X  X   X  X'     X'     X  `X");
     92    ee_putstr(b->x - b->w / 2 + 12, b->y - b->h / 2 + 4,
     93              "XXXX'  XXXXX  X   X  `XXX   XXXX   X   X");
     94    ee_putstr(b->x - b->w / 2 + 12, b->y - b->h / 2 + 5,
     95              "X'     X' `X  X. ,X     `X  X'     X  ,X");
     96    ee_putstr(b->x - b->w / 2 + 12, b->y - b->h / 2 + 6,
     97              "X      X   X  `XXXX  XXXX'  `XXXX  XXXX'");
    9898}
    9999

  • libcaca/trunk/src/overlay.c

    r109 r147  
    3434    /* Draw life jauge */
    3535    ee_color(EE_GRAY);
    36     ee_goto(4, 1);
    37     ee_putstr(dots30);
     36    ee_putstr(4, 1, dots30);
    3837
    3938    if(g->p->life > MAX_LIFE * 7 / 10)
    … …  
    5049    }
    5150
    52     ee_goto(4, 1);
    53     ee_putstr(dashes30 + (MAX_LIFE - g->p->life) * 30 / MAX_LIFE);
     51    ee_putstr(4, 1, dashes30 + (MAX_LIFE - g->p->life) * 30 / MAX_LIFE);
    5452
    5553    ee_color(EE_WHITE);
    56     ee_goto(1, 1);
    57     ee_putstr("L |");
    58     ee_goto(34, 1);
    59     ee_putstr("|");
     54    ee_putstr(1, 1, "L |");
     55    ee_putstr(34, 1, "|");
    6056
    6157    /* Draw weapon jauge */
    6258    ee_color(EE_GRAY);
    63     ee_goto(42, 1);
    64     ee_putstr(dots30 + 10);
     59    ee_putstr(42, 1, dots30 + 10);
    6560
    6661    if(g->p->special > MAX_SPECIAL * 9 / 10)
    … …  
    7772    }
    7873
    79     ee_goto(42, 1);
    80     ee_putstr(dashes30 + 10 + (MAX_SPECIAL - g->p->special) * 20 / MAX_SPECIAL);
     74    ee_putstr(42, 1, dashes30 + 10
     75                      + (MAX_SPECIAL - g->p->special) * 20 / MAX_SPECIAL);
    8176
    8277    ee_color(EE_WHITE);
    83     ee_goto(39, 1);
    84     ee_putstr("S |");
    85     ee_goto(62, 1);
    86     ee_putstr("|");
     78    ee_putstr(39, 1, "S |");
     79    ee_putstr(62, 1, "|");
    8780}
    8881

  • libcaca/trunk/src/player.c

    r109 r147  
    5656    }
    5757
    58     ee_goto(p->x + 2, p->y - 2);
    5958    ee_color(EE_GREEN);
    60     ee_putstr("/\\");
    61     ee_goto(p->x + 1, p->y - 1);
    62     ee_putchar('(');
     59    ee_putstr(p->x + 2, p->y - 2, "/\\");
     60    ee_putchar(p->x + 1, p->y - 1, '(');
     61    ee_putchar(p->x + 4, p->y - 1, ')');
     62    ee_putstr(p->x, p->y, "I<__>I");
    6363    ee_color(EE_YELLOW);
    64     ee_putstr("()");
    65     ee_color(EE_GREEN);
    66     ee_putchar(')');
    67     ee_goto(p->x, p->y);
    68     ee_color(EE_GREEN);
    69     ee_putstr("I<__>I");
     64    ee_putstr(p->x + 2, p->y - 1, "()");
    7065}
    7166

  • libcaca/trunk/src/starfield.c

    r109 r147  
    5555        {
    5656            ee_color(s[i].c);
    57             ee_goto(s[i].x, s[i].y);
    58             ee_putchar(s[i].ch);
     57            ee_putchar(s[i].x, s[i].y, s[i].ch);
    5958        }
    6059    }

  • libcaca/trunk/src/tunnel.c

    r109 r147  
    7878    {
    7979        if(t->left[i] <= -10)
    80         {
    8180            continue;
    82         }
    8381
    8482        if(i + 1 == g->h || t->left[i] > t->left[i+1])
    85         {
    8683            c = (i == 0 || t->left[i] > t->left[i-1]) ? '>' : '/';
    87         }
    8884        else
    89         {
    9085            c = (i == 0 || t->left[i] > t->left[i-1]) ? '\\' : '<';
    91         }
    92 
    93         ee_goto(t->left[i] + 1, i);
    94         ee_putchar(c);
     86
     87        ee_putchar(t->left[i] + 1, i, c);
    9588
    9689        if(i + 1 < g->h)
    97         {
    9890            for(j = 1; j < t->left[i+1] - t->left[i]; j++)
    99             {
    100                 ee_goto(t->left[i] + j + 1, i);
    101                 ee_putchar('_');
    102             }
    103         }
     91                ee_putchar(t->left[i] + j + 1, i, '_');
    10492    }
    10593
    … …  
    10896    {
    10997        if(t->right[i] >= g->w + 10)
    110         {
    11198            continue;
    112         }
    11399
    114100        if(i + 1 == g->h || t->right[i] > t->right[i+1])
    115         {
    116101            c = (i == 0 || t->right[i] > t->right[i-1]) ? '>' : '/';
    117         }
    118102        else
    119         {
    120103            c = (i == 0 || t->right[i] > t->right[i-1]) ? '\\' : '<';
    121         }
    122104
    123105        if(i + 1 < g->h)
    124         {
    125106            for(j = 1; j < t->right[i] - t->right[i+1]; j++)
    126             {
    127                 ee_goto(t->right[i+1] + j - 1, i);
    128                 ee_putchar('_');
    129             }
    130         }
    131 
    132         ee_goto(t->right[i] - 1, i);
    133         ee_putchar(c);
     107                ee_putchar(t->right[i+1] + j - 1, i, '_');
     108
     109        ee_putchar(t->right[i] - 1, i, c);
    134110    }
    135111
    … …  
    138114    /* Left concrete */
    139115    for(i = 0; i < g->h ; i++)
    140     {
    141116        for(j = 0 ; j <= t->left[i]; j++)
    142         {
    143             ee_goto(j, i);
    144             ee_putchar('#');
    145         }
    146     }
     117            ee_putchar(j, i, '#');
    147118
    148119    /* Right concrete */
    149120    for(i = 0; i < g->h ; i++)
    150     {
    151121        for(j = t->right[i] ; j < g->w ; j++)
    152         {
    153             ee_goto(j, i);
    154             ee_putchar('#');
    155         }
    156     }
     122            ee_putchar(j, i, '#');
    157123}
    158124

  • libcaca/trunk/src/weapons.c

    r143 r147  
    5858            case WEAPON_LASER:
    5959                ee_color(EE_WHITE);
    60                 ee_goto(wp->x[i] >> 4, wp->y[i] >> 4);
    61                 ee_putchar('|');
     60                ee_putchar(wp->x[i] >> 4, wp->y[i] >> 4, '|');
    6261                ee_color(EE_CYAN);
    63                 ee_goto(wp->x[i] >> 4, (wp->y[i] >> 4) + 1);
    64                 ee_putchar('|');
     62                ee_putchar(wp->x[i] >> 4, (wp->y[i] >> 4) + 1, '|');
    6563                break;
    6664            case WEAPON_SEEKER:
    6765                ee_color(EE_CYAN);
    68                 ee_goto(wp->x3[i] >> 4, wp->y3[i] >> 4);
    69                 ee_putchar('.');
    70                 ee_goto(wp->x2[i] >> 4, wp->y2[i] >> 4);
    71                 ee_putchar('o');
     66                ee_putchar(wp->x3[i] >> 4, wp->y3[i] >> 4, '.');
     67                ee_putchar(wp->x2[i] >> 4, wp->y2[i] >> 4, 'o');
    7268                ee_color(EE_WHITE);
    73                 ee_goto(wp->x[i] >> 4, wp->y[i] >> 4);
    74                 ee_putchar('@');
     69                ee_putchar(wp->x[i] >> 4, wp->y[i] >> 4, '@');
    7570                break;
    7671            case WEAPON_BOMB:
    7772                ee_color(EE_GRAY);
    78                 ee_goto((wp->x[i] - wp->vx[i]) >> 4, (wp->y[i] - wp->vy[i]) >> 4);
    79                 ee_putchar('.');
    80                 ee_goto((wp->x3[i] - wp->vx[i]) >> 4, (wp->y3[i] - wp->vy[i]) >> 4);
    81                 ee_putchar('.');
    82                 ee_goto((wp->x2[i] - wp->vx[i]) >> 4, (wp->y2[i] - wp->vy[i]) >> 4);
    83                 ee_putchar('.');
    84                 ee_goto(wp->x3[i] >> 4, wp->y3[i] >> 4);
    85                 ee_putchar('.');
    86                 ee_goto(wp->x2[i] >> 4, wp->y2[i] >> 4);
    87                 ee_putchar('.');
     73                ee_putchar((wp->x[i] - wp->vx[i]) >> 4, (wp->y[i] - wp->vy[i]) >> 4, '.');
     74                ee_putchar((wp->x3[i] - wp->vx[i]) >> 4, (wp->y3[i] - wp->vy[i]) >> 4, '.');
     75                ee_putchar((wp->x2[i] - wp->vx[i]) >> 4, (wp->y2[i] - wp->vy[i]) >> 4, '.');
     76                ee_putchar(wp->x3[i] >> 4, wp->y3[i] >> 4, '.');
     77                ee_putchar(wp->x2[i] >> 4, wp->y2[i] >> 4, '.');
    8878                draw_bomb(wp->x[i] >> 4, wp->y[i] >> 4, wp->vx[i], wp->vy[i]);
    8979                break;
    … …  
    368358        case 24:
    369359            ee_color(EE_WHITE);
    370             ee_goto(x, y-3);
    371             ee_putstr("__");
    372             ee_goto(x-1, y-2);
    373             ee_putchar('\'');
    374             ee_goto(x+2, y-2);
    375             ee_putchar('`');
     360            ee_putstr(x, y-3, "__");
     361            ee_putchar(x-1, y-2, '\'');
     362            ee_putchar(x+2, y-2, '`');
    376363            break;
    377364        case 23:
    378365            ee_color(EE_CYAN);
    379             ee_goto(x, y-3);
    380             ee_putstr("__");
    381             ee_color(EE_WHITE);
    382             ee_goto(x-2, y-2);
    383             ee_putstr("-'");
    384             ee_goto(x+2, y-2);
    385             ee_putstr("`-");
     366            ee_putstr(x, y-3, "__");
     367            ee_color(EE_WHITE);
     368            ee_putstr(x-2, y-2, "-'");
     369            ee_putstr(x+2, y-2, "`-");
    386370            break;
    387371        case 22:
    388372            ee_color(EE_CYAN);
    389             ee_goto(x, y-3);
    390             ee_putstr("__");
    391             ee_goto(x-1, y-2);
    392             ee_putchar('\'');
    393             ee_goto(x+2, y-2);
    394             ee_putchar('`');
    395             ee_color(EE_WHITE);
    396             ee_goto(x-3, y-2);
    397             ee_putstr(",-");
    398             ee_goto(x+3, y-2);
    399             ee_putstr("-.");
     373            ee_putstr(x, y-3, "__");
     374            ee_putchar(x-1, y-2, '\'');
     375            ee_putchar(x+2, y-2, '`');
     376            ee_color(EE_WHITE);
     377            ee_putstr(x-3, y-2, ",-");
     378            ee_putstr(x+3, y-2, "-.");
    400379            break;
    401380        case 21:
    402381            ee_color(EE_CYAN);
    403             ee_goto(x-1, y-3);
    404             ee_putstr("____");
    405             ee_goto(x-2, y-2);
    406             ee_putchar('\'');
    407             ee_goto(x+3, y-2);
    408             ee_putchar('`');
    409             ee_color(EE_WHITE);
    410             ee_goto(x-4, y-2);
    411             ee_putstr(",-");
    412             ee_goto(x+4, y-2);
    413             ee_putstr("-.");
     382            ee_putstr(x-1, y-3, "____");
     383            ee_putchar(x-2, y-2, '\'');
     384            ee_putchar(x+3, y-2, '`');
     385            ee_color(EE_WHITE);
     386            ee_putstr(x-4, y-2, ",-");
     387            ee_putstr(x+4, y-2, "-.");
    414388            break;
    415389        case 20:
    416390            ee_color(EE_WHITE);
    417             ee_goto(x, y-3);
    418             ee_putstr("%%");
    419             ee_goto(x-4, y-2);
    420             ee_putchar(',');
    421             ee_goto(x+5, y-2);
    422             ee_putchar('.');
    423             ee_color(EE_CYAN);
    424             ee_goto(x-1, y-3);
    425             ee_putchar(':');
    426             ee_goto(x+2, y-3);
    427             ee_putchar(':');
    428             ee_goto(x-3, y-2);
    429             ee_putstr("-'");
    430             ee_goto(x+3, y-2);
    431             ee_putstr("`-");
     391            ee_putstr(x, y-3, "%%");
     392            ee_putchar(x-4, y-2, ',');
     393            ee_putchar(x+5, y-2, '.');
     394            ee_color(EE_CYAN);
     395            ee_putchar(x-1, y-3, ':');
     396            ee_putchar(x+2, y-3, ':');
     397            ee_putstr(x-3, y-2, "-'");
     398            ee_putstr(x+3, y-2, "`-");
    432399            break;
    433400        case 19:
    434401            ee_color(EE_WHITE);
    435             ee_goto(x, y-4);
    436             ee_putstr("%%");
    437             ee_goto(x, y-3);
    438             ee_putstr("##");
    439             ee_color(EE_CYAN);
    440             ee_goto(x-1, y-4);
    441             ee_putchar(':');
    442             ee_goto(x+2, y-4);
    443             ee_putchar(':');
    444             ee_goto(x-1, y-3);
    445             ee_putchar('%');
    446             ee_goto(x+2, y-3);
    447             ee_putchar('%');
    448             ee_goto(x-4, y-2);
    449             ee_putstr(",-'");
    450             ee_goto(x+3, y-2);
    451             ee_putstr("`-.");
     402            ee_putstr(x, y-4, "%%");
     403            ee_putstr(x, y-3, "##");
     404            ee_color(EE_CYAN);
     405            ee_putchar(x-1, y-4, ':');
     406            ee_putchar(x+2, y-4, ':');
     407            ee_putchar(x-1, y-3, '%');
     408            ee_putchar(x+2, y-3, '%');
     409            ee_putstr(x-4, y-2, ",-'");
     410            ee_putstr(x+3, y-2, "`-.");
    452411            ee_color(EE_BLUE);
    453             ee_goto(x-2, y-3);
    454             ee_putchar(':');
    455             ee_goto(x+3, y-3);
    456             ee_putchar(':');
     412            ee_putchar(x-2, y-3, ':');
     413            ee_putchar(x+3, y-3, ':');
    457414            break;
    458415        case 18:
    … …  
    460417            r = (18 - frame) * (18 - frame);
    461418            ee_color(EE_WHITE);
    462             ee_goto(x-1, y-5-r);
    463             ee_putstr(":%%:");
    464             ee_goto(x-1, y-4-r);
    465             ee_putstr("%##%");
    466             ee_color(EE_CYAN);
    467             ee_goto(x-2, y-4-r);
    468             ee_putchar(':');
    469             ee_goto(x+3, y-4-r);
    470             ee_putchar(':');
    471             ee_goto(x-2, y-2);
    472             ee_putchar('\'');
    473             ee_goto(x+3, y-2);
    474             ee_putchar('`');
     419            ee_putstr(x-1, y-5-r, ":%%:");
     420            ee_putstr(x-1, y-4-r, "%##%");
     421            ee_color(EE_CYAN);
     422            ee_putchar(x-2, y-4-r, ':');
     423            ee_putchar(x+3, y-4-r, ':');
     424            ee_putchar(x-2, y-2, '\'');
     425            ee_putchar(x+3, y-2, '`');
    475426            ee_color(EE_BLUE);
    476             ee_goto(x-3, y-2);
    477             ee_putchar(':');
    478             ee_goto(x+4, y-2);
    479             ee_putchar(':');
     427            ee_putchar(x-3, y-2, ':');
     428            ee_putchar(x+4, y-2, ':');
    480429            for(i = 0; i <= r; i++)
    481430            {
    482431                ee_color(EE_WHITE);
    483                 ee_goto(x-1, y-3-i);
    484                 ee_putstr((i+frame) % 5 ? "####" : "%%%%");
     432                ee_putstr(x-1, y-3-i, ((i+frame) % 5) ? "####" : "%%%%");
    485433                ee_color(EE_CYAN);
    486                 ee_goto(x-2, y-3-i);
    487                 ee_putchar('%');
    488                 ee_goto(x+3, y-3-i);
    489                 ee_putchar('%');
     434                ee_putchar(x-2, y-3-i, '%');
     435                ee_putchar(x+3, y-3-i, '%');
    490436                ee_color(EE_BLUE);
    491                 ee_goto(x-3, y-3-i);
    492                 ee_putchar(':');
    493                 ee_goto(x+4, y-3-i);
    494                 ee_putchar(':');
     437                ee_putchar(x-3, y-3-i, ':');
     438                ee_putchar(x+4, y-3-i, ':');
    495439            }
    496440            break;

  • libcaca/trunk/test/demo.c

    r133 r147  
    139139    ee_draw_line(1, 1, xo, 1, '.');
    140140
    141     ee_goto((xo - strlen("libee demo")) / 2, 3);
    142     ee_putstr("libee demo");
    143     ee_goto((xo - strlen("============")) / 2, 4);
    144     ee_putstr("============");
    145 
    146     ee_goto(4, 6);
    147     ee_putstr("0: complete demo");
    148     ee_goto(4, 7);
    149     ee_putstr("1: dots demo");
    150     ee_goto(4, 8);
    151     ee_putstr("2: lines demo");
    152     ee_goto(4, 9);
    153     ee_putstr("3: thin lines demo");
    154     ee_goto(4, 10);
    155     ee_putstr("4: circles demo");
    156     ee_goto(4, 11);
    157     ee_putstr("5: ellipses demo");
    158     ee_goto(4, 12);
    159     ee_putstr("6: triangles demo");
    160     ee_goto(4, 13);
    161     ee_putstr("7: outlined triangles demo");
    162     ee_goto(4, 14);
    163     ee_putstr("8: sprites demo");
    164 
    165     ee_goto(4, yo - 2);
    166     ee_putstr("q: quit");
     141    ee_putstr((xo - strlen("libee demo")) / 2, 3, "libee demo");
     142    ee_putstr((xo - strlen("============")) / 2, 4, "============");
     143
     144    ee_putstr(4, 6, "0: complete demo");
     145    ee_putstr(4, 7, "1: dots demo");
     146    ee_putstr(4, 8, "2: lines demo");
     147    ee_putstr(4, 9, "3: thin lines demo");
     148    ee_putstr(4, 10, "4: circles demo");
     149    ee_putstr(4, 11, "5: ellipses demo");
     150    ee_putstr(4, 12, "6: triangles demo");
     151    ee_putstr(4, 13, "7: outlined triangles demo");
     152    ee_putstr(4, 14, "8: sprites demo");
     153
     154    ee_putstr(4, yo - 2, "q: quit");
    167155
    168156    ee_refresh();
    … …  
    266254        int delta = ee_rand(-5, 5);
    267255        ee_color(ee_rand(1, 10));
    268         ee_goto(ee_get_width() / 2
    269                  + cos(0.02*j) * (delta + ee_get_width() / 4),
    270                 ee_get_height() / 2
    271                  + sin(0.02*j) * (delta + ee_get_height() / 3));
    272         ee_putchar('#');
     256        ee_putchar(ee_get_width() / 2
     257                    + cos(0.02*j) * (delta + ee_get_width() / 4),
     258                   ee_get_height() / 2
     259                    + sin(0.02*j) * (delta + ee_get_height() / 3),
     260                   '#');
    273261    }
    274262
    … …  
    291279        /* Putpixel */
    292280        ee_color(ee_rand(1, 10));
    293         ee_goto(ee_rand(0, xmax), ee_rand(0, ymax));
    294         ee_putchar('#');
     281        ee_putchar(ee_rand(0, xmax), ee_rand(0, ymax), '#');
    295282    }
    296283    ee_refresh();
Note: See TracChangeset for help on using the changeset viewer.