rollback_interface.h

Go to the documentation of this file.

/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
 
#pragma once
 
#include "irr_v3d.h"
#include <string>
#include <iostream>
#include <list>
#include "exceptions.h"
#include "inventory.h"
 
class Map;
class IGameDef;
struct MapNode;
class InventoryManager;
 
struct RollbackNode
{
    std::string name;
    int param1 = 0;
    int param2 = 0;
    std::string meta;
 
    bool operator == (const RollbackNode &other)
    {
        return (name == other.name && param1 == other.param1 &&
                param2 == other.param2 && meta == other.meta);
    }
    bool operator != (const RollbackNode &other) { return !(*this == other); }
 
    RollbackNode() = default;
 
    RollbackNode(Map *map, v3s16 p, IGameDef *gamedef);
};
 
 
struct RollbackAction
{
    enum Type{
        TYPE_NOTHING,
        TYPE_SET_NODE,
        TYPE_MODIFY_INVENTORY_STACK,
    } type = TYPE_NOTHING;
 
    time_t unix_time = 0;
    std::string actor;
    bool actor_is_guess = false;
 
    v3s16 p;
    RollbackNode n_old;
    RollbackNode n_new;
 
    std::string inventory_location;
    std::string inventory_list;
    u32 inventory_index;
    bool inventory_add;
    ItemStack inventory_stack;
 
    RollbackAction() = default;
 
    void setSetNode(v3s16 p_, const RollbackNode &n_old_,
            const RollbackNode &n_new_)
    {
        type = TYPE_SET_NODE;
        p = p_;
        n_old = n_old_;
        n_new = n_new_;
    }
 
    void setModifyInventoryStack(const std::string &inventory_location_,
            const std::string &inventory_list_, u32 index_,
            bool add_, const ItemStack &inventory_stack_)
    {
        type = TYPE_MODIFY_INVENTORY_STACK;
        inventory_location = inventory_location_;
        inventory_list = inventory_list_;
        inventory_index = index_;
        inventory_add = add_;
        inventory_stack = inventory_stack_;
    }
 
    // String should not contain newlines or nulls
    std::string toString() const;
 
    // Eg. flowing water level changes are not important
    bool isImportant(IGameDef *gamedef) const;
 
    bool getPosition(v3s16 *dst) const;
 
    bool applyRevert(Map *map, InventoryManager *imgr, IGameDef *gamedef) const;
};
 
 
class IRollbackManager
{
public:
    virtual void reportAction(const RollbackAction &action) = 0;
    virtual std::string getActor() = 0;
    virtual bool isActorGuess() = 0;
    virtual void setActor(const std::string &actor, bool is_guess) = 0;
    virtual std::string getSuspect(v3s16 p, float nearness_shortcut,
                                   float min_nearness) = 0;
 
    virtual ~IRollbackManager() = default;;
    virtual void flush() = 0;
    // Get all actors that did something to position p, but not further than
    // <seconds> in history
    virtual std::list<RollbackAction> getNodeActors(v3s16 pos, int range,
                    time_t seconds, int limit) = 0;
    // Get actions to revert <seconds> of history made by <actor>
    virtual std::list<RollbackAction> getRevertActions(const std::string &actor,
                    time_t seconds) = 0;
};
 
 
class RollbackScopeActor
{
public:
    RollbackScopeActor(IRollbackManager * rollback_,
            const std::string & actor, bool is_guess = false) :
        rollback(rollback_)
    {
        if (rollback) {
            old_actor = rollback->getActor();
            old_actor_guess = rollback->isActorGuess();
            rollback->setActor(actor, is_guess);
        }
    }
    ~RollbackScopeActor()
    {
        if (rollback) {
            rollback->setActor(old_actor, old_actor_guess);
        }
    }
 
private:
    IRollbackManager * rollback;
    std::string old_actor;
    bool old_actor_guess;
};