Back to index

gcompris  8.2.2
Defines | Functions | Variables
reversecount.c File Reference
#include "gcompris/gcompris.h"

Go to the source code of this file.

Defines

#define SOUNDLISTFILE   PACKAGE
#define TUX_IMG_NORTH   "gcompris/misc/tux_top_north.png"
#define TUX_IMG_SOUTH   "gcompris/misc/tux_top_south.png"
#define TUX_IMG_WEST   "gcompris/misc/tux_top_west.png"
#define TUX_IMG_EAST   "gcompris/misc/tux_top_east.png"
#define TUX_TO_BORDER_GAP   10
#define ANIMATE_SPEED   800
#define NUMBER_OF_IMAGES   10
#define NUMBER_OF_FISHES   27

Functions

static void start_board (GcomprisBoard *agcomprisBoard)
static gint key_press (guint keyval, gchar *commit_str, gchar *preedit_str)
static void pause_board (gboolean pause)
static void end_board (void)
static gboolean is_our_board (GcomprisBoard *gcomprisBoard)
static void set_level (guint level)
static void game_won (void)
static void process_ok (void)
static void process_error (void)
static GnomeCanvasItem * reversecount_create_item (GnomeCanvasGroup *parent)
static void reversecount_destroy_all_items (void)
static void reversecount_next_level (void)
static gint item_event (GnomeCanvasItem *item, GdkEvent *event, gint *dice_index)
 Increment the dices when they are clicked.
static GnomeCanvasItem * display_item_at (gchar *imagename, int block, double ratio)
 Display given imagename on the given ice block.
static void display_random_fish ()
static void create_clock (double x, double y, int value)
static void update_clock (int value)
static gint animate_tux ()

Variables

static GcomprisBoard * gcomprisBoard = NULL
static gboolean board_paused = TRUE
static gint animate_id = 0
static int leavenow
static int gamewon
static GnomeCanvasGroup * boardRootItem = NULL
static int number_of_item = 0
static int number_of_item_x = 0
static int number_of_item_y = 0
static int errors = 0
static int number_of_dices = 0
static int max_dice_number = 0
static int number_of_fish = 0
static int tux_index = 0
static int tux_destination = 0
static int fish_index = 0
static int animate_speed = 0
static double tux_ratio = 0
static int dicevalue_array [10]
static GnomeCanvasItem * fishItem
static GnomeCanvasItem * tuxItem
static GnomeCanvasItem * clock_image_item
static gchar * imageList []
static gchar * fishList []
static BoardPlugin menu_bp

Define Documentation

#define ANIMATE_SPEED   800

Definition at line 72 of file reversecount.c.

#define NUMBER_OF_FISHES   27

Definition at line 126 of file reversecount.c.

#define NUMBER_OF_IMAGES   10

Definition at line 92 of file reversecount.c.

#define SOUNDLISTFILE   PACKAGE

Definition at line 22 of file reversecount.c.

#define TUX_IMG_EAST   "gcompris/misc/tux_top_east.png"

Definition at line 41 of file reversecount.c.

#define TUX_IMG_NORTH   "gcompris/misc/tux_top_north.png"

Definition at line 38 of file reversecount.c.

#define TUX_IMG_SOUTH   "gcompris/misc/tux_top_south.png"

Definition at line 39 of file reversecount.c.

#define TUX_IMG_WEST   "gcompris/misc/tux_top_west.png"

Definition at line 40 of file reversecount.c.

#define TUX_TO_BORDER_GAP   10

Definition at line 42 of file reversecount.c.


Function Documentation

static gint animate_tux ( ) [static]

Definition at line 781 of file reversecount.c.

