path: root/libgame/game-recorder.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-recorder.h"
#include "game-marshal.h"
#include "game-player.h"

static void	game_recorder_class_init	(gpointer		g_class,
                                                 gpointer		class_data);
static void	game_recorder_init      	(GTypeInstance *	instance,
                                                 gpointer		g_class);
static void	game_recorder_dispose		(GObject *		object);
static void     game_recorder_get_property      (GObject *              object,
						 guint                  param_id,
						 GValue *               value,
						 GParamSpec *           pspec);
static void     game_recorder_set_property      (GObject *              object,
						 guint                  param_id,
						 const GValue *         value,
						 GParamSpec *           pspec);

static void	game_recorder_start_recording	(GameRecorder *		recorder);
static void	game_recorder_stop_recording	(GameRecorder *		recorder);

enum {
  PROP_0,
  PROP_GAME,
  PROP_RECORDING,
  PROP_DATE
};

enum {
  START_RECORDING,
  STOP_RECORDING,
  /* fill me */
  LAST_SIGNAL
};

static GObjectClass *parent_class = NULL;
static guint game_recorder_signals[LAST_SIGNAL] = { 0 };

static void
game_recorder_clear (GameRecorder *recorder)
{
  if (recorder->doc) {
    xmlFreeDoc (recorder->doc);
    recorder->doc = NULL;
    recorder->root = NULL;
    recorder->game_head = NULL;
    if (recorder->resources_lookup) {
      g_hash_table_destroy (recorder->resources_lookup);
      recorder->resources_lookup = NULL;
    }
    recorder->tick = NULL;
  }
  g_assert (recorder->resources_lookup == NULL);
}

