Пример #1
0
void do_chsave( CHAR_DATA *ch, char *argument )
{
    char arg1[MAX_INPUT_LENGTH];
    char arg2[MAX_INPUT_LENGTH];
    char buf[MSL];

    argument = one_argument( argument, arg1 );
    argument = one_argument( argument, arg2 );

    if ( IS_NPC(ch) )
        return;

    if (!ch->desc || NULLSTR(arg1) )
    {
        send_to_char("Syntax: chsave load/save\n\r",ch);
        send_to_char("Syntax: chsave delete (change number)\n\r",ch);
        return;
    }

    if ( !str_cmp(arg1,"load") )
    {
        load_changes( );
        send_to_char("Changes Loaded.\n\r",ch);
        return;
    }

    if ( !str_cmp(arg1,"save") )
    {
        save_changes( );
        send_to_char("Changes Saved.\n\r",ch);
        return;
    }

    if ( !str_cmp(arg1, "delete"))
    {
        int num;

        if ( NULLSTR(arg2) || !is_number( arg2 ) )
        {
            send_to_char("For chsave delete, you must provide a change number.\n\r",ch);
            send_to_char("Syntax: chsave delete (change number)\n\r",ch);
            return;
        }

        num = atoi( arg2 );
        if ( num < 0 || num > maxChanges )
        {
            sprintf( buf, "Valid changes are from 0 to %d.\n\r", maxChanges );
            send_to_char( buf, ch );
            return;
        }
        delete_change( num );
        send_to_char("Change deleted.\n\r",ch);
        return;
    }

    return;
}
Пример #2
0
void do_addchange(CHAR_DATA *ch, char *argument )
{
    CHANGE_DATA * new_table;

    if ( IS_NPC( ch ) )
        return;

    if ( argument[0] == '\0' )
    {
        send_to_char( "Syntax: addchange [change string]\n\r", ch );
        send_to_char( "Type 'changes' to view the list.\n\r", ch );
        return;
    }

    maxChanges++;
    new_table = realloc( changes_table, sizeof( CHANGE_DATA ) *(maxChanges+1) );

    if (!new_table)                                         /* realloc failed */
    {
        send_to_char ("Memory allocation failed. Brace for impact.\n\r",ch);
        return;
    }

    changes_table = new_table;

    changes_table[maxChanges-1].change  = str_dup( argument );
    changes_table[maxChanges-1].coder   = str_dup( ch->name );
    changes_table[maxChanges-1].date    = str_dup(current_date());
    changes_table[maxChanges-1].mudtime = current_time;

    send_to_char("Changes Created.\n\r",ch);
    send_to_char("Type '@@echanges@@w' to see the changes.\n\r",ch);
    info("New change added to the MUD, type '@@echanges@@g' to see it.", 0);
    save_changes();
    load_changes();
    return;
}
Пример #3
0
static gint
change_map_load_some_changes (SBlbBlockChangeMap *block_change_map, guint first_block_index, GError **error)
{
    SBlbBlockChangeMapPrivate *priv = block_change_map->priv;
    SBlbBlockIndexFile *interval_file = NULL;
    gint interval_index;
    gint result = 0;

    change_map_clear (block_change_map);

    priv->first_block_index = first_block_index;
    priv->last_block_index = first_block_index + CHANGES_IN_MAP_MAX;

    for (interval_index = 0; ; interval_index++)
    {
        const SBlbBlockInterval *interval;
        gint n_changes_loaded;
        gchar *path;
        gboolean success;

        interval = sblb_block_interval_map_get_interval (priv->block_interval_map, priv->item_path, priv->is_stream, interval_index);
        if (!interval)
            break;

        path = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "runs" G_DIR_SEPARATOR_S "%010" G_GUINT64_FORMAT G_DIR_SEPARATOR_S
                                "blocks-index", priv->repo_path, interval->run_id);

        interval_file = sblb_block_index_file_open (path);
        g_free (path);

        success = sblb_block_index_file_seek_to_index (interval_file, interval->block_map_offset, error);
        if (!success)
        {
            result = -1;
            break;
        }

        n_changes_loaded = load_changes (block_change_map, interval, interval_file, priv->first_block_index,
                                         priv->last_block_index, error);
        if (n_changes_loaded < 0)
        {
            result = -1;
            break;
        }

        result += n_changes_loaded;

        g_object_unref (interval_file);
        interval_file = NULL;
    }

    if (interval_file)
        g_object_unref (interval_file);

    if (result < 0)
    {
        change_map_clear (block_change_map);
        priv->first_block_index = 0;
        priv->last_block_index = 0;
    }

    return result;
}