added asking for and uploading tapes to score server (only once)
[rocksndiamonds.git] / src / libgame / text.c
1 // ============================================================================
2 // Artsoft Retro-Game Library
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // text.c
10 // ============================================================================
11
12 #include <stdio.h>
13 #include <stdarg.h>
14
15 #include "text.h"
16 #include "misc.h"
17
18
19 // ============================================================================
20 // font functions
21 // ============================================================================
22
23 void InitFontInfo(struct FontBitmapInfo *font_bitmap_info, int num_fonts,
24                   int (*select_font_function)(int),
25                   int (*get_font_from_token_function)(char *))
26 {
27   gfx.num_fonts = num_fonts;
28   gfx.font_bitmap_info = font_bitmap_info;
29   gfx.select_font_function = select_font_function;
30   gfx.get_font_from_token_function = get_font_from_token_function;
31 }
32
33 void FreeFontInfo(struct FontBitmapInfo *font_bitmap_info)
34 {
35   if (font_bitmap_info == NULL)
36     return;
37
38   free(font_bitmap_info);
39 }
40
41 struct FontBitmapInfo *getFontBitmapInfo(int font_nr)
42 {
43   int font_bitmap_id = gfx.select_font_function(font_nr);
44
45   return &gfx.font_bitmap_info[font_bitmap_id];
46 }
47
48 int getFontWidth(int font_nr)
49 {
50   int font_bitmap_id = gfx.select_font_function(font_nr);
51
52   return gfx.font_bitmap_info[font_bitmap_id].width;
53 }
54
55 int getFontHeight(int font_nr)
56 {
57   int font_bitmap_id = gfx.select_font_function(font_nr);
58
59   return gfx.font_bitmap_info[font_bitmap_id].height;
60 }
61
62 int getFontDrawOffsetX(int font_nr)
63 {
64   int font_bitmap_id = gfx.select_font_function(font_nr);
65
66   return gfx.font_bitmap_info[font_bitmap_id].draw_xoffset;
67 }
68
69 int getFontDrawOffsetY(int font_nr)
70 {
71   int font_bitmap_id = gfx.select_font_function(font_nr);
72
73   return gfx.font_bitmap_info[font_bitmap_id].draw_yoffset;
74 }
75
76 int getTextWidth(char *text, int font_nr)
77 {
78   return (text != NULL ? strlen(text) * getFontWidth(font_nr) : 0);
79 }
80
81 static int getFontCharPosition(int font_nr, char c)
82 {
83   int font_bitmap_id = gfx.select_font_function(font_nr);
84   struct FontBitmapInfo *font = &gfx.font_bitmap_info[font_bitmap_id];
85   boolean default_font = (font->num_chars == DEFAULT_NUM_CHARS_PER_FONT);
86   int font_pos = (unsigned char)c - 32;
87
88   // map some special characters to their ascii values in default font
89   if (default_font)
90     font_pos = MAP_FONT_ASCII(c) - 32;
91
92   // this allows dynamic special characters together with special font
93   if (font_pos < 0 || font_pos >= font->num_chars)
94     font_pos = 0;
95
96   return font_pos;
97 }
98
99 void getFontCharSource(int font_nr, char c, Bitmap **bitmap, int *x, int *y)
100 {
101   int font_bitmap_id = gfx.select_font_function(font_nr);
102   struct FontBitmapInfo *font = &gfx.font_bitmap_info[font_bitmap_id];
103   int font_pos = getFontCharPosition(font_nr, c);
104   int offset_x = (font->offset_x != 0 ? font->offset_x : font->width);
105   int offset_y = (font->offset_y != 0 ? font->offset_y : font->height);
106
107   *bitmap = font->bitmap;
108   *x = font->src_x + (font_pos % font->num_chars_per_line) * offset_x;
109   *y = font->src_y + (font_pos / font->num_chars_per_line) * offset_y;
110 }
111
112
113 // ============================================================================
114 // text string helper functions
115 // ============================================================================
116
117 int maxWordLengthInRequestString(char *text)
118 {
119   char *text_ptr;
120   int word_len = 0, max_word_len = 0;
121
122   for (text_ptr = text; *text_ptr; text_ptr++)
123   {
124     word_len = (*text_ptr != ' ' &&
125                 *text_ptr != '?' &&
126                 *text_ptr != '!' ? word_len + 1 : 0);
127
128     max_word_len = MAX(word_len, max_word_len);
129   }
130
131   return max_word_len;
132 }
133
134
135 // ============================================================================
136 // simple text drawing functions
137 // ============================================================================
138
139 void DrawInitText(char *text, int ypos, int font_nr)
140 {
141   if (window != NULL &&
142       gfx.draw_init_text &&
143       gfx.num_fonts > 0 &&
144       gfx.font_bitmap_info[font_nr].bitmap != NULL)
145   {
146     int x = (video.width - getTextWidth(text, font_nr)) / 2;
147     int y = ypos;
148     int width = video.width;
149     int height = getFontHeight(font_nr);
150
151     ClearRectangle(drawto, 0, y, width, height);
152     DrawTextExt(drawto, x, y, text, font_nr, BLIT_OPAQUE);
153
154     BlitBitmap(drawto, window, 0, 0, video.width, video.height, 0, 0);
155   }
156 }
157
158 void DrawInitTextHead(char *text)
159 {
160   // always draw headlines when loading initial stuff
161   LimitScreenUpdates(FALSE);
162
163   UPDATE_BUSY_STATE();
164
165   DrawInitText(text, 120, FC_GREEN);
166 }
167
168 void DrawInitTextItem(char *text)
169 {
170   // limit drawing (potentially many) loading items
171   LimitScreenUpdates(TRUE);
172
173   UPDATE_BUSY_STATE();
174
175   DrawInitText(text, 150, FC_YELLOW);
176 }
177
178 void DrawTextF(int x, int y, int font_nr, char *format, ...)
179 {
180   char buffer[MAX_OUTPUT_LINESIZE + 1];
181   va_list ap;
182
183   va_start(ap, format);
184   vsprintf(buffer, format, ap);
185   va_end(ap);
186
187   if (strlen(buffer) > MAX_OUTPUT_LINESIZE)
188     Fail("string too long in DrawTextF() -- aborting");
189
190   DrawText(gfx.sx + x, gfx.sy + y, buffer, font_nr);
191 }
192
193 void DrawTextFCentered(int y, int font_nr, char *format, ...)
194 {
195   char buffer[MAX_OUTPUT_LINESIZE + 1];
196   va_list ap;
197
198   va_start(ap, format);
199   vsprintf(buffer, format, ap);
200   va_end(ap);
201
202   if (strlen(buffer) > MAX_OUTPUT_LINESIZE)
203     Fail("string too long in DrawTextFCentered() -- aborting");
204
205   DrawText(gfx.sx + (gfx.sxsize - getTextWidth(buffer, font_nr)) / 2,
206            gfx.sy + y, buffer, font_nr);
207 }
208
209 void DrawTextS(int x, int y, int font_nr, char *text)
210 {
211   DrawText(gfx.sx + x, gfx.sy + y, text, font_nr);
212 }
213
214 void DrawTextSCentered(int y, int font_nr, char *text)
215 {
216   DrawText(gfx.sx + (gfx.sxsize - getTextWidth(text, font_nr)) / 2,
217            gfx.sy + y, text, font_nr);
218 }
219
220 void DrawTextSAligned(int x, int y, char *text, int font_nr, int align)
221 {
222   DrawText(gfx.sx + ALIGNED_XPOS(x, getTextWidth(text, font_nr), align),
223            gfx.sy + y, text, font_nr);
224 }
225
226 void DrawTextAligned(int x, int y, char *text, int font_nr, int align)
227 {
228   DrawText(ALIGNED_XPOS(x, getTextWidth(text, font_nr), align),
229            y, text, font_nr);
230 }
231
232 void DrawText(int x, int y, char *text, int font_nr)
233 {
234   int mask_mode = BLIT_OPAQUE;
235
236   if (DrawingOnBackground(x, y))
237     mask_mode = BLIT_ON_BACKGROUND;
238
239   DrawTextExt(drawto, x, y, text, font_nr, mask_mode);
240
241   if (IN_GFX_FIELD_FULL(x, y))
242     redraw_mask |= REDRAW_FIELD;
243   else if (IN_GFX_DOOR_1(x, y))
244     redraw_mask |= REDRAW_DOOR_1;
245   else if (IN_GFX_DOOR_2(x, y))
246     redraw_mask |= REDRAW_DOOR_2;
247   else if (IN_GFX_DOOR_3(x, y))
248     redraw_mask |= REDRAW_DOOR_3;
249   else
250     redraw_mask |= REDRAW_ALL;
251 }
252
253 void DrawTextExt(DrawBuffer *dst_bitmap, int dst_x, int dst_y, char *text,
254                  int font_nr, int mask_mode)
255 {
256   struct FontBitmapInfo *font = getFontBitmapInfo(font_nr);
257   int font_width = getFontWidth(font_nr);
258   int font_height = getFontHeight(font_nr);
259   Bitmap *src_bitmap;
260   int src_x, src_y;
261   char *text_ptr = text;
262
263   if (font->bitmap == NULL)
264     return;
265
266   // skip text to be printed outside the window (left/right will be clipped)
267   if (dst_y < 0 || dst_y + font_height > video.height)
268     return;
269
270   // add offset for drawing font characters
271   dst_x += font->draw_xoffset;
272   dst_y += font->draw_yoffset;
273
274   while (*text_ptr)
275   {
276     char c = *text_ptr++;
277
278     if (c == '\n')
279       c = ' ';          // print space instead of newline
280
281     getFontCharSource(font_nr, c, &src_bitmap, &src_x, &src_y);
282
283     // clip text at the left side of the window
284     if (dst_x < 0)
285     {
286       dst_x += font_width;
287
288       continue;
289     }
290
291     // clip text at the right side of the window
292     if (dst_x + font_width > video.width)
293       break;
294
295     if (mask_mode == BLIT_INVERSE)      // special mode for text gadgets
296     {
297       // first step: draw solid colored rectangle (use "cursor" character)
298       if (strlen(text) == 1)    // only one char inverted => draw cursor
299       {
300         Bitmap *cursor_bitmap;
301         int cursor_x, cursor_y;
302
303         getFontCharSource(font_nr, FONT_ASCII_CURSOR, &cursor_bitmap,
304                           &cursor_x, &cursor_y);
305
306         BlitBitmap(cursor_bitmap, dst_bitmap, cursor_x, cursor_y,
307                    font_width, font_height, dst_x, dst_y);
308       }
309
310       // second step: draw masked inverted character
311       SDLCopyInverseMasked(src_bitmap, dst_bitmap, src_x, src_y,
312                            font_width, font_height, dst_x, dst_y);
313     }
314     else if (mask_mode == BLIT_MASKED || mask_mode == BLIT_ON_BACKGROUND)
315     {
316       if (mask_mode == BLIT_ON_BACKGROUND)
317       {
318         // clear font character background
319         ClearRectangleOnBackground(dst_bitmap, dst_x, dst_y,
320                                    font_width, font_height);
321       }
322
323       BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y,
324                        font_width, font_height, dst_x, dst_y);
325     }
326     else        // normal, non-masked font blitting
327     {
328       BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y,
329                  font_width, font_height, dst_x, dst_y);
330     }
331
332     dst_x += font_width;
333   }
334 }
335
336
337 // ============================================================================
338 // text buffer drawing functions
339 // ============================================================================
340
341 #define MAX_LINES_FROM_FILE             1024
342
343 char *GetTextBufferFromFile(char *filename, int max_lines)
344 {
345   File *file;
346   char *buffer;
347   int num_lines = 0;
348
349   if (filename == NULL)
350     return NULL;
351
352   if (!(file = openFile(filename, MODE_READ)))
353     return NULL;
354
355   buffer = checked_calloc(1);   // start with valid, but empty text buffer
356
357   while (!checkEndOfFile(file) && num_lines < max_lines)
358   {
359     char line[MAX_LINE_LEN];
360
361     // read next line of input file
362     if (!getStringFromFile(file, line, MAX_LINE_LEN))
363       break;
364
365     buffer = checked_realloc(buffer, strlen(buffer) + strlen(line) + 1);
366
367     strcat(buffer, line);
368
369     num_lines++;
370   }
371
372   closeFile(file);
373
374   return buffer;
375 }
376
377 static boolean RenderLineToBuffer(char **src_buffer_ptr, char *dst_buffer,
378                                   int *dst_buffer_len, int line_length,
379                                   boolean last_line_was_empty)
380 {
381   char *text_ptr = *src_buffer_ptr;
382   char *buffer = dst_buffer;
383   int buffer_len = *dst_buffer_len;
384   boolean buffer_filled = FALSE;
385
386   while (*text_ptr)
387   {
388     char *word_ptr;
389     int word_len;
390
391     // skip leading whitespaces
392     while (*text_ptr == ' ' || *text_ptr == '\t')
393       text_ptr++;
394
395     word_ptr = text_ptr;
396     word_len = 0;
397
398     // look for end of next word
399     while (*word_ptr != ' ' && *word_ptr != '\t' && *word_ptr != '\0')
400     {
401       word_ptr++;
402       word_len++;
403     }
404
405     if (word_len == 0)
406     {
407       continue;
408     }
409     else if (*text_ptr == '\n')         // special case: force empty line
410     {
411       if (buffer_len == 0)
412         text_ptr++;
413
414       // prevent printing of multiple empty lines
415       if (buffer_len > 0 || !last_line_was_empty)
416         buffer_filled = TRUE;
417     }
418     else if (word_len < line_length - buffer_len)
419     {
420       // word fits into text buffer -- add word
421
422       if (buffer_len > 0)
423         buffer[buffer_len++] = ' ';
424
425       strncpy(&buffer[buffer_len], text_ptr, word_len);
426       buffer_len += word_len;
427       buffer[buffer_len] = '\0';
428       text_ptr += word_len;
429     }
430     else if (buffer_len > 0)
431     {
432       // not enough space left for word in text buffer -- print buffer
433
434       buffer_filled = TRUE;
435     }
436     else
437     {
438       // word does not fit at all into empty text buffer -- cut word
439
440       strncpy(buffer, text_ptr, line_length);
441       buffer[line_length] = '\0';
442       text_ptr += line_length;
443       buffer_filled = TRUE;
444     }
445
446     if (buffer_filled)
447       break;
448   }
449
450   *src_buffer_ptr = text_ptr;
451   *dst_buffer_len = buffer_len;
452
453   return buffer_filled;
454 }
455
456 static boolean getCheckedTokenValueFromString(char *string, char **token,
457                                               char **value)
458 {
459   char *ptr;
460
461   if (!getTokenValueFromString(string, token, value))
462     return FALSE;
463
464   if (**token != '.')                   // token should begin with dot
465     return FALSE;
466
467   for (ptr = *token; *ptr; ptr++)       // token should contain no whitespace
468     if (*ptr == ' ' || *ptr == '\t')
469       return FALSE;
470
471   for (ptr = *value; *ptr; ptr++)       // value should contain no whitespace
472     if (*ptr == ' ' || *ptr == '\t')
473       return FALSE;
474
475   return TRUE;
476 }
477
478 static void DrawTextBuffer_Flush(int x, int y, char *buffer, int font_nr,
479                                  int line_length, int cut_length,
480                                  int mask_mode, boolean centered,
481                                  int current_ypos)
482 {
483   int buffer_len = strlen(buffer);
484   int font_width = getFontWidth(font_nr);
485   int offset_chars = (centered ? (line_length - buffer_len) / 2 : 0);
486   int offset_xsize =
487     (centered ? font_width * (line_length - buffer_len) / 2 : 0);
488   int final_cut_length = MAX(0, cut_length - offset_chars);
489   int xx = x + offset_xsize;
490   int yy = y + current_ypos;
491
492   buffer[final_cut_length] = '\0';
493
494   if (mask_mode != -1)
495     DrawTextExt(drawto, xx, yy, buffer, font_nr, mask_mode);
496   else
497     DrawText(xx, yy, buffer, font_nr);
498 }
499
500 int DrawTextBuffer(int x, int y, char *text_buffer, int font_nr,
501                    int line_length, int cut_length, int max_lines,
502                    int line_spacing, int mask_mode, boolean autowrap,
503                    boolean centered, boolean parse_comments)
504 {
505   char buffer[line_length + 1];
506   int buffer_len;
507   int font_height = getFontHeight(font_nr);
508   int line_height = font_height + line_spacing;
509   int current_line = 0;
510   int current_ypos = 0;
511   int max_ysize = max_lines * line_height;
512
513   if (text_buffer == NULL || *text_buffer == '\0')
514     return 0;
515
516   if (current_line >= max_lines)
517     return 0;
518
519   if (cut_length == -1)
520     cut_length = line_length;
521
522   buffer[0] = '\0';
523   buffer_len = 0;
524
525   while (*text_buffer && current_ypos < max_ysize)
526   {
527     char line[MAX_LINE_LEN + 1];
528     char *line_ptr;
529     boolean last_line_was_empty = TRUE;
530     int num_line_chars = MAX_LINE_LEN;
531     int i;
532
533     // copy next line from text buffer to line buffer (nearly fgets() style)
534     for (i = 0; i < num_line_chars && *text_buffer; i++)
535       if ((line[i] = *text_buffer++) == '\n')
536         break;
537     line[i] = '\0';
538
539     // prevent 'num_line_chars' sized lines to cause additional empty line
540     if (i == num_line_chars && *text_buffer == '\n')
541       text_buffer++;
542
543     // skip comments (lines directly beginning with '#')
544     if (line[0] == '#' && parse_comments)
545     {
546       char *token, *value;
547
548       // try to read generic token/value pair definition after comment sign
549       if (getCheckedTokenValueFromString(line + 1, &token, &value))
550       {
551         // if found, flush the current buffer, if non-empty
552         if (buffer_len > 0 && current_ypos < max_ysize)
553         {
554           DrawTextBuffer_Flush(x, y, buffer, font_nr, line_length, cut_length,
555                                mask_mode, centered, current_ypos);
556           current_ypos += line_height;
557           current_line++;
558
559           buffer[0] = '\0';
560           buffer_len = 0;
561         }
562
563         if (strEqual(token, ".font"))
564           font_nr = gfx.get_font_from_token_function(value);
565         else if (strEqual(token, ".autowrap"))
566           autowrap = get_boolean_from_string(value);
567         else if (strEqual(token, ".centered"))
568           centered = get_boolean_from_string(value);
569         else if (strEqual(token, ".parse_comments"))
570           parse_comments = get_boolean_from_string(value);
571
572         // if font has changed, depending values need to be updated as well
573         font_height = getFontHeight(font_nr);
574         line_height = font_height + line_spacing;
575       }
576
577       continue;
578     }
579
580     // cut trailing newline and carriage return from input line
581     for (line_ptr = line; *line_ptr; line_ptr++)
582     {
583       if (*line_ptr == '\n' || *line_ptr == '\r')
584       {
585         *line_ptr = '\0';
586         break;
587       }
588     }
589
590     if (strlen(line) == 0)              // special case: force empty line
591       strcpy(line, "\n");
592
593     line_ptr = line;
594
595     while (*line_ptr && current_ypos < max_ysize)
596     {
597       boolean buffer_filled;
598
599       if (autowrap)
600       {
601         buffer_filled = RenderLineToBuffer(&line_ptr, buffer, &buffer_len,
602                                            line_length, last_line_was_empty);
603       }
604       else
605       {
606         if (strlen(line_ptr) <= line_length)
607         {
608           buffer_len = strlen(line_ptr);
609           strcpy(buffer, line_ptr);
610         }
611         else
612         {
613           buffer_len = line_length;
614           strncpy(buffer, line_ptr, line_length);
615         }
616
617         buffer[buffer_len] = '\0';
618         line_ptr += buffer_len;
619
620         buffer_filled = TRUE;
621       }
622
623       if (buffer_filled)
624       {
625         DrawTextBuffer_Flush(x, y, buffer, font_nr, line_length, cut_length,
626                              mask_mode, centered, current_ypos);
627         current_ypos += line_height;
628         current_line++;
629
630         last_line_was_empty = (buffer_len == 0);
631
632         buffer[0] = '\0';
633         buffer_len = 0;
634       }
635     }
636   }
637
638   if (buffer_len > 0 && current_ypos < max_ysize)
639   {
640     DrawTextBuffer_Flush(x, y, buffer, font_nr, line_length, cut_length,
641                          mask_mode, centered, current_ypos);
642     current_ypos += line_height;
643     current_line++;
644   }
645
646   return current_line;
647 }
648
649 int DrawTextBufferVA(int x, int y, char *format, va_list ap, int font_nr,
650                      int line_length, int cut_length, int max_lines,
651                      int line_spacing, int mask_mode, boolean autowrap,
652                      boolean centered, boolean parse_comments)
653 {
654   char text_buffer[MAX_OUTPUT_LINESIZE];
655   int text_length = vsnprintf(text_buffer, MAX_OUTPUT_LINESIZE, format, ap);
656
657   if (text_length >= MAX_OUTPUT_LINESIZE)
658     Warn("string too long in DrawTextBufferVA() -- truncated");
659
660   int num_lines_printed = DrawTextBuffer(x, y, text_buffer, font_nr,
661                                          line_length, cut_length, max_lines,
662                                          line_spacing, mask_mode, autowrap,
663                                          centered, parse_comments);
664   return num_lines_printed;
665 }
666
667 int DrawTextFile(int x, int y, char *filename, int font_nr,
668                  int line_length, int cut_length, int max_lines,
669                  int line_spacing, int mask_mode, boolean autowrap,
670                  boolean centered, boolean parse_comments)
671 {
672   char *text_buffer = GetTextBufferFromFile(filename, MAX_LINES_FROM_FILE);
673   int num_lines_printed = DrawTextBuffer(x, y, text_buffer, font_nr,
674                                          line_length, cut_length, max_lines,
675                                          line_spacing, mask_mode, autowrap,
676                                          centered, parse_comments);
677   checked_free(text_buffer);
678
679   return num_lines_printed;
680 }