Back to index

gcompris  8.2.2
Classes | Defines | Functions | Variables
clickgame.c File Reference
#include <string.h>
#include "gcompris/gcompris.h"
#include "gcompris/pixbuf_util.h"
#include <libart_lgpl/art_affine.h>

Go to the source code of this file.

Classes

struct  FishItem

Defines

#define SOUNDLISTFILE   PACKAGE
#define NUM_SMALLFISH   G_N_ELEMENTS(smallFish)
#define NUM_MEDFISH   G_N_ELEMENTS(medFish)
#define NUM_BIGFISH   G_N_ELEMENTS(bigFish)

Functions

static void clickgame_start (GcomprisBoard *agcomprisBoard)
static void clickgame_pause (gboolean pause)
static void clickgame_end (void)
static gboolean clickgame_is_our_board (GcomprisBoard *gcomprisBoard)
static void clickgame_set_level (guint level)
static void clickgame_config (void)
static FishItemclickgame_create_item ()
static gint clickgame_drop_items (GtkWidget *widget, gpointer data)
static gint clickgame_move_items (GtkWidget *widget, gpointer data)
static gint clickgame_animate_items (GtkWidget *widget, gpointer data)
static void clickgame_destroy_item (FishItem *fishitem)
static void clickgame_destroy_items (void)
static void clickgame_destroy_all_items (void)
static void clickgame_next_level (void)
static void game_won (void)
static void fish_reverse_direction (FishItem *fish)
static void fish_gobble (FishItem *fishitem)
static gint canvas_event (GnomeCanvas *canvas, GdkEvent *event)
static gint item_event (GnomeCanvasItem *item, GdkEvent *event, FishItem *fishitem)
static void clickgame_animate_item (FishItem *fishitem)
static void clickgame_move_item (FishItem *fishitem)
static GSList * load_random_fish (gboolean smallish)

Variables

static gboolean board_paused = TRUE
static GList * item_list = NULL
static GList * item2del_list = NULL
static GcomprisBoard * gcomprisBoard = NULL
static gulong event_handle_id
static gint move_items_id = 0
static gint animate_id = 0
static gint drop_items_id = 0
static int gamewon
static guint32 fallSpeed = 0
static double moveSpeed = 0.0
static double imageZoom = 0.0
static const gchar * smallFish []
static const gchar * medFish []
static const gchar * bigFish []
static BoardPlugin menu_bp

Class Documentation

struct FishItem

Definition at line 46 of file clickgame.c.

Class Members
GSList * cur_frames
gint currentItem
gint fright
GSList * fwd_frames
GSList * rev_frames
GnomeCanvasItem * rootitem
double speed
gint stun

Define Documentation

#define NUM_BIGFISH   G_N_ELEMENTS(bigFish)

Definition at line 122 of file clickgame.c.

#define NUM_MEDFISH   G_N_ELEMENTS(medFish)

Definition at line 108 of file clickgame.c.

#define NUM_SMALLFISH   G_N_ELEMENTS(smallFish)

Definition at line 91 of file clickgame.c.

#define SOUNDLISTFILE   PACKAGE

Definition at line 32 of file clickgame.c.


Function Documentation

static gint canvas_event ( GnomeCanvas *  canvas,
GdkEvent *  event 
) [static]

Definition at line 245 of file clickgame.c.