{
  // Move tux
  if(tuxItem!=NULL)
    gtk_object_destroy(GTK_OBJECT(tuxItem));

  tux_index++;

  g_warning("=========== tux_index=%d tux_destination=%d fish_index=%d\n", tux_index, tux_destination, fish_index);

  // Wrapping
  if(tux_index >= number_of_item)
    tux_index = tux_index - (number_of_item);

  /* Caclulate which tux should be displayed */
  if(tux_index<number_of_item_x-1)
    tuxItem = display_item_at(TUX_IMG_EAST, tux_index, tux_ratio);
  else if(tux_index<number_of_item_x+number_of_item_y-2)
    tuxItem = display_item_at(TUX_IMG_SOUTH, tux_index, tux_ratio);
  else if(tux_index<2*number_of_item_x+number_of_item_y-3)
    tuxItem = display_item_at(TUX_IMG_WEST, tux_index, tux_ratio);
  else
    tuxItem = display_item_at(TUX_IMG_NORTH, tux_index, tux_ratio);

  /* Rearm the timer to go to the next spot */
  if(tux_index != tux_destination)
    {
      animate_id = gtk_timeout_add (animate_speed,
                                (GtkFunction) animate_tux, NULL);
    }
  else
    {
      animate_id = 0;

      if(tux_destination != fish_index)
       {
         process_error();
       }
      else
       {
         // Remove the fish
         if(fishItem!=NULL)
           gtk_object_destroy(GTK_OBJECT(fishItem));

         gc_sound_play_ogg ("sounds/gobble.ogg", NULL);

         if(--number_of_fish == 0)
           {
             gamewon = TRUE;
             reversecount_destroy_all_items();
             gc_bonus_display(gamewon, BONUS_SMILEY);
           }
         else
           {
             display_random_fish();
           }
       }
    }

  return(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void create_clock ( double  x,
double  y,
int  value 
) [static]

Definition at line 738 of file reversecount.c.

{
  GdkPixbuf   *pixmap = NULL;
  char       *str = NULL;

  if(value<0)
    return;

  str = g_strdup_printf("%s%d.png", "gcompris/timers/clock",value);

  pixmap = gc_pixmap_load(str);

  clock_image_item = gnome_canvas_item_new (boardRootItem,
                                       gnome_canvas_pixbuf_get_type (),
                                       "pixbuf", pixmap,
                                       "x", (double) x,
                                       "y", (double) y,
                                       NULL);

  gdk_pixbuf_unref(pixmap);
  g_free(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static GnomeCanvasItem * display_item_at ( gchar *  imagename,
int  block,
double  ratio 
) [static]

Display given imagename on the given ice block.

Definition at line 587 of file reversecount.c.

{
  double block_width, block_height;
  double xratio, yratio;
  GnomeCanvasItem *item = NULL;
  GdkPixbuf   *pixmap = NULL;
  int i,j;

  block_width  = BOARDWIDTH/number_of_item_x;
  block_height = BOARDHEIGHT/number_of_item_y;

  pixmap = gc_pixmap_load(imagename);

  if(block < number_of_item_x)
    {
      // Upper line
      g_warning("      // Upper line\n");
      i = block_width * block;
      j = 0;
    }
  else if(block < number_of_item_x + number_of_item_y - 2)
    {
      // Right line
      g_warning("      // Right line\n");
      i = block_width * (number_of_item_x - 1);
      j = block_height * (block - (number_of_item_x-1));
    }
  else if(block < number_of_item_x*2 + number_of_item_y - 2)
    {
      // Bottom line
      g_warning("      // Bottom line\n");
      i = block_width * (number_of_item_x - (block-
                                        (number_of_item_x+number_of_item_y-1))-2);
      j = block_height * (number_of_item_y-1);
    }
  else
    {
      // Left line
      g_warning("      // Left line\n");
      i = 0;
      j = block_height * (number_of_item_y - (block - (number_of_item_x*2 +
                                                number_of_item_y-4)));
    }

  g_warning("display_tux %d i=%d j=%d\n", block, i, j);

  /* Calculation to thrink the item while keeping the ratio */
  if(ratio==-1)
    {
      xratio =  block_width  / (gdk_pixbuf_get_width (pixmap) + TUX_TO_BORDER_GAP);
      yratio =  block_height / (gdk_pixbuf_get_height(pixmap) + TUX_TO_BORDER_GAP);
      xratio = yratio = MIN(xratio, yratio);
    }
  else
    {
      xratio = yratio = ratio;
    }

  item = gnome_canvas_item_new (boardRootItem,
                            gnome_canvas_pixbuf_get_type (),
                            "pixbuf", pixmap,
                            "x", (double) i + (block_width -
                                             (gdk_pixbuf_get_width (pixmap) * xratio)) / 2,
                            "y", (double) j + (block_height -
                                             (gdk_pixbuf_get_height (pixmap) * yratio)) / 2,
                            "width", (double) gdk_pixbuf_get_width (pixmap) * xratio,
                            "height", (double)  gdk_pixbuf_get_height (pixmap) * yratio,
                            "width_set", TRUE,
                            "height_set", TRUE,
                            NULL);

  gdk_pixbuf_unref(pixmap);

  return(item);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void display_random_fish ( ) [static]

Definition at line 569 of file reversecount.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void end_board ( void  ) [static]

Definition at line 208 of file reversecount.c.

Here is the call graph for this function:

static void game_won ( void  ) [static]

Definition at line 664 of file reversecount.c.

{
  gcomprisBoard->sublevel++;

  if(gcomprisBoard->sublevel>gcomprisBoard->number_of_sublevel) {
    /* Try the next level */
    gcomprisBoard->sublevel=1;
    gcomprisBoard->level++;
    if(gcomprisBoard->level>gcomprisBoard->maxlevel) { // the current board is finished : bail out
      gc_bonus_end_display(BOARD_FINISHED_RANDOM);
      return;
    }
    gc_sound_play_ogg ("sounds/bonus.ogg", NULL);
  }
  reversecount_next_level();
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean is_our_board ( GcomprisBoard *  gcomprisBoard) [static]

Definition at line 231 of file reversecount.c.

{
  if (gcomprisBoard)
    {
      if(g_strcasecmp(gcomprisBoard->type, "reversecount")==0)
       {
         /* Set the plugin entry */
         gcomprisBoard->plugin=&menu_bp;

         return TRUE;
       }
    }
  return FALSE;
}
static gint item_event ( GnomeCanvasItem *  item,
GdkEvent *  event,
gint *  dice_index 
) [static]

Increment the dices when they are clicked.

Definition at line 687 of file reversecount.c.

{
  gchar *str;
  GdkPixbuf   *pixmap = NULL;
  gint i = *dice_index;

  if(board_paused)
    return FALSE;

  switch (event->type)
    {
    case GDK_BUTTON_PRESS:
      switch(event->button.button)
       {
       case 1:
         if(dicevalue_array[i]++ >= max_dice_number)
           dicevalue_array[i] = (number_of_dices==1 ? 1 : 0);
         break;
       case 2:
       case 3:
         if(dicevalue_array[i]-- == (number_of_dices==1 ? 1 : 0))
           dicevalue_array[i] = max_dice_number;
         break;
       default:
         break;
       }

      str = g_strdup_printf("gcompris/dice/gnome-dice%d.png", dicevalue_array[i]);

      pixmap = gc_pixmap_load(str);

      /* Warning changing the image needs to update pixbuf_ref for the focus usage */
      gc_item_focus_free(item, NULL);
      gnome_canvas_item_set (item,
                          "pixbuf", pixmap,
                          NULL);
      gdk_pixbuf_unref(pixmap);

      g_free(str);
      break;

    default:
      break;
    }

  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gint key_press ( guint  keyval,
gchar *  commit_str,
gchar *  preedit_str 
) [static]

Definition at line 247 of file reversecount.c.

{

  if(!gcomprisBoard)
    return FALSE;

  /* Add some filter for control and shift key */
  switch (keyval)
    {
      /* Avoid all this keys to be interpreted by this game */
    case GDK_Shift_L:
    case GDK_Shift_R:
    case GDK_Control_L:
    case GDK_Control_R:
    case GDK_Caps_Lock:
    case GDK_Shift_Lock:
    case GDK_Meta_L:
    case GDK_Meta_R:
    case GDK_Alt_L:
    case GDK_Alt_R:
    case GDK_Super_L:
    case GDK_Super_R:
    case GDK_Hyper_L:
    case GDK_Hyper_R:
    case GDK_Num_Lock:
      return FALSE;
    case GDK_KP_Enter:
    case GDK_Return:
      process_ok();
      return TRUE;
    }

  return TRUE;
}

Here is the call graph for this function:

static void pause_board ( gboolean  pause) [static]

Definition at line 165 of file reversecount.c.

{
  if(gcomprisBoard==NULL)
    return;

  if(gamewon == TRUE && pause == FALSE) /* the game is won */
    {
      game_won();
    }

  if(leavenow == TRUE && pause == FALSE)
    gc_bonus_end_display(BOARD_FINISHED_TOOMANYERRORS);

  board_paused = pause;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void process_error ( void  ) [static]

Definition at line 283 of file reversecount.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void process_ok ( void  ) [static]

Definition at line 301 of file reversecount.c.

{
  guint i;

  tux_destination = tux_index;

  for(i=0; i<number_of_dices; i++)
      tux_destination += dicevalue_array[i];

  // Wrapping
  if(tux_destination >= number_of_item)
    tux_destination = tux_destination - (number_of_item);

  // Do not allow going at a position after the fish
  if((tux_destination > fish_index)
     || (tux_destination == tux_index))
    {
      process_error();
      return;
    }

  if(!animate_id) {
    animate_id = gtk_timeout_add (animate_speed, (GtkFunction) animate_tux, NULL);
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

static GnomeCanvasItem * reversecount_create_item ( GnomeCanvasGroup *  parent) [static]

Definition at line 417 of file reversecount.c.

{
  int i,j,d;
  GnomeCanvasItem *item = NULL;
  GdkPixbuf   *pixmap = NULL;
  double block_width, block_height;
  double dice_area_x;
  double xratio, yratio;
  GcomprisProperties *properties = gc_prop_get();

  boardRootItem = GNOME_CANVAS_GROUP(
                                 gnome_canvas_item_new (gnome_canvas_root(gcomprisBoard->canvas),
                                                     gnome_canvas_group_get_type (),
                                                     "x", (double) 0,
                                                     "y", (double) 0,

                                                     NULL));

  block_width =  BOARDWIDTH/number_of_item_x;
  block_height = BOARDHEIGHT/number_of_item_y;

  /* Timer is not requested */
  if(properties->timer>0)
    {
      errors = number_of_dices + 4 - (MIN(properties->timer, 4));
      create_clock(BOARDWIDTH - block_width - 100, BOARDHEIGHT - block_height - 100,
                 errors) ;
    }
  else
    {
      errors = -1;
    }

  /* Calc the tux best ratio to display it */
  pixmap = gc_pixmap_load(TUX_IMG_EAST);
  xratio =  block_width  / (gdk_pixbuf_get_width (pixmap) + TUX_TO_BORDER_GAP);
  yratio =  block_height / (gdk_pixbuf_get_height(pixmap) + TUX_TO_BORDER_GAP);
  tux_ratio = yratio = MIN(xratio, yratio);
  gdk_pixbuf_unref(pixmap);

  pixmap = gc_pixmap_load("reversecount/iceblock.png");

  for(i=0; i<BOARDWIDTH; i+=block_width)
    {
      j=0;
      item = gnome_canvas_item_new (boardRootItem,
                                gnome_canvas_pixbuf_get_type (),
                                "pixbuf", pixmap,
                                "x", (double) i,
                                "y", (double) j,
                                "width", (double) block_width,
                                "height", (double)  block_height,
                                "width_set", TRUE,
                                "height_set", TRUE,
                                   NULL);

      j=BOARDHEIGHT-block_height;
      item = gnome_canvas_item_new (boardRootItem,
                                gnome_canvas_pixbuf_get_type (),
                                "pixbuf", pixmap,
                                "x", (double) i,
                                "y", (double) j,
                                "width", (double) block_width,
                                "height", (double)  block_height,
                                "width_set", TRUE,
                                "height_set", TRUE,
                                   NULL);
    }

  for(j=block_height; j<=BOARDHEIGHT-(block_height*2); j+=block_height)
    {
      i = 0;
      item = gnome_canvas_item_new (boardRootItem,
                                gnome_canvas_pixbuf_get_type (),
                                "pixbuf", pixmap,
                                "x", (double) i,
                                "y", (double) j,
                                "width", (double) block_width,
                                "height", (double)  block_height,
                                "width_set", TRUE,
                                "height_set", TRUE,
                                   NULL);

      i = BOARDWIDTH - block_width;
      item = gnome_canvas_item_new (boardRootItem,
                                gnome_canvas_pixbuf_get_type (),
                                "pixbuf", pixmap,
                                "x", (double) i,
                                "y", (double) j,
                                "width", (double) block_width,
                                "height", (double)  block_height,
                                "width_set", TRUE,
                                "height_set", TRUE,
                                   NULL);
    }

  gdk_pixbuf_unref(pixmap);


  //----------------------------------------
  // Create the dice area
  pixmap = gc_pixmap_load("reversecount/dice_area.png");

  dice_area_x = BOARDWIDTH - block_width - gdk_pixbuf_get_width (pixmap) - 20;

  gnome_canvas_item_new (boardRootItem,
                      gnome_canvas_pixbuf_get_type (),
                      "pixbuf", pixmap,
                      "x", (double) dice_area_x,
                      "y", (double) block_height + 20,
                      NULL);

  gdk_pixbuf_unref(pixmap);

  //----------------------------------------
  // Create the dices
  pixmap = gc_pixmap_load("gcompris/dice/gnome-dice1.png");

  for(d=0; d<number_of_dices; d++)
    {
      int *val;

      i = dice_area_x + gdk_pixbuf_get_width(pixmap) * d + 30;
      j = block_height + 25 + d*7;

      item = gnome_canvas_item_new (boardRootItem,
                                gnome_canvas_pixbuf_get_type (),
                                "pixbuf", pixmap,
                                "x", (double) i,
                                "y", (double) j,
                                NULL);
      dicevalue_array[d] = 1;
      val = g_new(gint, 1);
      *val = d;
      gtk_signal_connect(GTK_OBJECT(item), "event", (GtkSignalFunc) item_event,
                      val);
      gtk_signal_connect(GTK_OBJECT(item), "event",
                      (GtkSignalFunc) gc_item_focus_event,
                      NULL);

    }
  gdk_pixbuf_unref(pixmap);

  tux_index = 0;
  tuxItem = display_item_at(TUX_IMG_EAST, tux_index, tux_ratio);

  // Display the first fish
  display_random_fish();

  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void reversecount_destroy_all_items ( void  ) [static]

Definition at line 406 of file reversecount.c.

{

  gc_timer_end();

  if(boardRootItem!=NULL)
    gtk_object_destroy (GTK_OBJECT(boardRootItem));

  boardRootItem = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void reversecount_next_level ( void  ) [static]

Definition at line 332 of file reversecount.c.

{

  gc_set_background(gnome_canvas_root(gcomprisBoard->canvas),
                       imageList[gcomprisBoard->level-1]);

  gc_bar_set_level(gcomprisBoard);

  reversecount_destroy_all_items();
  gamewon = FALSE;

  /* Select level difficulty */
  switch(gcomprisBoard->level)
    {
    case 1:
      number_of_item_x = 5;
      number_of_item_y = 5;
      number_of_dices = 1;
      max_dice_number = 3;
      number_of_fish = 3;
      break;
    case 2:
      number_of_item_x = 5;
      number_of_item_y = 5;
      number_of_dices = 1;
      max_dice_number = 6;
      number_of_fish = 6;
      break;
    case 3:
      number_of_item_x = 6;
      number_of_item_y = 6;
      number_of_dices = 1;
      max_dice_number = 9;
      number_of_fish = 6;
      break;
    case 4:
      number_of_item_x = 8;
      number_of_item_y = 6;
      number_of_dices = 1;
      max_dice_number = 3;
      number_of_fish = 6;
      break;
    case 5:
      number_of_item_x = 8;
      number_of_item_y = 6;
      number_of_dices = 2;
      max_dice_number = 6;
      number_of_fish = 10;
      break;
    case 6:
      number_of_item_x = 8;
      number_of_item_y = 8;
      number_of_dices = 2;
      max_dice_number = 9;
      number_of_fish = 10;
      break;
    default:
      number_of_item_x = 10;
      number_of_item_y = 10;
      number_of_dices = 3;
      max_dice_number = 9;
      number_of_fish = 10;
      break;
    }

  animate_speed = ANIMATE_SPEED - gcomprisBoard->level * 60;

  number_of_item = number_of_item_x * 2 + (number_of_item_y - 2) * 2;

  /* Try the next level */
  reversecount_create_item(gnome_canvas_root(gcomprisBoard->canvas));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_level ( guint  level) [static]

Definition at line 219 of file reversecount.c.

{

  if(gcomprisBoard!=NULL)
    {
      gcomprisBoard->level=level;
      gcomprisBoard->sublevel=1;
      reversecount_next_level();
    }
}

Here is the call graph for this function:

static void start_board ( GcomprisBoard *  agcomprisBoard) [static]

Definition at line 183 of file reversecount.c.

{

  if(agcomprisBoard!=NULL)
    {
      gcomprisBoard=agcomprisBoard;

      /* disable im_context */
      gcomprisBoard->disable_im_context = TRUE;

      gcomprisBoard->level=1;
      gcomprisBoard->maxlevel=7;
      gcomprisBoard->sublevel=1;
      gcomprisBoard->number_of_sublevel=1; /* Go to next level after this number of 'play' */
      gc_bar_set(GC_BAR_LEVEL|GC_BAR_OK);

      reversecount_next_level();

      gamewon = FALSE;
      leavenow = FALSE;

      pause_board(FALSE);
    }
}

Here is the call graph for this function:

static void update_clock ( int  value) [static]

Definition at line 761 of file reversecount.c.

{
  GdkPixbuf   *pixmap = NULL;
  char        *str = NULL;

  if(value<0)
    return;

  str = g_strdup_printf("%s%d.png", "gcompris/timers/clock",value);

  pixmap = gc_pixmap_load(str);

  gnome_canvas_item_set (clock_image_item,
                      "pixbuf", pixmap,
                      NULL);

  gdk_pixbuf_unref(pixmap);
  g_free(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

gint animate_id = 0 [static]

Definition at line 26 of file reversecount.c.

int animate_speed = 0 [static]

Definition at line 70 of file reversecount.c.

gboolean board_paused = TRUE [static]

Definition at line 25 of file reversecount.c.

GnomeCanvasGroup* boardRootItem = NULL [static]

Definition at line 44 of file reversecount.c.

GnomeCanvasItem* clock_image_item [static]

Definition at line 79 of file reversecount.c.

int dicevalue_array[10] [static]

Definition at line 76 of file reversecount.c.

int errors = 0 [static]

Definition at line 62 of file reversecount.c.

int fish_index = 0 [static]

Definition at line 69 of file reversecount.c.

GnomeCanvasItem* fishItem [static]

Definition at line 77 of file reversecount.c.

gchar* fishList[] [static]

Definition at line 95 of file reversecount.c.

int gamewon [static]

Definition at line 35 of file reversecount.c.

GcomprisBoard* gcomprisBoard = NULL [static]

Definition at line 24 of file reversecount.c.

gchar* imageList[] [static]
Initial value:
{
  "reversecount/baleine.png",
  "reversecount/phoque.png",
  "reversecount/ourspolaire.png",
  "reversecount/morse.png",
  "reversecount/elephant_mer.png",
  "reversecount/epaulard.png",
  "reversecount/narval.png",
}

Definition at line 82 of file reversecount.c.

int leavenow [static]

Definition at line 27 of file reversecount.c.

int max_dice_number = 0 [static]

Definition at line 64 of file reversecount.c.

BoardPlugin menu_bp [static]
Initial value:
  {
    NULL,
    NULL,
    "Reverse count",
    "Practice substraction with a funny game",
    "Bruno Coudoin <bruno.coudoin@free.fr>",
    NULL,
    NULL,
    NULL,
    NULL,
    start_board,
    pause_board,
    end_board,
    is_our_board,
    key_press,
    process_ok,
    set_level,
    NULL,
    NULL,
    NULL,
    NULL
  }

Definition at line 129 of file reversecount.c.

int number_of_dices = 0 [static]

Definition at line 63 of file reversecount.c.

int number_of_fish = 0 [static]

Definition at line 65 of file reversecount.c.

int number_of_item = 0 [static]

Definition at line 58 of file reversecount.c.

int number_of_item_x = 0 [static]

Definition at line 59 of file reversecount.c.

int number_of_item_y = 0 [static]

Definition at line 60 of file reversecount.c.

int tux_destination = 0 [static]

Definition at line 68 of file reversecount.c.

int tux_index = 0 [static]

Definition at line 67 of file reversecount.c.

double tux_ratio = 0 [static]

Definition at line 74 of file reversecount.c.

GnomeCanvasItem* tuxItem [static]

Definition at line 78 of file reversecount.c.