home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 115 / af115sub.adf / yahzee.lzx / yahzee / draw.c < prev    next >
C/C++ Source or Header  |  1998-06-03  |  10KB  |  351 lines
  1. /*
  2.  * draw.c
  3.  * ======
  4.  * Functions for drawing the scoreboard.
  5.  *
  6.  * Copyright © 1994-1998 Håkan L. Younes (lorens@hem.passagen.se)
  7.  */
  8.  
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <exec/types.h>
  12. #include <graphics/rastport.h>
  13. #include <intuition/screens.h>
  14. #include "localize.h"
  15. #include "rules.h"
  16. #include "layout_const.h"
  17. #include "draw.h"
  18.  
  19. #include <clib/graphics_protos.h>
  20.  
  21.  
  22. #define NUM_BOARDPENS   (BOARD_FILLPEN + 1)
  23.  
  24. UWORD   board_pens[NUM_BOARDPENS] = { 0, 0, 1, 1, 2, 3 };
  25. BOOL    locked_pens[NUM_BOARDPENS] = { 0, 0, 0, 0, 0, 0 };
  26. static const UBYTE   default_pens[NUM_BOARDPENS] = {
  27.    BACKGROUNDPEN, BACKGROUNDPEN, SHADOWPEN, TEXTPEN, HIGHLIGHTTEXTPEN, FILLPEN
  28. };
  29.  
  30. struct box   upper_board, lower_board;
  31. struct box   board_grid[MAX_PLAYERS + 1][MAX_LABELS];
  32.  
  33.  
  34. static void
  35. draw_line (
  36.    struct RastPort  *rp,
  37.    WORD              x_pos,
  38.    WORD              y_pos,
  39.    UWORD             x_ext,
  40.    UWORD             y_ext)
  41. {
  42.    Move (rp, x_pos, y_pos);
  43.    Draw (rp, x_pos + x_ext - 1, y_pos + y_ext - 1);
  44. }
  45.  
  46.  
  47. void
  48. init_board_pens (
  49.    UWORD  *gui_pens)
  50. {
  51.    register UBYTE   n;
  52.    
  53.    if (gui_pens != NULL)
  54.       for (n = 0; n < NUM_BOARDPENS; ++n)
  55.          if (!locked_pens[n])
  56.             board_pens[n] = gui_pens[default_pens[n]];
  57. }
  58.  
  59. void
  60. delete_gadgets (
  61.    struct RastPort  *rp,
  62.    struct Gadget    *gad)
  63. {
  64.    SetAPen (rp, board_pens[BOARD_BACKGROUNDPEN]);
  65.    
  66.    while (gad != NULL)
  67.    {
  68.       if (gad->Width != 0 && gad->Height != 0)
  69.       {
  70.          RectFill (rp, gad->LeftEdge, gad->TopEdge,
  71.                    gad->LeftEdge + gad->Width - 1,
  72.                    gad->TopEdge + gad->Height - 1);
  73.       }
  74.       gad = gad->NextGadget;
  75.    }
  76. }
  77.  
  78. void
  79. draw_scoreboard (
  80.    struct RastPort  *rp,
  81.    struct rules     *rules,
  82.    UBYTE             num_players)
  83. {
  84.    register UBYTE   n;
  85.    register WORD    coord;
  86.    struct box  *board_box;
  87.    char        *label_str;
  88.    UBYTE   limit;
  89.    
  90.    limit = num_upper_labels (rules);
  91.    board_box = &upper_board;
  92.    while (board_box != NULL)
  93.    {
  94.       /* draw background */
  95.       SetAPen (rp, board_pens[BOARD_PAPERPEN]);
  96.       RectFill (rp,
  97.                 board_box->left, board_box->top,
  98.                 board_box->left + board_box->width - 1,
  99.                 board_box->top + board_box->height - 1);
  100.       
  101.       /* draw horizontal lines and labels */
  102.       SetAPen (rp, board_pens[BOARD_LINEPEN]);
  103.       coord = board_box->top;
  104.       if (!(board_box == &lower_board && lower_board.left == upper_board.left))
  105.       {
  106.          while (coord < board_box->top + LINEHEIGHT)
  107.          {
  108.             draw_line (rp, board_box->left, coord, board_box->width, 1);
  109.             ++coord;
  110.          }
  111.          coord += board_grid[0][0].height;
  112.       }
  113.       for (n = ((board_box == &upper_board) ? 0 : limit);
  114.            n < ((board_box == &upper_board) ? limit : MAX_LABELS);
  115.            ++n)
  116.       {
  117.          if (!rules->labels[n])
  118.             ++limit;
  119.          else
  120.          {
  121.             if (n == UPPER_TOTAL || n == BONUS ||
  122.                 n == TOTAL || n == SAVED_ROLLS)
  123.             {
  124.                SetAPen (rp, board_pens[BOARD_HIGHLIGHTPEN]);
  125.             }
  126.             else
  127.                SetAPen (rp, board_pens[BOARD_TEXTPEN]);
  128.             Move (rp,
  129.                   board_grid[0][n].left + INTERWIDTH / 4,
  130.                   board_grid[0][n].top + rp->TxBaseline +
  131.                   (board_grid[0][n].height - rp->TxHeight) / 2);
  132.             label_str = localized_string ((n == YAHZEE) ?
  133.                                           rules->yahzee_label :
  134.                                           label_msg[n]);
  135.             Text (rp, label_str, strlen (label_str));
  136.    
  137.             SetAPen (rp, board_pens[BOARD_LINEPEN]);
  138.             while (coord < board_grid[0][n].top)
  139.             {
  140.                draw_line (rp, board_box->left, coord, board_box->width, 1);
  141.                ++coord;
  142.             }
  143.             coord += board_grid[0][n].height;
  144.          }
  145.       }
  146.       while (coord < board_box->top + board_box->height)
  147.       {
  148.          draw_line (rp, board_box->left, coord, board_box->width, 1);
  149.          ++coord;
  150.       }
  151.       
  152.       /* draw vertical lines */
  153.       coord = board_box->left;
  154.       for (n = 0; n <= num_players; ++n)
  155.       {
  156.          while (coord <
  157.                 board_grid[n][(board_box == &upper_board) ? 0 : TOTAL].left)
  158.          {
  159.             draw_line (rp, coord, board_box->top, 1, board_box->height);
  160.             ++coord;
  161.          }
  162.          coord += board_grid[n][(board_box == &upper_board) ? 0 : TOTAL].width;
  163.       }
  164.       while (coord < board_box->left + board_box->width)
  165.       {
  166.          draw_line (rp, coord, board_box->top, 1, board_box->height);
  167.          ++coord;
  168.       }
  169.       
  170.       board_box = (board_box == &upper_board) ? &lower_board : NULL;
  171.    }
  172. }
  173.  
  174. void
  175. delete_scoreboard (
  176.    struct RastPort  *rp)
  177. {
  178.    SetAPen (rp, board_pens[BOARD_BACKGROUNDPEN]);
  179.    RectFill (rp,
  180.              upper_board.left, upper_board.top,
  181.              upper_board.left + upper_board.width - 1,
  182.              upper_board.top + upper_board.height - 1);
  183.    RectFill (rp,
  184.              lower_board.left, lower_board.top,
  185.              lower_board.left + lower_board.width - 1,
  186.              lower_board.top + lower_board.height - 1);
  187. }
  188.  
  189. void
  190. reset_scoreboard (
  191.    struct RastPort  *rp,
  192.    struct rules     *rules,
  193.    UBYTE             num_players)
  194. {
  195.    register UBYTE   i, j;
  196.    UBYTE   limit;
  197.    
  198.    limit = num_upper_labels (rules);
  199.    /*delete old scores */
  200.    SetAPen (rp, board_pens[BOARD_PAPERPEN]);
  201.    for (i = 1; i <= num_players; ++i)
  202.    {
  203.       for (j = 0; j < MAX_LABELS; ++j)
  204.       {
  205.          if (rules->labels[j])
  206.          {
  207.             RectFill (rp,
  208.                       board_grid[i][j].left, board_grid[i][j].top,
  209.                       board_grid[i][j].left + board_grid[i][j].width - 1,
  210.                       board_grid[i][j].top + board_grid[i][j].height - 1);
  211.          }
  212.       }
  213.    }
  214.    
  215.    /* draw reset scores */
  216.    SetAPen (rp, board_pens[BOARD_HIGHLIGHTPEN]);
  217.    for (i = 1; i <= num_players; ++i)
  218.    {
  219.       for (j = UPPER_TOTAL; j < MAX_LABELS; ++j)
  220.       {
  221.          if (j == BONUS + 1)
  222.             j = TOTAL;
  223.          
  224.          if (rules->labels[j])
  225.          {
  226.             Move (rp,
  227.                   board_grid[i][j].left + INTERWIDTH / 4,
  228.                   board_grid[i][j].top + rp->TxBaseline +
  229.                   (board_grid[i][j].height - rp->TxHeight) / 2);
  230.             Text (rp, "  0", 3);
  231.          }
  232.       }
  233.    }
  234. }
  235.  
  236. void
  237. draw_player_numbers (
  238.    struct RastPort  *rp,
  239.    UBYTE             num_players,
  240.    UBYTE             current_player)
  241. {
  242.    register UBYTE   n;
  243.    char   buf[2];
  244.    
  245.    for (n = 1; n <= num_players; ++n)
  246.    {
  247.       sprintf (buf, "%d", n);
  248.       
  249.       if (n == current_player + 1)
  250.          SetAPen (rp, board_pens[BOARD_HIGHLIGHTPEN]);
  251.       else
  252.          SetAPen (rp, board_pens[BOARD_TEXTPEN]);
  253.       Move (rp,
  254.             board_grid[n][0].left + (board_grid[n][0].width - rp->TxWidth) / 2,
  255.             upper_board.top + LINEHEIGHT + rp->TxBaseline +
  256.             (board_grid[n][0].height - rp->TxHeight) / 2);
  257.       Text (rp, buf, strlen (buf));
  258.       
  259.       if (upper_board.left != lower_board.left)
  260.       {
  261.          Move (rp,
  262.                board_grid[n][TOTAL].left +
  263.                (board_grid[n][TOTAL].width - rp->TxWidth) / 2,
  264.                lower_board.top + LINEHEIGHT + rp->TxBaseline +
  265.                (board_grid[n][TOTAL].height - rp->TxHeight) / 2);
  266.          Text (rp, buf, strlen (buf));
  267.       }
  268.    }
  269. }
  270.  
  271. void
  272. draw_possible_score (
  273.    struct RastPort  *rp,
  274.    struct rules     *rules,
  275.    UWORD             current_player,
  276.    WORD              scoreboard[],
  277.    UBYTE             possible_score[])
  278. {
  279.    register UBYTE   n;
  280.    char   buf[4];
  281.    
  282.    for (n = 0; n < MAX_LABELS; ++n)
  283.    {
  284.       if (rules->labels[n] && (scoreboard[n] == -1 || n == SAVED_ROLLS))
  285.       {
  286.          if (n == SAVED_ROLLS)
  287.             sprintf (buf, "%d", scoreboard[n]);
  288.          else
  289.             sprintf (buf, "%d", possible_score[n]);
  290.          
  291.          SetAPen (rp, board_pens[(n == SAVED_ROLLS) ? BOARD_HIGHLIGHTPEN :
  292.                                                       BOARD_FILLPEN]);
  293.          Move (rp,
  294.                board_grid[current_player + 1][n].left + INTERWIDTH / 4,
  295.                board_grid[current_player + 1][n].top + rp->TxBaseline +
  296.                (board_grid[current_player + 1][n].height - rp->TxHeight) / 2);
  297.          Text (rp, "   ", 3 - strlen (buf));
  298.          Text (rp, buf, strlen (buf));
  299.       }
  300.    }
  301. }
  302.  
  303. void
  304. draw_chosen_score (
  305.    struct RastPort  *rp,
  306.    struct rules     *rules,
  307.    UBYTE             current_player,
  308.    WORD              scoreboard[],
  309.    BOOL              highlighted)
  310. {
  311.    register UBYTE   n;
  312.    char   buf[4];
  313.    
  314.    for (n = 0; n < MAX_LABELS; ++n)
  315.    {
  316.       if (rules->labels[n])
  317.       {
  318.          if (scoreboard[n] == -1)
  319.          {
  320.             SetAPen (rp, board_pens[BOARD_PAPERPEN]);
  321.             RectFill (rp,
  322.                       board_grid[current_player + 1][n].left,
  323.                       board_grid[current_player + 1][n].top,
  324.                       board_grid[current_player + 1][n].left +
  325.                       board_grid[current_player + 1][n].width - 1,
  326.                       board_grid[current_player + 1][n].top +
  327.                       board_grid[current_player + 1][n].height - 1);
  328.          }
  329.          else
  330.          {
  331.             sprintf (buf, "%d", scoreboard[n]);
  332.             
  333.             if (n == UPPER_TOTAL || n == BONUS ||
  334.                 n == TOTAL || n == SAVED_ROLLS || highlighted)
  335.             {
  336.                SetAPen (rp, board_pens[BOARD_HIGHLIGHTPEN]);
  337.             }
  338.             else
  339.                SetAPen (rp, board_pens[BOARD_TEXTPEN]);
  340.             
  341.             Move (rp,
  342.                 board_grid[current_player + 1][n].left + INTERWIDTH / 4,
  343.                 board_grid[current_player + 1][n].top + rp->TxBaseline +
  344.                 (board_grid[current_player + 1][n].height - rp->TxHeight) / 2);
  345.             Text (rp, "   ", 3 - strlen (buf));
  346.             Text (rp, buf, strlen (buf));
  347.          }
  348.       }
  349.    }
  350. }
  351.