X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Frollback_interface.h;h=94b800579ca1a20aac1f27ea3ff46c8477e104e6;hb=8d387433b14791db95e59127b5e6e30f58155c1e;hp=0f0a11885afa64f48f6b1ba587753ada748c3c87;hpb=0190f9b077dcb2b8cb41c622dd91ffc1e04dacac;p=dragonfireclient.git

diff --git a/src/rollback_interface.h b/src/rollback_interface.h
index 0f0a11885..94b800579 100644
--- a/src/rollback_interface.h
+++ b/src/rollback_interface.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+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
@@ -17,13 +17,14 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifndef ROLLBACK_INTERFACE_HEADER
-#define ROLLBACK_INTERFACE_HEADER
+#pragma once
 
 #include "irr_v3d.h"
 #include <string>
 #include <iostream>
+#include <list>
 #include "exceptions.h"
+#include "inventory.h"
 
 class Map;
 class IGameDef;
@@ -33,52 +34,46 @@ class InventoryManager;
 struct RollbackNode
 {
 	std::string name;
-	int param1;
-	int param2;
+	int param1 = 0;
+	int param2 = 0;
 	std::string meta;
 
-	bool operator==(const RollbackNode &other)
+	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);
-	}
+	bool operator != (const RollbackNode &other) { return !(*this == other); }
 
-	RollbackNode():
-		param1(0),
-		param2(0)
-	{}
+	RollbackNode() = default;
 
 	RollbackNode(Map *map, v3s16 p, IGameDef *gamedef);
 };
 
+
 struct RollbackAction
 {
 	enum Type{
 		TYPE_NOTHING,
 		TYPE_SET_NODE,
 		TYPE_MODIFY_INVENTORY_STACK,
-	} type;
+	} type = TYPE_NOTHING;
 
-	int unix_time;
+	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;
-	std::string inventory_stack;
+	ItemStack inventory_stack;
 
-	RollbackAction():
-		type(TYPE_NOTHING)
-	{}
+	RollbackAction() = default;
 
 	void setSetNode(v3s16 p_, const RollbackNode &n_old_,
 			const RollbackNode &n_new_)
@@ -90,8 +85,8 @@ struct RollbackAction
 	}
 
 	void setModifyInventoryStack(const std::string &inventory_location_,
-			const std::string &inventory_list_, int index_,
-			bool add_, const std::string &inventory_stack_)
+			const std::string &inventory_list_, u32 index_,
+			bool add_, const ItemStack &inventory_stack_)
 	{
 		type = TYPE_MODIFY_INVENTORY_STACK;
 		inventory_location = inventory_location_;
@@ -100,46 +95,63 @@ struct RollbackAction
 		inventory_add = add_;
 		inventory_stack = inventory_stack_;
 	}
-	
+
 	// String should not contain newlines or nulls
 	std::string toString() const;
-	void fromStream(std::istream &is) throw(SerializationError);
-	
+
 	// 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 IRollbackReportSink
+
+class IRollbackManager
 {
 public:
-	virtual ~IRollbackReportSink(){}
 	virtual void reportAction(const RollbackAction &action) = 0;
 	virtual std::string getActor() = 0;
-	virtual void setActor(const std::string &actor) = 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(IRollbackReportSink *sink, const std::string &actor):
-		m_sink(sink)
+	RollbackScopeActor(IRollbackManager * rollback_,
+			const std::string & actor, bool is_guess = false) :
+		rollback(rollback_)
 	{
-		if(m_sink){
-			m_actor_was = m_sink->getActor();
-			m_sink->setActor(actor);
+		if (rollback) {
+			old_actor = rollback->getActor();
+			old_actor_guess = rollback->isActorGuess();
+			rollback->setActor(actor, is_guess);
 		}
 	}
 	~RollbackScopeActor()
 	{
-		if(m_sink){
-			m_sink->setActor(m_actor_was);
+		if (rollback) {
+			rollback->setActor(old_actor, old_actor_guess);
 		}
 	}
+
 private:
-	IRollbackReportSink *m_sink;
-	std::string m_actor_was;
+	IRollbackManager * rollback;
+	std::string old_actor;
+	bool old_actor_guess;
 };
-
-#endif