{
  FishItem *fish;
  double mouse_x = event->button.x;
  double mouse_y = event->button.y;
  int ii;

  switch (event->type)
     {
     case GDK_BUTTON_PRESS:
       switch(event->button.button)
         {
         case 1:
         case 2:
         case 3:
           if (gcomprisBoard->level >= 3 &&
              !(event->button.state & GDK_SHIFT_MASK)) {
            for (ii=0; (fish=g_list_nth_data(item_list, ii)); ii++) {
              double dx, dy, near;
              double x1,x2,y1,y2;
              int react;
              gnome_canvas_item_get_bounds (fish->rootitem, &x1, &y1, &x2, &y2);
              //printf("fish %d\n", ii);

              dy = (mouse_y - (y1 + (y2 - y1) / 2)) / ((y2 - y1) / 2);
              //printf("dy = %.2f\n", dy);
              if (fabs(dy) > 3) continue;

              dx = (mouse_x - (x1 + (x2 - x1) / 2)) / ((x2 - x1) / 2);
              //printf("dx = %.2f\n", dx);
              if (fabs(dx) > 3) continue;

              // 0 to .9
              near = (sqrt(2*3*3) - sqrt(dx*dx + dy*dy))/(1.11 * sqrt(2*3*3));
              //printf("near = %.2f\n", near);

              react = ((rand() % 1000 < near * 1000) +
                     (rand() % 1000 < near * 1000));
              if (react) {
               if (gnome_canvas_get_item_at (canvas, mouse_x, mouse_y) !=
                   g_slist_nth_data (fish->cur_frames, fish->currentItem) &&
                   (dx > 0) ^ (fish->speed < 0))
                 fish_reverse_direction (fish);
               else
                 react += 1;
              }
              if (react >= 2)
               fish->fright +=
                 (1000 + rand() % (int)(near * 2000)) / moveSpeed;
            }
          }
          break;
        default: break;
        }
       break;
     default:
       break;
     }

  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_animate_item ( FishItem fishitem) [static]

Definition at line 522 of file clickgame.c.

{
  gint currentItem;

  /* Manage the animation */
  currentItem = fishitem->currentItem;
  fishitem->currentItem++;
  if(fishitem->currentItem >= g_slist_length(fishitem->cur_frames))
    fishitem->currentItem=0;

  gnome_canvas_item_show((GnomeCanvasItem *)g_slist_nth_data(fishitem->cur_frames,
                                                      fishitem->currentItem));

  gnome_canvas_item_hide((GnomeCanvasItem *)g_slist_nth_data(fishitem->cur_frames,
                                                      currentItem));
}

Here is the caller graph for this function:

static gint clickgame_animate_items ( GtkWidget *  widget,
gpointer  data 
) [static]

Definition at line 641 of file clickgame.c.

{
  g_list_foreach (item_list, (GFunc) clickgame_animate_item, NULL);

  animate_id = gtk_timeout_add (1000,
                           (GtkFunction) clickgame_animate_items, NULL);

  return(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_config ( void  ) [static]

Definition at line 471 of file clickgame.c.

{
  if(gcomprisBoard!=NULL)
    {
      clickgame_pause(TRUE);
    }
}

Here is the call graph for this function:

static FishItem * clickgame_create_item ( ) [static]

Definition at line 703 of file clickgame.c.

{
  GnomeCanvasGroup *parent = gnome_canvas_root(gcomprisBoard->canvas);
  GdkPixbuf *pixmap = NULL;
  GdkPixbuf *pixmap2 = NULL;
  GnomeCanvasItem *rootitem;
  FishItem *fishitem;
  double x;
  gint i, length;
  GSList *ilist;

  /* Avoid to have too much items displayed */
  if(g_list_length(item_list)>5)
    return NULL;

  // select smallish fish on even levels, also see imageZoom
  ilist = load_random_fish (!(gcomprisBoard->level & 1));

  fishitem = g_malloc(sizeof(FishItem));
  fishitem->currentItem   = 0;
  fishitem->speed = (double)(rand()%(60))/10 - 3;
  fishitem->fright = 0;
  fishitem->stun = 0;
  fishitem->fwd_frames = NULL;
  fishitem->rev_frames = NULL;

  pixmap = (GdkPixbuf *)g_slist_nth_data(ilist, 0);

  if(pixmap==NULL)
    return NULL;

  if(fishitem->speed<0)
    {
      x = (double) gcomprisBoard->width;
      fishitem->speed=MIN(fishitem->speed, -1);
    }
  else
    {
      x = (double) -gdk_pixbuf_get_width(pixmap)*imageZoom;
      fishitem->speed=MAX(fishitem->speed, 1);
    }

  rootitem = \
    gnome_canvas_item_new (parent,
                        gnome_canvas_group_get_type (),
                        "x", x,
                        "y", (double)(rand()%(gcomprisBoard->height-
                                           (guint)(gdk_pixbuf_get_height(pixmap)*
                                                  imageZoom))),
                        NULL);

  gtk_signal_connect(GTK_OBJECT(rootitem), "event",
                   (GtkSignalFunc) item_event, fishitem);

  fishitem->rootitem = rootitem;

  length = g_slist_length(ilist);
  for(i=0; i<length; i++)
    {
      GnomeCanvasItem *fwd, *rev;

      pixmap = (GdkPixbuf *)g_slist_nth_data(ilist, i);
      pixmap2 = pixbuf_copy_mirror(pixmap, TRUE, FALSE);

      fwd = gnome_canvas_item_new (GNOME_CANVAS_GROUP(rootitem),
                               gnome_canvas_pixbuf_get_type (),
                               "pixbuf", pixmap,
                               "x", 0.0,
                               "y", 0.0,
                               "width", (double) gdk_pixbuf_get_width(pixmap)*imageZoom,
                               "height", (double) gdk_pixbuf_get_height(pixmap)*imageZoom,
                               "width_set", TRUE,
                               "height_set", TRUE,
                               NULL);
      rev = gnome_canvas_item_new (GNOME_CANVAS_GROUP(rootitem),
                               gnome_canvas_pixbuf_get_type (),
                               "pixbuf", pixmap2,
                               "x", 0.0,
                               "y", 0.0,
                               "width", (double) gdk_pixbuf_get_width(pixmap2)*imageZoom,
                               "height", (double) gdk_pixbuf_get_height(pixmap2)*imageZoom,
                               "width_set", TRUE,
                               "height_set", TRUE,
                               NULL);
      gdk_pixbuf_unref(pixmap);
      gdk_pixbuf_unref(pixmap2);

      fishitem->fwd_frames = g_slist_prepend (fishitem->fwd_frames, fwd);
      fishitem->rev_frames = g_slist_prepend (fishitem->rev_frames, rev);

      gnome_canvas_item_hide (fwd);
      gnome_canvas_item_hide (rev);
    }

  g_slist_free (ilist);

  fishitem->fwd_frames = g_slist_reverse (fishitem->fwd_frames);
  fishitem->rev_frames = g_slist_reverse (fishitem->rev_frames);

  fishitem->cur_frames =
    fishitem->speed<0? fishitem->rev_frames : fishitem->fwd_frames;

  gnome_canvas_item_show(g_slist_nth_data(fishitem->cur_frames,
                                     fishitem->currentItem));

  item_list = g_list_append (item_list, fishitem);

  return (fishitem);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_destroy_all_items ( void  ) [static]

Definition at line 611 of file clickgame.c.

{
  while(item_list)
    {
      FishItem *fishitem = g_list_nth_data(item_list, 0);
      clickgame_destroy_item(fishitem);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_destroy_item ( FishItem fishitem) [static]

Definition at line 585 of file clickgame.c.

{
  GnomeCanvasItem *item = fishitem->rootitem;

  item_list = g_list_remove (item_list, fishitem);
  item2del_list = g_list_remove (item2del_list, fishitem);
  gtk_object_destroy (GTK_OBJECT(item));

  g_slist_free (fishitem->fwd_frames);
  g_slist_free (fishitem->rev_frames);
  g_free(fishitem);
}

Here is the caller graph for this function:

static void clickgame_destroy_items ( void  ) [static]

Definition at line 599 of file clickgame.c.

{
  FishItem *fishitem;

  while(g_list_length(item2del_list)>0)
    {
      fishitem = g_list_nth_data(item2del_list, 0);
      clickgame_destroy_item(fishitem);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gint clickgame_drop_items ( GtkWidget *  widget,
gpointer  data 
) [static]

Definition at line 817 of file clickgame.c.

{
  clickgame_create_item();

  drop_items_id = gtk_timeout_add (fallSpeed,
                               (GtkFunction) clickgame_drop_items, NULL);
  return (FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_end ( void  ) [static]

Definition at line 429 of file clickgame.c.

{
  if(gcomprisBoard!=NULL)
    {
      clickgame_pause(TRUE);
      gc_score_end();
      clickgame_destroy_all_items();
      gtk_signal_disconnect(GTK_OBJECT(gcomprisBoard->canvas),
                         event_handle_id);
      gcomprisBoard->level = 1;       // Restart this game to zero
    }
  gcomprisBoard = NULL;
}

Here is the call graph for this function:

static gboolean clickgame_is_our_board ( GcomprisBoard *  gcomprisBoard) [static]

Definition at line 455 of file clickgame.c.

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

         return TRUE;
       }
    }
  return FALSE;
}
static void clickgame_move_item ( FishItem fishitem) [static]

Definition at line 539 of file clickgame.c.

{
  double sp = fishitem->speed;
  double x1, y1, x2, y2;

  GnomeCanvasItem *item = fishitem->rootitem;

  if (fishitem->stun) {
    --fishitem->stun;
    sp *= .1 + (rand() % 100) / 1000.0;
  } else if (fishitem->fright) {
    --fishitem->fright;
    sp *= 3 + (rand() % 3000) / 1000.0;
  }
  gnome_canvas_item_move(item, sp, 0.0);


  gnome_canvas_item_get_bounds    (item,
                               &x1,
                               &y1,
                               &x2,
                               &y2);

  if(fishitem->speed>0)
    {
      if(x1>gcomprisBoard->width) {
       item2del_list = g_list_append (item2del_list, fishitem);
       gc_sound_play_ogg ("crash", NULL);
      }
    }
  else
    {
      if(x2<0) {
       item2del_list = g_list_append (item2del_list, fishitem);
       gc_sound_play_ogg ("crash", NULL);
      }
    }

  while (g_list_length (item_list) < 3) {
    FishItem *fish = clickgame_create_item();
    if (!fish) break;
    gnome_canvas_item_move(fish->rootitem,
                          fish->speed * (rand() % 200), 0.0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gint clickgame_move_items ( GtkWidget *  widget,
gpointer  data 
) [static]

Definition at line 624 of file clickgame.c.

{
  g_list_foreach (item_list, (GFunc) clickgame_move_item, NULL);

  /* Destroy items that falls out of the canvas */
  clickgame_destroy_items();

  move_items_id = gtk_timeout_add (moveSpeed,
                               (GtkFunction) clickgame_move_items, NULL);

  return(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_next_level ( void  ) [static]

Definition at line 485 of file clickgame.c.

{
  static /*const*/ gchar *bglist[] =
    {
      "clickgame/nur00523.jpg",
      "clickgame/nur03006.jpg",
      "clickgame/nur03011.jpg",
      "clickgame/nur03010.jpg",
      "clickgame/nur03013.jpg",
      "clickgame/nur03505.jpg"
    };

  int bgx = gcomprisBoard->level - 1;

  if (bgx < 0 || G_N_ELEMENTS(bglist) <= bgx)
    bgx = G_N_ELEMENTS(bglist) - 1;

  gc_set_background(gnome_canvas_root(gcomprisBoard->canvas), bglist[bgx]);

  gc_bar_set_level(gcomprisBoard);

  /* Try the next level */
  moveSpeed=100+(40/(gcomprisBoard->level));
  fallSpeed=5000-gcomprisBoard->level*200;
  imageZoom = 0.75 + 0.25 * ((gcomprisBoard->maxlevel - gcomprisBoard->level + 1) / gcomprisBoard->maxlevel);
  gcomprisBoard->sublevel=0;
  gc_score_set(gcomprisBoard->sublevel);

  while (g_list_length (item_list) < 3) {
    FishItem *fish = clickgame_create_item();
    if (!fish) break;
    gnome_canvas_item_move(fish->rootitem,
                          fish->speed * (rand() % 200), 0.0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_pause ( gboolean  pause) [static]

Definition at line 161 of file clickgame.c.

{
  if(gcomprisBoard==NULL)
    return;

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

  if(pause)
    {
      if (move_items_id) {
       gtk_timeout_remove (move_items_id);
       move_items_id = 0;
      }
      if (animate_id) {
       gtk_timeout_remove (animate_id);
       animate_id = 0;
      }
      if (drop_items_id) {
       gtk_timeout_remove (drop_items_id);
       drop_items_id = 0;
      }
    }
  else
    {
      if(!drop_items_id) {
       drop_items_id = gtk_timeout_add (200,
                                    (GtkFunction) clickgame_drop_items, NULL);
      }
      if(!move_items_id) {
       move_items_id = gtk_timeout_add (200, (GtkFunction) clickgame_move_items, NULL);
      }
      if(!animate_id) {
       animate_id = gtk_timeout_add (200, (GtkFunction) clickgame_animate_items, NULL);
      }
    }

  board_paused = pause;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clickgame_set_level ( guint  level) [static]

Definition at line 444 of file clickgame.c.

{

  if(gcomprisBoard!=NULL)
    {
      gcomprisBoard->level=level;
      clickgame_next_level();
    }
}

Here is the call graph for this function:

static void clickgame_start ( GcomprisBoard *  agcomprisBoard) [static]

Definition at line 403 of file clickgame.c.

{
  if (!agcomprisBoard)
    return;

  gcomprisBoard = agcomprisBoard;

  /* set initial values for this level */
  gcomprisBoard->level = 1;
  gcomprisBoard->maxlevel=6;
  gcomprisBoard->number_of_sublevel=10; /* Go to next level after this number of 'play' */
  gc_score_start(SCORESTYLE_NOTE,
               gcomprisBoard->width - 220,
               gcomprisBoard->height - 50,
               gcomprisBoard->number_of_sublevel);
  gc_bar_set(GC_BAR_LEVEL);

  event_handle_id =
    gtk_signal_connect(GTK_OBJECT(gcomprisBoard->canvas), "event",
                     (GtkSignalFunc) canvas_event, 0);
  clickgame_next_level();

  clickgame_pause(FALSE);
}

Here is the call graph for this function:

static void fish_gobble ( FishItem fishitem) [static]

Definition at line 219 of file clickgame.c.

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

  gcomprisBoard->sublevel++;
  gc_score_set(gcomprisBoard->sublevel);

  if(gcomprisBoard->sublevel>=gcomprisBoard->number_of_sublevel) {
    gamewon = TRUE;
    clickgame_destroy_all_items();
    gc_bonus_display(gamewon, BONUS_FLOWER);
    return;
  }
  /* Drop a new item now to speed up the game */
  if(g_list_length(item_list)==0)
    {
      /* Remove any pending new item creation to sync the falls */
      if (drop_items_id)
       gtk_timeout_remove (drop_items_id);
      drop_items_id =
       gtk_timeout_add (0, (GtkFunction) clickgame_drop_items, NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fish_reverse_direction ( FishItem fish) [static]

Definition at line 204 of file clickgame.c.

{
  fish->speed = -fish->speed;

  gnome_canvas_item_hide(g_slist_nth_data(fish->cur_frames,
                                     fish->currentItem));

  fish->cur_frames =
    fish->speed<0? fish->rev_frames : fish->fwd_frames;

  gnome_canvas_item_show(g_slist_nth_data(fish->cur_frames,
                                     fish->currentItem));
}

Here is the caller graph for this function:

static void game_won ( void  ) [static]

Definition at line 827 of file clickgame.c.

{
  gcomprisBoard->sublevel++;

  if(gcomprisBoard->sublevel>=gcomprisBoard->number_of_sublevel) {
    /* Try the next level */
    gcomprisBoard->sublevel=0;
    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);
  }
  clickgame_next_level();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gint item_event ( GnomeCanvasItem *  item,
GdkEvent *  event,
FishItem fishitem 
) [static]

Definition at line 308 of file clickgame.c.

{
   static double x, y;
   double new_x, new_y;
   GdkCursor *fleur;
   static int dragging;
   double item_x, item_y;

   if(!gcomprisBoard)
     return FALSE;

   if(board_paused)
     return FALSE;

   item_x = event->button.x;
   item_y = event->button.y;
   gnome_canvas_item_w2i(item->parent, &item_x, &item_y);

   switch (event->type)
     {
     case GDK_BUTTON_PRESS:
       switch(event->button.button)
         {
         case 1:
         case 2:
         case 3:
           if (event->button.state & GDK_SHIFT_MASK)
             {
               x = item_x;
               y = item_y;

               fleur = gdk_cursor_new(GDK_FLEUR);
               gc_canvas_item_grab(item,
                                      GDK_POINTER_MOTION_MASK |
                                      GDK_BUTTON_RELEASE_MASK,
                                      fleur,
                                      event->button.time);
               gdk_cursor_destroy(fleur);
               dragging = TRUE;
             }
           else
             {
              if (gcomprisBoard->level >= 5 && !fishitem->stun) {
               fishitem->stun = 500 * (1 + gcomprisBoard->maxlevel - gcomprisBoard->level) / moveSpeed;
               fishitem->fright += 500 / moveSpeed;
              } else {
               fish_gobble (fishitem);
              }
             }
           break;

         case 4:
          /* fish up */
          gnome_canvas_item_move(item, 0.0, -3.0);
          break;

         case 5:
          /* fish down */
          gnome_canvas_item_move(item, 0.0, 3.0);
          break;

         default:
           break;
         }
       break;

     case GDK_MOTION_NOTIFY:
       if (dragging && (event->motion.state & GDK_BUTTON1_MASK))
         {
           new_x = item_x;
           new_y = item_y;

           gnome_canvas_item_move(item, new_x - x, new_y - y);
           x = new_x;
           y = new_y;
         }
       break;

     case GDK_BUTTON_RELEASE:
       if(dragging)
        {
          gc_canvas_item_ungrab(item, event->button.time);
          dragging = FALSE;
        }
       break;

     default:
       break;
     }

   return FALSE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static GSList* load_random_fish ( gboolean  smallish) [static]

Definition at line 651 of file clickgame.c.

{
  int fish;
  const gchar **extraFish;
  const gchar **surpriseFish;
  int num_extra;
  int num_surprise;

  if (smallish) {
    extraFish = smallFish;
    num_extra = NUM_SMALLFISH;
    surpriseFish = bigFish;
    num_surprise = NUM_BIGFISH;
  } else {
    extraFish = bigFish;
    num_extra = NUM_BIGFISH;
    surpriseFish = smallFish;
    num_surprise = NUM_SMALLFISH;
  }

  fish = rand() % (NUM_MEDFISH + num_extra + 2);

  const gchar *path;
  if (fish < NUM_MEDFISH) {
    path = medFish[fish];
  } else if (fish < NUM_MEDFISH + num_extra) {
    path = extraFish[fish - NUM_MEDFISH];
  } else {
    fish = rand() % num_surprise;
    path = surpriseFish[fish];
  }

  int frame = 0;
  GSList *ilist = 0;
  while(1)
    {
      if (frame) {
       gchar *exists = gc_file_find_absolute (path, "fishes", frame);
       g_free (exists);
       if (!exists) break;
      }

      GdkPixbuf *pixmap = gc_pixmap_load (path, "fishes", frame);
      if (!pixmap) break;

      ilist = g_slist_prepend (ilist, pixmap);
      ++frame;
    }
  return g_slist_reverse (ilist);
}

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 43 of file clickgame.c.

const gchar* bigFish[] [static]
Initial value:
  {
    "%s/blueking2_%d.png",
    "%s/butfish_%d.png",
    "%s/discus2_%d.png",
    "%s/f07_%d.png",
    "%s/f08_%d.png",
    "%s/f09_%d.png",
    "%s/f10_%d.png",
    "%s/manta_%d.png",
    "%s/newf1_%d.png",
  }

Definition at line 110 of file clickgame.c.

gboolean board_paused = TRUE [static]

Definition at line 34 of file clickgame.c.

gint drop_items_id = 0 [static]

Definition at line 44 of file clickgame.c.

gulong event_handle_id [static]

Definition at line 41 of file clickgame.c.

guint32 fallSpeed = 0 [static]

Definition at line 76 of file clickgame.c.

int gamewon [static]

Definition at line 73 of file clickgame.c.

GcomprisBoard* gcomprisBoard = NULL [static]

Definition at line 39 of file clickgame.c.

double imageZoom = 0.0 [static]

Definition at line 78 of file clickgame.c.

GList* item2del_list = NULL [static]

Definition at line 37 of file clickgame.c.

GList* item_list = NULL [static]

Definition at line 36 of file clickgame.c.

const gchar* medFish[] [static]
Initial value:
  {
    "%s/f00_%d.png",
    "%s/f01_%d.png",
    "%s/f03_%d.png",
    "%s/f04_%d.png",
    "%s/f05_%d.png",
    "%s/f06_%d.png",
    "%s/f11_%d.png",
    "%s/f12_%d.png",
    "%s/f13_%d.png",
    "%s/QueenAngel_%d.png",
    "%s/six_barred_%d.png",
    "%s/shark1_%d.png",
  }

Definition at line 93 of file clickgame.c.

BoardPlugin menu_bp [static]
Initial value:
{
   NULL,
   NULL,
   "Click On Me",
   "Click with the mouse on all swimming fish before they leave the fishtank",
   "Bruno Coudoin <bruno.coudoin@free.fr>",
   NULL,
   NULL,
   NULL,
   NULL,
   clickgame_start,
   clickgame_pause,
   clickgame_end,
   clickgame_is_our_board,
   NULL,
   NULL,
   clickgame_set_level,
   clickgame_config,
   NULL,
   NULL,
   NULL
}

Definition at line 125 of file clickgame.c.

gint move_items_id = 0 [static]

Definition at line 42 of file clickgame.c.

double moveSpeed = 0.0 [static]

Definition at line 77 of file clickgame.c.

const gchar* smallFish[] [static]
Initial value:
  {
    "%s/cichlid1_%d.png",
    "%s/cichlid4_%d.png",
    "%s/collaris_%d.png",
    "%s/discus3_%d.png",
    "%s/eel_%d.png",
    "%s/teeth_%d.png",
    "%s/f02_%d.png",
  }

Definition at line 81 of file clickgame.c.