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 #include "lib/playback_control.h"
  26
  27 #define MAX_DICES 12
  28 #define INITIAL_NB_DICES 1
  29 #define INITIAL_NB_SIDES 2 /* corresponds to 6 sides in the array */
  30
  31 #define DICE_QUIT PLA_CANCEL
  32 #define DICE_ROLL PLA_SELECT
  33
  34
  35 #define CFG_FILE "dice.cfg"
  36
  37 const struct button_mapping* plugin_contexts[]={pla_main_ctx};
  38
  39 struct dices
  40 {
  41     int values[MAX_DICES];
  42     int total;
  43     int nb_dices;
  44     int nb_sides;
  45 };
  46
  47 #define PRINT_BUFFER_LENGTH MAX_DICES*4
  48
  49
  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, { .int_p = &dice.nb_dices}, "dice count", NULL},
  68     {TYPE_ENUM, 0, 8, { .int_p = &sides_index }, "side count", sides_conf}
  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 void* parameter) {
  78     (void)parameter;
  79     int i, action;
  80
  81     dice_init(&dice);
  82     rb->srand(*rb->current_tick);
  83
  84     configfile_load(CFG_FILE, config, 2, 0);
  85     dice.nb_sides = nb_sides_values[sides_index];
  86     if(!dice_menu(&dice))
  87     {
  88         configfile_save(CFG_FILE, config, 2, 0);
  89         return PLUGIN_OK;
  90     }
  91     configfile_save(CFG_FILE, config, 2, 0);
  92     dice_roll(&dice);
  93     FOR_NB_SCREENS(i)
  94         dice_print( &dice, rb->screens[i] );
  95     while(true) {
  96         action = pluginlib_getaction(TIMEOUT_BLOCK,
  97                                      plugin_contexts, ARRAYLEN(plugin_contexts));
  98         switch(action) {
  99             case DICE_ROLL:
 100                 dice_roll(&dice);
 101                 FOR_NB_SCREENS(i)
 102                     dice_print( &dice, rb->screens[i] );
 103                 break;
 104             case DICE_QUIT:
 105                 return PLUGIN_OK;
 106         }
 107     }
 108 }
 109
 110 void dice_init(struct dices* dice){
 111     dice->nb_dices=INITIAL_NB_DICES;
 112     sides_index=INITIAL_NB_SIDES;
 113
 114 }
 115
 116 void dice_roll(struct dices* dice) {
 117     int i;
 118     dice->total = 0;
 119     for (i=0; i<dice->nb_dices; i++) {
 120         dice->values[i] = rb->rand()%dice->nb_sides + 1;
 121         dice->total+=dice->values[i];
 122     }
 123 }
 124
 125 void dice_print_string_buffer(struct dices* dice, char* buffer,
 126                               int start, int end){
 127     int i, written;
 128     for (i=start; i<end; i++) {
 129         written=rb->snprintf(buffer, PRINT_BUFFER_LENGTH,
 130                              " %3d", dice->values[i]);
 131         buffer=&(buffer[written]);
 132     }
 133 }
 134
 135 void dice_print(struct dices* dice, struct screen* display){
 136     char buffer[PRINT_BUFFER_LENGTH];
 137     /* display characteristics */
 138     int char_height, char_width;
 139     display->getstringsize("M", &char_width, &char_height);
 140     int display_nb_row=display->getheight()/char_height;
 141     int display_nb_col=display->getwidth()/char_width;
 142
 143     int nb_dices_per_line=display_nb_col/4;/* 4 char per dice displayed*/
 144     if(!nb_dices_per_line)
 145         nb_dices_per_line++;
 146
 147     int nb_lines_required=dice->nb_dices/nb_dices_per_line;
 148     int current_row=0;
 149     if(dice->nb_dices%nb_dices_per_line!=0)
 150         nb_lines_required++;
 151     display->clear_display();
 152     if(display_nb_row<nb_lines_required){
 153         /* Put everything on the same scrolling line */
 154         dice_print_string_buffer(dice, buffer, 0, dice->nb_dices);
 155         display->puts_scroll(0, current_row, buffer);
 156         current_row++;
 157     }else{
 158         int start=0;
 159         int end=0;
 160         for(;current_row<nb_lines_required;current_row++){
 161             end=start+nb_dices_per_line;
 162             if(end>dice->nb_dices)
 163                 end=dice->nb_dices;
 164             dice_print_string_buffer(dice, buffer, start, end);
 165             display->puts(0, current_row, buffer);
 166             start=end;
 167         }
 168     }
 169     rb->snprintf(buffer, PRINT_BUFFER_LENGTH, "Total: %d", dice->total);
 170     display->puts_scroll(0, current_row, buffer);
 171     display->update();
 172 }
 173
 174 bool dice_menu(struct dices * dice) {
 175     int selection;
 176     bool menu_quit = false, result = false;
 177
 178     MENUITEM_STRINGLIST(menu, "Dice Menu", NULL,
 179                         "Roll Dice",
 180                         "Number of Dice", "Number of Sides",
 181                         "Playback Control", "Quit");
 182
 183
 184     while (!menu_quit) {
 185         switch(rb->do_menu(&menu, &selection, NULL, false)){
 186             case 0:
 187                 menu_quit = true;
 188                 result = true;
 189                 break;
 190
 191             case 1:
 192                 rb->set_int("Number of Dice", "", UNIT_INT, &(dice->nb_dices),
 193                             NULL, 1, 1, MAX_DICES, NULL );
 194                 break;
 195
 196             case 2:
 197                 rb->set_option("Number of Sides", &sides_index, INT,
 198                                nb_sides_option,
 199                                sizeof(nb_sides_values)/sizeof(int), NULL);
 200                 dice->nb_sides=nb_sides_values[sides_index];
 201                 break;
 202
 203             case 3:
 204                 playback_control(NULL);
 205                 break;
 206
 207             default:
 208                 menu_quit = true;
 209                 result = false;
 210                 break;
 211         }
 212     }
 213     return result;
 214 }