GType
game_recorder_get_type ()
{
  static GType recorder_type = 0;
  
  if (!recorder_type) {
    static const GTypeInfo recorder_info = {
      sizeof (GameRecorderClass),
      NULL,
      NULL,
      game_recorder_class_init,
      NULL,
      NULL,
      sizeof (GameRecorder),
      0,
      game_recorder_init,
    };
    
    recorder_type = g_type_register_static (G_TYPE_OBJECT, "GameRecorder", &recorder_info, 0);
  }
  
  return recorder_type;
}
static void
game_recorder_class_init (gpointer g_class, gpointer class_data)
{
  GObjectClass *object_class = G_OBJECT_CLASS (g_class);
  
  parent_class = g_type_class_ref (G_TYPE_OBJECT);

  object_class->dispose = game_recorder_dispose;
  object_class->get_property = game_recorder_get_property;
  object_class->set_property = game_recorder_set_property;

  game_recorder_signals[START_RECORDING] = g_signal_new ("start-recording",
	  G_TYPE_FROM_CLASS (g_class), G_SIGNAL_RUN_LAST,
	  G_STRUCT_OFFSET (GameRecorderClass, start_recording), NULL, NULL,
	  game_marshal_VOID__VOID, G_TYPE_NONE, 0);
  game_recorder_signals[STOP_RECORDING] = g_signal_new ("stop-recording",
	  G_TYPE_FROM_CLASS (g_class), G_SIGNAL_RUN_LAST,
	  G_STRUCT_OFFSET (GameRecorderClass, stop_recording), NULL, NULL,
	  game_marshal_VOID__VOID, G_TYPE_NONE, 0);

  g_object_class_install_property (object_class, PROP_GAME,
	  g_param_spec_object ("game", _("game"), _("game that is recorded"),
			       GAME_TYPE_GAME, G_PARAM_READWRITE));
  g_object_class_install_property (object_class, PROP_RECORDING,
	  g_param_spec_boolean ("recording", _("recording"), _("set if currently recording"),
				FALSE, G_PARAM_READABLE));
  g_object_class_install_property (object_class, PROP_DATE,
      g_param_spec_ulong ("date", _("date"), _("unix timestamp of recorded game"),
	  0, G_MAXULONG, 0, G_PARAM_READABLE));
}
static void
game_recorder_init (GTypeInstance *instance, gpointer g_class)
{
  GameRecorder *recorder = (GameRecorder *) instance;

  recorder->game = NULL;
  recorder->recording = FALSE;
}
static void
game_recorder_dispose (GObject *object)
{
  GameRecorder *recorder = GAME_RECORDER (object);

  if (recorder->recording) {
    game_recorder_stop_recording (recorder);
  }
  game_recorder_clear (recorder);
  game_recorder_set_game (recorder, NULL);

  parent_class->dispose (object);
}
static void
game_recorder_get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec)
{
  GameRecorder *recorder;
  
  g_return_if_fail (GAME_IS_RECORDER (object));

  recorder = GAME_RECORDER (object);
  
  switch (param_id) {
    case PROP_GAME:
      g_value_set_object (value, game_recorder_get_game (recorder));
      break;
    case PROP_RECORDING:
      g_value_set_boolean (value, game_recorder_is_recording (recorder));
      break;
    case PROP_DATE:
      g_value_set_ulong (value, recorder->timestamp);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}
static void
game_recorder_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec)
{
  GameRecorder *recorder;
  
  g_return_if_fail (GAME_IS_RECORDER (object));

  recorder = GAME_RECORDER (object);
  
  switch (param_id) {
    case PROP_GAME:
      game_recorder_set_game (recorder, GAME_GAME (g_value_get_object (value)));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
  }
}
GameRecorder *
game_recorder_new (void)
{
  GameRecorder *recorder = GAME_RECORDER (g_object_new (GAME_TYPE_RECORDER, NULL));

  return recorder;
}
static void
check_tick (GameRecorder *recorder)
{
  if (recorder->tick == NULL) {
    gchar *str;
    g_assert (recorder->game->match != NULL);
    recorder->tick = xmlNewChild (recorder->game_head, NULL, BAD_CAST "tick", NULL);
    str = g_strdup_printf ("%u", game_game_get_tick (recorder->game));
    xmlSetProp (recorder->tick, BAD_CAST "nr", BAD_CAST str);
    g_free (str);
  }
}
static void
handle_key (GamePlayer *player, gchar *key, gchar *action, GameRecorder *recorder)
{
  xmlNode *node;
  gchar *str;
  
  if (!game_recorder_is_recording (recorder)) 
    return;
  check_tick (recorder);

  node = xmlNewChild (recorder->tick, NULL, BAD_CAST action, NULL);
  xmlSetProp (node, BAD_CAST "key", BAD_CAST key);
  str = g_strdup_printf ("%lu", (gulong) player);
  xmlSetProp (node, BAD_CAST "player", BAD_CAST str);
  g_free (str);
}
static void
cb_key_pressed (GamePlayer *player, gchar *key, GameRecorder *recorder)
{
  handle_key (player, key, "pressed", recorder);
}
static void
cb_key_released (GamePlayer *player, gchar *key, GameRecorder *recorder)
{
  handle_key (player, key, "released", recorder);
}
static void
add_player (GameRecorder *recorder, GamePlayer *player)
{
  xmlNode *xmlplay;
  gchar *str;
    
  g_signal_connect (player, "key-pressed", (GCallback) cb_key_pressed, recorder);
  g_signal_connect (player, "key-released", (GCallback) cb_key_released, recorder);
    
  check_tick (recorder);
  xmlplay = xmlNewChild (recorder->tick, NULL, BAD_CAST "player", NULL);
  str = g_strdup_printf ("%lu", (gulong) player);
  xmlSetProp (xmlplay, BAD_CAST "id", BAD_CAST str);
  g_free (str);
  xmlNewChild (xmlplay, NULL, BAD_CAST "name", BAD_CAST player->name);
  str = game_color_to_string (&player->color);
  xmlNewChild (xmlplay, NULL, BAD_CAST "color", BAD_CAST str);
  g_free (str);
}
static void
game_recorder_start_recording (GameRecorder *recorder)
{
  const gchar *name;
  gchar *str;
  GameObject *player;
  GameContainerIter iter;
  GTimeVal tv;
  
  g_assert (!recorder->recording);
  g_assert (recorder->game != NULL);

  /* emit signal before starting to record */
  game_recorder_clear (recorder);
  g_signal_emit (G_OBJECT (recorder), game_recorder_signals [START_RECORDING], 0);
  g_object_notify (G_OBJECT (recorder), "recording");
  recorder->recording = TRUE;
  
  g_get_current_time (&tv);
  recorder->timestamp = tv.tv_sec;
  name = game_game_get_name (recorder->game);
  xmlIndentTreeOutput = TRUE;
  recorder->doc = xmlNewDoc (BAD_CAST "1.0");
  xmlSetDocCompressMode (recorder->doc, 9);

  recorder->root = xmlNewDocNode (recorder->doc, NULL, BAD_CAST "libgame", NULL);
  xmlSetProp (recorder->root, BAD_CAST "game", BAD_CAST name);
  xmlSetProp (recorder->root, BAD_CAST "gameversion", BAD_CAST game_game_get_version (recorder->game));
  xmlDocSetRootElement (recorder->doc, recorder->root);
  
  recorder->header = xmlNewChild (recorder->root, NULL, BAD_CAST "header", NULL);
  str = g_strdup_printf ("%u", (guint) recorder->game->seed);
  xmlNewChild (recorder->header, NULL, BAD_CAST "seed", BAD_CAST str);
  g_free (str);
  
  recorder->game_head = xmlNewChild (recorder->root, NULL, BAD_CAST "game", NULL);
  game_container_iter_init (&iter, game_game_get_players (recorder->game));
  while ((player = game_container_iter_next (&iter))) {
    if (recorder->tick == NULL)
      recorder->tick = xmlNewChild (recorder->game_head, NULL, BAD_CAST "setup", NULL);
    add_player (recorder, GAME_PLAYER (player));
  }
  recorder->tick = NULL;
}
static void
game_recorder_stop_recording (GameRecorder *recorder)
{
  guint j;
  GamePlayer *player;
  xmlNode *node, *stats;
  gchar *str, *playerid;
  GameGame *game = recorder->game;
  const GameInfoScore *scores = game->scores;
  GameContainerIter iter;
  
  g_assert (recorder->recording);
  
  /* add info that game has ended */
  str = g_strdup_printf ("%u", game->tick);
  xmlNewChild (recorder->header, NULL, BAD_CAST "duration", BAD_CAST str);
  g_free (str);

  stats = xmlNewChild (recorder->root, NULL, BAD_CAST "statistics", NULL);
  game_container_iter_init (&iter, game_game_get_players (game));
  while ((player = GAME_PLAYER (game_container_iter_next (&iter)))) {
    playerid = g_strdup_printf ("%lu", (gulong) player);

    for (j = 0; scores[j].name != NULL; j++) {
      str = g_strdup_printf ("%d", game_player_get_score (player, scores[j].name));
      
      node = xmlNewChild (stats, NULL, BAD_CAST "score", BAD_CAST str);
      xmlSetProp (node, BAD_CAST "player", BAD_CAST playerid);
      xmlSetProp (node, BAD_CAST "name", BAD_CAST scores[j].name);

      g_free (str);
    }
    g_free (playerid);
  }

  g_signal_emit (G_OBJECT (recorder), game_recorder_signals [STOP_RECORDING], 0);
  g_object_notify (G_OBJECT (recorder), "recording");
  recorder->recording = FALSE;
}
static void
cb_start_recording (GameGame *game, GameRecorder *recorder)
{
  game_recorder_start_recording (recorder);
}
static void
cb_stop_recording (GameGame *game, GameRecorder *recorder)
{
  game_recorder_stop_recording (recorder);
}
static void
cb_game_destroyed (gpointer precorder, GObject *game)
{
  GameRecorder *recorder = GAME_RECORDER (precorder);
  g_assert (recorder->game == GAME_GAME (game));

  recorder->game = NULL;
  g_object_notify (G_OBJECT (recorder), "game"); 
}
static void
cb_tick (GameGame *game, guint tick, GameRecorder *recorder)
{
  recorder->tick = NULL;
}
static void
cb_player_added (GameGame *game, GameObject *player, GameRecorder *recorder)
{
  if (GAME_IS_PLAYER (player) && game_recorder_is_recording (recorder))
    add_player (recorder, GAME_PLAYER (player));
}

