home · contact · privacy
Use bit shifting instead of magic number in rrand().
[plomrogue] / 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 }