Fix bone-attached entities (#10015)

[oweals/minetest.git] / src / rollback_interface.h

diff --git a/src/rollback_interface.h b/src/rollback_interface.h
index 8dd429d7669473e9f767fd7f63c1293910e13c40..94b800579ca1a20aac1f27ea3ff46c8477e104e6 100644 (file)
--- 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,55 +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;
+       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),
-               unix_time(0),
-               actor_is_guess(false)
-       {}
+       RollbackAction() = default;
 
        void setSetNode(v3s16 p_, const RollbackNode &n_old_,
                        const RollbackNode &n_new_)
@@ -93,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_;
@@ -103,54 +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 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;
+                                      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,
-                       bool is_guess=false):
-               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_actor_was_guess = m_sink->isActorGuess();
-                       m_sink->setActor(actor, is_guess);
+               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, m_actor_was_guess);
+               if (rollback) {
+                       rollback->setActor(old_actor, old_actor_guess);
                }
        }
+
 private:
-       IRollbackReportSink *m_sink;
-       std::string m_actor_was;
-       bool m_actor_was_guess;
+       IRollbackManager * rollback;
+       std::string old_actor;
+       bool old_actor_guess;
 };
-
-#endif