static void
cb_load_resource (GameGame *game, const char *resource_name, guchar **resource, 
    gulong *length, GError **error, GameRecorder *recorder)
{
  char *str;

  if (!game_recorder_is_recording (recorder))
    return;
  if (*error)
    return;
  
  if (!recorder->resources_lookup) {
    recorder->resources_lookup = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
  } else if (g_hash_table_lookup (recorder->resources_lookup, resource_name)) {
    return;
  }
  str = g_strdup (resource_name);
  g_hash_table_insert (recorder->resources_lookup, str, str);
}

void
game_recorder_set_game (GameRecorder *recorder, GameGame *game)
{
  g_return_if_fail (GAME_IS_RECORDER (recorder));
  g_return_if_fail (!recorder->recording);
  
  if (game != NULL) {
    g_return_if_fail (GAME_IS_GAME (game));
    g_return_if_fail (game->match == NULL);
  }
  if (game == recorder->game)
    return;
  
  /* destroy old stuff */
  if (recorder->game != NULL) {
    g_assert (g_signal_handlers_disconnect_matched (G_OBJECT (recorder->game), 
	    G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, recorder) == 5);
    g_object_weak_unref (G_OBJECT (recorder->game), cb_game_destroyed, recorder);
  }
  
  /* set up new stuff */
  if (game != NULL) {
    g_signal_connect (game, "start-game", (GCallback) cb_start_recording, recorder);
    g_signal_connect (game, "end-game", (GCallback) cb_stop_recording, recorder);
    g_signal_connect_after (game, "tick", (GCallback) cb_tick, recorder);
    g_signal_connect (game, "object-added", (GCallback) cb_player_added, recorder);
    g_signal_connect_after (game, "load-resource", (GCallback) cb_load_resource, recorder);
    g_object_weak_ref (G_OBJECT (game), cb_game_destroyed, recorder);
    recorder->game = game;
  } else {
    recorder->game = NULL;
  }
  
  g_object_notify (G_OBJECT (recorder), "game"); 
}

GameGame *
game_recorder_get_game (GameRecorder *recorder)
{
  g_return_val_if_fail (GAME_IS_RECORDER (recorder), NULL);
  
  return recorder->game;
}

gboolean
game_recorder_is_recording (GameRecorder *recorder)
{
  g_return_val_if_fail (GAME_IS_RECORDER (recorder), FALSE);
  
  return recorder->recording;
}

/**
 * game_recorder_save:
 * @recorder: a #GameRecorder
 * @filename: location to save the file to
 *
 * Saves the last recorded game, if any. This function may only be
 * called when the recorder is not recording.
 *
 * Returns: TRUE, if the game was successfully saved.
 **/
gboolean
game_recorder_save (GameRecorder *recorder, const char *filename)
{
  g_return_val_if_fail (GAME_IS_RECORDER (recorder), FALSE);
  g_return_val_if_fail (!game_recorder_is_recording (recorder), FALSE);
  
  if (!recorder->doc)
    return FALSE;

  return xmlSaveFormatFile (filename, recorder->doc, 1) >= 0;
}