path: root/libgame/game-board.c

/*
 *  Copyright (C) 2003 Benjamin Otte <otte@gnome.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *  $Id$
 */

#include "game-private.h"
#include "game-board.h"
#include "game-sprite.h"
#include "game-actor.h"
#include "game-filter.h"
#include "game-container.h"

#include <string.h>
#include <math.h>
#include <gobject/gvaluecollector.h>

enum {
  PROP_0,
  PROP_COLLISIONS,
  PROP_REPEAT
};

GameGraphicClass *parent_class;

static void
game_board_draw_repeated (GameBoard *board, cairo_t *cr)
{
  GameRectangle rect, area = GAME_GRAPHIC (board)->rect;
  GamePoint p, move_x = { - board->repeat.x, 0 }, move_y = { 0, - board->repeat.y };
  GSList *walk;
  double tmp;
  int x_start, x_stop;
  int y, y_start, y_stop;

  if (board->repeat.x > 0.0) {
    area.x1 = MAX (area.x1, 0);
    area.x2 = MIN (area.x2, board->repeat.x);
  }
  if (board->repeat.y > 0.0) {
    area.y1 = MAX (area.y1, 0);
    area.y2 = MIN (area.y2, board->repeat.y);
  }
  if (!GAME_RECTANGLE_IS_VALID (&area))
    return;
  
  for (walk = board->sprites; walk; walk = g_slist_next (walk)) {
    GameSprite *sprite = walk->data;
    if (!sprite->graphic)
      continue;
    game_sprite_get_area (sprite, &rect);
    if (board->repeat.x > 0.0) {
      tmp = area.x1 - rect.x2;
      tmp /= board->repeat.x;
      x_start = floor (tmp + 1.0);
      tmp = area.x2 - rect.x1;
      tmp /= board->repeat.x;
      x_stop = ceil (tmp);
    } else if (area.x1 >= rect.x2 || area.x2 <= rect.x1) {
      continue;
    } else {
      x_start = 0;
      x_stop = 1;
    }
    if (board->repeat.y > 0.0) {
      tmp = area.y1 - rect.y2;
      tmp /= board->repeat.y;
      y_start = floor (tmp + 1.0);
      tmp = area.y2 - rect.y1;
      tmp /= board->repeat.y;
      y_stop = ceil (tmp);
    } else if (area.y1 >= rect.y2 || area.y2 <= rect.y1) {
      continue;
    } else {
      y_start = 0;
      y_stop = 1;
    }
    p.x = - x_start * board->repeat.x - sprite->pos.x;
    p.y = - y_start * board->repeat.y - sprite->pos.y;
    game_rectangle_move (&rect, &area, &p);
    move_x.y = - (y_start - y_stop) * board->repeat.y;
    for (; x_start < x_stop; x_start++) {
      for (y = y_start; y < y_stop; y++) {
	cairo_save (cr);
	cairo_translate (cr, x_start * board->repeat.x + sprite->pos.x, 
	    y * board->repeat.y + sprite->pos.y);
	game_graphic_draw (sprite->graphic, cr);
	cairo_restore (cr);
	game_rectangle_move (&rect, &rect, &move_y);
      }
      game_rectangle_move (&rect, &rect, &move_x);
    }
  }
}

static void
game_board_draw_unrepeated (GameBoard *board, cairo_t *cr)
{
  GSList *walk;

  for (walk = board->sprites; walk; walk = g_slist_next (walk)) {
    GameSprite *sprite = walk->data;
    if (!sprite->graphic)
      continue;
    cairo_save (cr);
    cairo_translate (cr, sprite->pos.x, sprite->pos.y);
    game_graphic_draw (sprite->graphic, cr);
    cairo_restore (cr);
  }
}

static void
game_board_draw (GameGraphic *graphic, cairo_t *cr)
{
  GameBoard *board = GAME_BOARD (graphic);
  
  if (board->repeat.x > 0.0 || board->repeat.y > 0.0)
    game_board_draw_repeated (board, cr);
  else
    game_board_draw_unrepeated (board, cr);
}

static gchar *
game_board_to_string (GameObject *object)
{
  GameBoard *board = GAME_BOARD (object);

  return g_strdup_printf ("%s %p with %u sprites", G_OBJECT_TYPE_NAME(object), 
      object, g_slist_length (board->sprites));
}

