apps/plugins/dice.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Brandon Low
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "plugin.h"
  23 #include "lib/pluginlib_actions.h"
  24 #include "lib/configfile.h"
  25
  26 #define MAX_DICES 12
  27 #define INITIAL_NB_DICES 1
  28 #define INITIAL_NB_SIDES 2 /* corresponds to 6 sides in the array */
  29
  30 #define DICE_QUIT PLA_QUIT
  31 #define DICE_ROLL PLA_START
  32
  33
  34 #define CFG_FILE "dice.cfg"
  35
  36 const struct button_mapping* plugin_contexts[]={generic_actions};
  37
  38 struct dices
  39 {
  40     int values[MAX_DICES];
  41     int total;
  42     int nb_dices;
  43     int nb_sides;
  44 };
  45
  46 #define PRINT_BUFFER_LENGTH MAX_DICES*4
  47 PLUGIN_HEADER
  48
  49 static const struct plugin_api* rb;
  50 static struct dices dice;
  51 static int sides_index;
  52
  53 static struct opt_items nb_sides_option[8] = {
  54     { "3", -1 },
  55     { "4", -1 },
  56     { "6", -1 },
  57     { "8", -1 },
  58     { "10", -1 },
  59     { "12", -1 },
  60     { "20", -1 },
  61     { "100", -1 }
  62 };
  63 static int nb_sides_values[] = { 3, 4, 6, 8, 10, 12, 20, 100 };
  64 static char *sides_conf[] = {"3", "4", "6", "8", "10", "12", "20", "100" };
  65 static struct configdata config[] =
  66 {
  67     {TYPE_INT, 0, MAX_DICES, &dice.nb_dices, "dice count", NULL, NULL},
  68     {TYPE_ENUM, 0, 8, &sides_index, "side count", sides_conf, NULL}
  69 };
  70
  71 void dice_init(struct dices* dice);
  72 void dice_roll(struct dices* dice);
  73 void dice_print(struct dices* dice, struct screen* display);
  74 bool dice_menu(struct dices* dice);
  75
  76 /* plugin entry point */
  77 enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter) {
  78     (void)parameter;
  79     rb = api;
  80     int i, action;
  81
  82     dice_init(&dice);
  83     rb->srand(*rb->current_tick);
  84
  85     configfile_init(rb);
  86     configfile_load(CFG_FILE, config, 2, 0);
  87     dice.nb_sides = nb_sides_values[sides_index];
  88     if(!dice_menu(&dice))
  89     {
  90         configfile_save(CFG_FILE, config, 2, 0);
  91         return PLUGIN_OK;
  92     }
  93     configfile_save(CFG_FILE, config, 2, 0);
  94     dice_roll(&dice);
  95     FOR_NB_SCREENS(i)
  96         dice_print( &dice, rb->screens[i] );
  97     while(true) {
  98         action = pluginlib_getaction(rb, TIMEOUT_BLOCK,
  99                                      plugin_contexts, 1);
 100         switch(action) {
 101             case DICE_ROLL:
 102                 dice_roll(&dice);
 103                 FOR_NB_SCREENS(i)
 104                     dice_print( &dice, rb->screens[i] );
 105                 break;
 106             case DICE_QUIT:
 107                 return PLUGIN_OK;
 108         }
 109     }
 110 }
 111
 112 void dice_init(struct dices* dice){
 113     dice->nb_dices=INITIAL_NB_DICES;
 114     sides_index=INITIAL_NB_SIDES;
 115
 116 }
 117
 118 void dice_roll(struct dices* dice) {
 119     int i;
 120     dice->total = 0;
 121     for (i=0; i<dice->nb_dices; i++) {
 122         dice->values[i] = rb->rand()%dice->nb_sides + 1;
 123         dice->total+=dice->values[i];
 124     }
 125 }
 126
 127 void dice_print_string_buffer(struct dices* dice, char* buffer,
 128                               int start, int end){
 129     int i, written;
 130     for (i=start; i<end; i++) {
 131         written=rb->snprintf(buffer, PRINT_BUFFER_LENGTH,
 132                              " %3d", dice->values[i]);
 133         buffer=&(buffer[written]);
 134     }
 135 }
 136
 137 void dice_print(struct dices* dice, struct screen* display){
 138     char buffer[PRINT_BUFFER_LENGTH];
 139     /* display characteristics */
 140     int char_height, char_width;
 141     display->getstringsize("M", &char_width, &char_height);
 142     int display_nb_row=display->getheight()/char_height;
 143     int display_nb_col=display->getwidth()/char_width;
 144
 145     int nb_dices_per_line=display_nb_col/4;/* 4 char per dice displayed*/
 146     int nb_lines_required=dice->nb_dices/nb_dices_per_line;
 147     int current_row=0;
 148     if(dice->nb_dices%nb_dices_per_line!=0)
 149         nb_lines_required++;
 150     display->clear_display();
 151     if(display_nb_row<nb_lines_required){
 152         /* Put everything on the same scrolling line */
 153         dice_print_string_buffer(dice, buffer, 0, dice->nb_dices);
 154         display->puts_scroll(0, current_row, buffer);
 155         current_row++;
 156     }else{
 157         int start=0;
 158         int end=0;
 159         for(;current_row<nb_lines_required;current_row++){
 160             end=start+nb_dices_per_line;
 161             if(end>dice->nb_dices)
 162                 end=dice->nb_dices;
 163             dice_print_string_buffer(dice, buffer, start, end);
 164             display->puts(0, current_row, buffer);
 165             start=end;
 166         }
 167     }
 168     rb->snprintf(buffer, PRINT_BUFFER_LENGTH, "Total: %d", dice->total);
 169     display->puts_scroll(0, current_row, buffer);
 170     display->update();
 171 }
 172
 173 bool dice_menu(struct dices * dice) {
 174     int selection;
 175     bool menu_quit = false, result = false;
 176
 177     MENUITEM_STRINGLIST(menu,"Dice Menu",NULL,"Roll Dice","Number of Dice",
 178                         "Number of Sides","Quit");
 179
 180
 181     while (!menu_quit) {
 182         switch(rb->do_menu(&menu, &selection, NULL, false)){
 183             case 0:
 184                 menu_quit = true;
 185                 result = true;
 186                 break;
 187
 188             case 1:
 189                 rb->set_int("Number of Dice", "", UNIT_INT, &(dice->nb_dices),
 190                             NULL, 1, 1, MAX_DICES, NULL );
 191                 break;
 192
 193             case 2:
 194                 rb->set_option("Number of Sides", &sides_index, INT,
 195                                nb_sides_option,
 196                                sizeof(nb_sides_values)/sizeof(int), NULL);
 197                 dice->nb_sides=nb_sides_values[sides_index];
 198                 break;
 199
 200             default:
 201                 menu_quit = true;
 202                 result = false;
 203                 break;
 204          }
 205     }
 206     return result;
 207 }