minetest/src/rollback_interface.h

158 lines
3.9 KiB
C
Raw Normal View History

/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
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>
2014-06-26 02:28:41 +02:00
#include <list>
#include "exceptions.h"
2014-06-26 02:28:41 +02:00
#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;
2014-06-26 02:28:41 +02:00
bool operator == (const RollbackNode &other)
{
return (name == other.name && param1 == other.param1 &&
param2 == other.param2 && meta == other.meta);
}
2014-06-26 02:28:41 +02:00
bool operator != (const RollbackNode &other) { return !(*this == other); }
RollbackNode() = default;
RollbackNode(Map *map, v3s16 p, IGameDef *gamedef);
};
2014-06-26 02:28:41 +02:00
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;
2014-06-26 02:28:41 +02:00
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_,
2014-06-26 02:28:41 +02:00
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;
};
2014-06-26 02:28:41 +02:00
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;
2012-07-27 14:46:51 +02:00
virtual std::string getSuspect(v3s16 p, float nearness_shortcut,
2014-06-26 02:28:41 +02:00
float min_nearness) = 0;
virtual ~IRollbackManager() = default;;
2014-06-26 02:28:41 +02:00
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;
};
2014-06-26 02:28:41 +02:00
class RollbackScopeActor
{
public:
2014-06-26 02:28:41 +02:00
RollbackScopeActor(IRollbackManager * rollback_,
const std::string & actor, bool is_guess = false) :
rollback(rollback_)
{
2014-06-26 02:28:41 +02:00
if (rollback) {
old_actor = rollback->getActor();
old_actor_guess = rollback->isActorGuess();
rollback->setActor(actor, is_guess);
}
}
~RollbackScopeActor()
{
2014-06-26 02:28:41 +02:00
if (rollback) {
rollback->setActor(old_actor, old_actor_guess);
}
}
2014-06-26 02:28:41 +02:00
private:
2014-06-26 02:28:41 +02:00
IRollbackManager * rollback;
std::string old_actor;
bool old_actor_guess;
};