static void
game_board_dispose (GObject* object)
{
  GSList *walk;
  GameBoard *board = GAME_BOARD (object);
  
  for (walk = board->sprites; walk; walk = g_slist_next (walk)) {
    GameSprite *sprite = GAME_SPRITE (walk->data);
    game_container_remove (GAME_CONTAINER (board), GAME_OBJECT (sprite));
    sprite->board = NULL;
    g_object_unref (sprite);
  }
  g_slist_free (board->sprites);
  board->sprites = NULL;
  if (board->actors) {
    g_object_unref (board->actors);
    board->actors = NULL;
  }
  g_assert (game_container_get_size (GAME_CONTAINER (board)) == 0);

  G_OBJECT_CLASS (parent_class)->dispose (object);
}

static void
game_board_get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec)
{
  GameBoard *board = GAME_BOARD (object);
  
  switch (param_id) {
    case PROP_COLLISIONS:
      g_value_set_boolean (value, board->collisions);
      break;
    case PROP_REPEAT:
      g_value_set_boxed (value, &board->repeat);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}

static void
game_board_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec)
{
  GameBoard *board = GAME_BOARD (object);
  
  switch (param_id) {
    case PROP_COLLISIONS:
      board->collisions = g_value_get_boolean (value);
      break;
    case PROP_REPEAT:
      if (g_value_get_boxed (value))
	board->repeat = *((GamePoint *) g_value_get_boxed (value));
      else
	board->repeat.x = board->repeat.y = 0.0;
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}

static void
game_board_game_set (GameObject *object)
{
  GameBoard *board = GAME_BOARD (object);
  GameGame *game = object->game;

  board->actors = game_filter_new_for_type (game, GAME_CONTAINER (board), GAME_TYPE_ACTOR);
}

static void
game_board_flush (GameObject *object)
{
  game_container_flush (GAME_CONTAINER (object));
}

static void
game_board_class_init (gpointer g_class, gpointer class_data)
{
  GObjectClass *object_class = G_OBJECT_CLASS (g_class);
  GameObjectClass *gameobject_class = GAME_OBJECT_CLASS (g_class);
  GameGraphicClass *graphic_class = GAME_GRAPHIC_CLASS (g_class);
  
  parent_class = g_type_class_peek_parent (g_class);
  
  object_class->set_property = game_board_set_property;
  object_class->get_property = game_board_get_property;
  object_class->dispose = game_board_dispose;

  g_object_class_install_property (object_class, PROP_COLLISIONS,
      g_param_spec_boolean ("collisions", _("collisions"), _("switch off to make actors not collide"),
	  TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
  g_object_class_install_property (object_class, PROP_REPEAT,
      g_param_spec_boxed ("repeat", _("repeat"), _("at which point the board repeats"),
	  GAME_TYPE_POINT, G_PARAM_READWRITE));

  gameobject_class->flush = game_board_flush;
  gameobject_class->to_string = game_board_to_string;
  gameobject_class->game_set = game_board_game_set;

  graphic_class->draw = game_board_draw;
}

static void
game_board_init (GTypeInstance *instance, gpointer g_class)
{
  GameBoard *board = GAME_BOARD (instance);

  board->sprite_type = GAME_TYPE_SPRITE;
}

static void
game_board_container_init (gpointer g_iface, gpointer iface_data)
{
  GameContainerInterface *iface = g_iface;

  iface->offset = G_STRUCT_OFFSET (GameBoard, sprite_data);
}

GType
game_board_get_type ()
{
  static GType board_type = 0;
  
  if (!board_type) {
    static const GTypeInfo board_info = {
      sizeof (GameBoardClass),
      NULL,
      NULL,
      game_board_class_init,
      NULL,
      NULL,
      sizeof (GameBoard),
      0,
      game_board_init,
    };
    static const GInterfaceInfo container_info = {
      game_board_container_init,
      NULL,
      NULL,
    };
    
    board_type = g_type_register_static (GAME_TYPE_GRAPHIC, "GameBoard", &board_info, 0);
    g_type_add_interface_static (board_type, GAME_TYPE_CONTAINER,
        &container_info);
  }
  
  return board_type;
}

GameBoard *
game_board_new (GameGame *game)
{
  GameBoard *board;
 
  g_return_val_if_fail (GAME_IS_GAME (game), NULL);
  
  /* FIXME: can we get this going with G_MAXDOUBLE * 2 width? */
  board = GAME_BOARD (game_game_add_object (game, GAME_TYPE_BOARD, 
      "permanent", TRUE, 
      "x", G_MAXDOUBLE / 2, "y", G_MAXDOUBLE / 2, 
      "width", G_MAXDOUBLE, "height", G_MAXDOUBLE, NULL));

  return board; 
}

GameSprite *
game_board_add_sprite (GameBoard *board, GType object_type, ...)
{
  va_list args;
  GameSprite *sprite;
  
  g_return_val_if_fail (GAME_IS_BOARD (board), NULL);
  g_return_val_if_fail (g_type_is_a (object_type, board->sprite_type), NULL);

  va_start (args, object_type);
  sprite = game_board_add_sprite_valist (board, object_type, args);
  va_end (args);
  
  return sprite;
}

GameSprite *
game_board_add_sprite_valist (GameBoard *board, GType object_type,
    va_list varargs)
{
  GObjectClass *class;
  GParameter *params;
  const gchar *name;
  GameSprite *sprite;
  guint n_params = 0, n_alloced_params = 16;
  
  g_return_val_if_fail (GAME_IS_BOARD (board), NULL);
  g_return_val_if_fail (g_type_is_a (object_type, GAME_TYPE_SPRITE), NULL);

  class = g_type_class_ref (object_type);
  
  name = va_arg (varargs, gchar*);
  if (name) {
    params = g_new (GParameter, n_alloced_params);
    while (name) {
      gchar *error = NULL;
      GParamSpec *pspec = g_object_class_find_property (class, name);
      if (!pspec) {
	g_warning ("%s: object class `%s' has no property named `%s'", G_STRFUNC,
	    g_type_name (object_type), name);
	break;
      }
      if (n_params >= n_alloced_params) {
	n_alloced_params += 16;
	params = g_renew (GParameter, params, n_alloced_params);
      }
      params[n_params].name = name;
      params[n_params].value.g_type = 0;
      g_value_init (&params[n_params].value, G_PARAM_SPEC_VALUE_TYPE (pspec));
      G_VALUE_COLLECT (&params[n_params].value, varargs, 0, &error);
      if (error) {
	g_warning ("%s: %s", G_STRFUNC, error);
      g_free (error);
      g_value_unset (&params[n_params].value);
      break;
      }
      n_params++;
      name = va_arg (varargs, gchar*);
    }
  } else {
    params = NULL;
    n_params = 0;
  }
  
  sprite = game_board_add_spritev (board, object_type, n_params, params);

  while (n_params--)
    g_value_unset (&params[n_params].value);
  g_free (params);

  g_type_class_unref (class);

  return sprite;
}

int
game_compare_sprite_layer (gconstpointer a, gconstpointer b)
{
  return GAME_SPRITE (a)->layer - GAME_SPRITE (b)->layer;
}

GameSprite *
game_board_add_spritev (GameBoard *board, GType object_type, guint n_parameters, 
    GParameter *parameters)
{
  GameSprite *sprite;
  GParameter all_parameters[n_parameters + 2];
  GameRectangle rect;
  
  g_return_val_if_fail (GAME_IS_BOARD (board), NULL);
  g_return_val_if_fail (g_type_is_a (object_type, GAME_TYPE_SPRITE), NULL);
  g_return_val_if_fail (parameters != NULL || n_parameters == 0, NULL);

  if (n_parameters)
    memcpy (all_parameters + 1, parameters, sizeof (GParameter) * n_parameters);
  all_parameters[0].name = "board";
  all_parameters[0].value.g_type = 0;
  g_value_init (&all_parameters[0].value, GAME_TYPE_BOARD);
  g_value_set_object (&all_parameters[0].value, board);
  
  sprite = GAME_SPRITE (game_game_add_objectv (GAME_OBJECT (board)->game, 
      object_type, n_parameters + 1, all_parameters));
  
  g_value_unset (&all_parameters[0].value);
  
  game_container_add (GAME_CONTAINER (board), GAME_OBJECT (sprite));
  board->sprites = g_slist_insert_sorted (board->sprites, sprite, game_compare_sprite_layer);
  game_sprite_get_area (sprite, &rect);
  game_graphic_invalidate_area (GAME_GRAPHIC (board), &rect);

  return sprite;
}

void
_game_board_sprite_changed_layer (GameBoard *board, GameSprite *sprite)
{
  GameRectangle rect;
  GSList *list;
  
  list = g_slist_find (board->sprites, sprite);
  if (list) {
    board->sprites = g_slist_remove (board->sprites, sprite);
    board->sprites = g_slist_insert_sorted (board->sprites, sprite, game_compare_sprite_layer);
  }

  game_sprite_get_area (sprite, &rect);
  game_graphic_invalidate_area (GAME_GRAPHIC (sprite->board), &rect);
}