plomlompom.com Git - plomrogue/blob - src/draw_wins.c

   1 /* draw_wins.c */
   2
   3 #include "draw_wins.h"
   4 #include <stdlib.h>      /* for malloc(), free() */
   5 #include <stdint.h>      /* for uint16_t */
   6 #include <string.h>      /* for strlen() */
   7 #include <ncurses.h>     /* for mvwaddch() */
   8 #include "windows.h"     /* for structs Win, Frame, for draw_scroll_hint() */
   9 #include "misc.h"        /* for center_offset() */
  10 #include "keybindings.h" /* for struct KeyBinding, for get_keyname() */
  11 #include "map_objects.h" /* for structs MapObj, Player */
  12 #include "map.h"         /* for Map struct */
  13 #include "main.h"        /* for World struct */
  14
  15
  16
  17 /* Write "text" into window "win" as far as possible. Start on row "start_y". */
  18 static void draw_with_linebreaks(struct Win * win, char * text,
  19                                  uint16_t start_y);
  20
  21 /* Write "text" not starting from the top but from the bottom of "win". */
  22 static void draw_text_from_bottom(struct Win * win, char * text);
  23
  24 /* Draw onto "map" in "win" the objects in the chain at "start". */
  25 static void draw_map_objects(struct World * world, struct MapObj * start,
  26                              struct Map * map, struct Win * win);
  27
  28
  29
  30 extern void draw_log_win(struct Win * win)
  31 {
  32     struct World * world = (struct World *) win->data;
  33     draw_text_from_bottom(win, world->log);
  34 }
  35
  36
  37
  38 extern void draw_map_win(struct Win * win)
  39 {
  40     struct World * world = (struct World *) win->data;
  41     struct Map * map = world->map;
  42     struct Player * player = world->player;
  43     char * cells = map->cells;
  44     uint16_t width_map_av  = map->size.x  - map->offset.x;
  45     uint16_t height_map_av = map->size.y - map->offset.y;
  46     uint16_t x, y, z;
  47     for (y = 0; y < win->frame.size.y; y++)
  48     {
  49         z = map->offset.x + (map->offset.y + y) * (map->size.x);
  50         for (x = 0; x < win->frame.size.x; x++)
  51         {
  52             if (y < height_map_av && x < width_map_av)
  53             {
  54                 mvwaddch(win->frame.curses_win, y, x, cells[z]);
  55                 z++;
  56             }
  57         }
  58     }
  59     draw_map_objects (world, (struct MapObj *) world->item, map, win);
  60     draw_map_objects (world, (struct MapObj *) world->monster, map, win);
  61     if (   player->pos.y >= map->offset.y
  62         && player->pos.y < map->offset.y + win->frame.size.y
  63         && player->pos.x >= map->offset.x
  64         && player->pos.x < map->offset.x + win->frame.size.x)
  65     {
  66         mvwaddch(win->frame.curses_win,
  67                  player->pos.y - map->offset.y, player->pos.x - map->offset.x,
  68                  '@');
  69     }
  70 }
  71
  72
  73
  74 extern void draw_info_win(struct Win * win)
  75 {
  76     struct World * world = (struct World *) win->data;
  77     char text[100];
  78     snprintf(text, 100,
  79              "Turn: %d\nHitpoints: %d", world->turn, world->player->hitpoints);
  80     draw_with_linebreaks(win, text, 0);
  81 }
  82
  83
  84
  85 extern void draw_keys_win(struct Win * win)
  86 {
  87     struct World * world = (struct World *) win->data;
  88     uint16_t offset, y, x;
  89     offset = center_offset(world->keyswindata->select, world->keyswindata->max,
  90                            win->frame.size.y - 1);
  91     uint8_t keydescwidth = 9 + 1; /* max length assured by get_keyname() + \0 */
  92     char * keydesc = malloc(keydescwidth), * keyname;
  93     attr_t attri;
  94     for (y = 0; y <= world->keyswindata->max && y < win->frame.size.y; y++)
  95     {
  96         if (0 == y && offset > 0)
  97         {
  98             draw_scroll_hint(&win->frame, y, offset + 1, '^');
  99             continue;
 100         }
 101         else if (win->frame.size.y == y + 1
 102                  && 0 < world->keyswindata->max
 103                         - (win->frame.size.y + offset - 1))
 104         {
 105             draw_scroll_hint(&win->frame, y,
 106                              world->keyswindata->max
 107                              - (offset + win->frame.size.y) + 2, 'v');
 108             continue;
 109         }
 110         attri = 0;
 111         if (y == world->keyswindata->select - offset)
 112         {
 113             attri = A_REVERSE;
 114             if (1 == world->keyswindata->edit)
 115             {
 116                 attri = attri | A_BLINK;
 117             }
 118         }
 119         keyname = get_keyname(world->keybindings[y + offset].key);
 120         snprintf(keydesc, keydescwidth, "%-9s", keyname);
 121         free(keyname);
 122         for (x = 0; x < win->frame.size.x; x++)
 123         {
 124             if (x < strlen(keydesc))
 125             {
 126                 mvwaddch(win->frame.curses_win, y, x, keydesc[x] | attri);
 127             }
 128             else if (strlen(keydesc) < x
 129                      && x < strlen(world->keybindings[y + offset].name)
 130                             + strlen(keydesc) + 1)
 131             {
 132                 mvwaddch(win->frame.curses_win, y, x,
 133                          world->keybindings[y + offset]
 134                          .name[x - strlen(keydesc) - 1] | attri);
 135             }
 136             else
 137             {
 138                 mvwaddch(win->frame.curses_win, y, x, ' ' | attri);
 139             }
 140         }
 141     }
 142     free(keydesc);
 143 }
 144
 145
 146
 147 static void draw_with_linebreaks(struct Win * win, char * text,
 148                                  uint16_t start_y)
 149 {
 150     uint16_t x, y;
 151     char toggle;
 152     char fin = 0;
 153     int16_t z = -1;
 154     for (y = start_y; y < win->frame.size.y; y++)
 155     {
 156         if (0 == fin)
 157         {
 158             toggle = 0;
 159         }
 160         for (x = 0; x < win->frame.size.x; x++)
 161         {
 162             if (0 == toggle)
 163             {
 164                 z++;
 165                 if ('\n' == text[z])
 166                 {
 167                     toggle = 1;
 168                     continue;
 169                 }
 170                 else
 171                 {
 172                     mvwaddch(win->frame.curses_win, y, x, text[z]);
 173                 }
 174                 if ('\n' == text[z+1])
 175                 {
 176                     z++;
 177                     toggle = 1;
 178                 }
 179                 else if (0 == text[z+1])
 180                 {
 181                     toggle = 1;
 182                     fin = 1;
 183                 }
 184             }
 185         }
 186     }
 187 }
 188
 189
 190
 191 static void draw_text_from_bottom (struct Win * win, char * text)
 192 {
 193     /* Determine number of lines text would have in a window of win's width,
 194      * but infinite height. Treat \n and \0 as control chars for incrementing
 195      * y and stopping the loop. Make sure +they* don't count as cell space.
 196      */
 197     char toggle = 0;
 198     uint16_t x, y, offset;
 199     int16_t z = -1;
 200     for (y = 0; 0 == toggle; y++)
 201     {
 202         for (x = 0; x < win->frame.size.x; x++)
 203         {
 204             z++;
 205             if ('\n' == text[z])
 206             {
 207                 break;
 208             }
 209             if ('\n' == text[z+1])
 210             {
 211                 z++;
 212                 break;
 213             }
 214             else if (0 == text[z+1])
 215             {
 216                 toggle = 1;
 217                 break;
 218             }
 219         }
 220     }
 221     z = -1;
 222
 223     /* Depending on what's bigger, determine start point in window or text. */
 224     uint16_t start_y = 0;
 225     if (y < win->frame.size.y)
 226     {
 227         start_y = win->frame.size.y - y;
 228     }
 229     else if (y > win->frame.size.y)
 230     {
 231         offset = y - win->frame.size.y;
 232         for (y = 0; y < offset; y++)
 233         {
 234             for (x = 0; x < win->frame.size.x; x++)
 235             {
 236                 z++;
 237                 if ('\n' == text[z])
 238                 {
 239                     break;
 240                 }
 241                 if ('\n' == text[z+1])
 242                 {
 243                     z++;
 244                     break;
 245                 }
 246             }
 247         }
 248         text = text + (sizeof(char) * (z + 1));
 249     }
 250
 251     draw_with_linebreaks(win, text, start_y);
 252 }
 253
 254
 255
 256 static void draw_map_objects(struct World * world, struct MapObj * start,
 257                              struct Map * map, struct Win * win)
 258 {
 259     struct MapObj * o;
 260     struct MapObjDef * d;
 261     char c;
 262     for (o = start; o != 0; o = o->next)
 263     {
 264         if (   o->pos.y >= map->offset.y
 265             && o->pos.y < map->offset.y + win->frame.size.y
 266             && o->pos.x >= map->offset.x
 267             && o->pos.x < map->offset.x + win->frame.size.x)
 268         {
 269             d = get_map_obj_def (world, o->type);
 270             c = d->mapchar;
 271             mvwaddch(win->frame.curses_win,
 272                      o->pos.y - map->offset.y, o->pos.x - map->offset.x, c);
 273         }
 274     }
 275 }