world.h

Go to the documentation of this file.

// Copyright (C) 2013-2020 iFunFactory Inc. All Rights Reserved.
//
// This work is confidential and proprietary to iFunFactory Inc. and
// must not be used, disclosed, copied, or distributed without the prior
// consent of iFunFactory Inc.

#ifndef INCLUDE_FUNAPI_SERVICE_WORLD_H_
#define INCLUDE_FUNAPI_SERVICE_WORLD_H_

#include <boost/noncopyable.hpp>
#include <funapi/network/session.h>
#include <funapi/types.h>


namespace fun {

class FUNAPI_DLL_VISIBILITY World : private boost::noncopyable {
 public:
  DECLARE_CLASS_PTR(World);

  class Impl;

  struct FUNAPI_DLL_VISIBILITY Point {
    Point();
    Point(float x, float y, float z);
    float x;
    float y;
    float z;
  };

  struct FUNAPI_DLL_VISIBILITY Sphere {
    Sphere();
    Sphere(const Point &coordinates, float radius);
    Sphere(float x, float y, float z, float radius);
    Point coordinates;
    float radius;
  };

  struct FUNAPI_DLL_VISIBILITY Vector2 {
    Vector2();
    Vector2(float x, float y);
    float x;
    float y;
  };

  struct FUNAPI_DLL_VISIBILITY FindOption {
    FindOption();
    FindOption(bool use_distance_square,
               bool use_sphere_center_for_distance = false,
               bool ignore_z_axis_in_block = false,
               bool use_ascending_order = false,
               size_t boundary_begin = 0,
               size_t boundary_count = -1);
    bool use_distance_square;
    bool use_sphere_center_for_distance;
    bool ignore_z_axis_in_block;
    bool use_ascending_order;
    size_t boundary_begin;
    size_t boundary_count;
  };

  class FUNAPI_DLL_VISIBILITY Object : private boost::noncopyable {
   public:
    class Impl;

    DECLARE_CLASS_PTR(World::Object);

    Object();
    explicit Object(float radius);

    explicit Object(int64_t id);
    Object(int64_t id, float radius);

    virtual ~Object();

    int64_t GetId() const;

    const Point &GetCoordinates() const;
    const Sphere &GetSphere() const;

    const string &GetName() const;
    void SetName(const string &name);

    const float &GetRadius() const;
    void SetRadius(float radius);

    int64_t GetType() const;
    void SetType(int64_t type);

    bool GetValueForKey(const int64_t &key, int64_t *result) const;
    void SetKeyValue(const int64_t &key, const int64_t &value);

    Ptr<Session> GetSession() const;
    void SetSession(const Ptr<Session> &session);

    bool IsSphere();

   private:
    friend class PrivateAccess;
    Impl *impl_;
  };

  typedef function<void(int64_t type, bool exist)> TypeExistenceCallback;

  typedef function<bool(const Point &/*coordinates arg*/,
                        float /*distance arg*/,
                        const Ptr<Object> &/*object*/)> FindFilter;

  typedef function<bool(const Ptr<World::Object> &object)> ObjectFilter;

  typedef std::vector<Ptr<Object> > ObjectVector;
  typedef std::vector<Ptr<Session> > SessionVector;
  typedef std::vector<float> DistanceVector;

  static const int64_t kInvalidId;
  static const FindOption kDefaultOption;
  static const FindFilter kNullFilter;

  static FindFilter MakeFilter(int64_t type_mask);
  static FindFilter MakeMovingSightFilter(const Sphere &previous_coordinates,
                                          int64_t type_mask = 0);
  static FindFilter MakeRectangleFilter(float front_gap,
                                        const Vector2 &direction,
                                        float width,
                                        float depth,
                                        float height,
                                        bool is_sphere = false,
                                        int64_t type_mask = 0);
  static FindFilter MakeCircularSectorFilter(float front_gap,
                                             const Vector2 &direction,
                                             float radius,
                                             float left_angle_in_degree,
                                             float right_angle_in_degree,
                                             float height,
                                             bool is_sphere = false,
                                             int64_t type_mask = 0);

  ~World();

  const string &GetName() const;

  void MonitorTypeExistence(int64_t type,
                            const TypeExistenceCallback &callback);

  int64_t InsertObject(const Point &coordinates,
                       const Ptr<Object> &object) ASSERT_NO_ROLLBACK;
  Ptr<Object> EraseObject(int64_t id) ASSERT_NO_ROLLBACK;
  Ptr<Object> GetObject(int64_t id) const;

  size_t EraseAllObjects(ObjectVector *objects = NULL) ASSERT_NO_ROLLBACK;

  void GetAllObjects(const ObjectFilter &filter,
                     ObjectVector *objects) const;
  void GetAllObjects(ObjectVector *objects) const;

  size_t GetObjectCount() const;

  bool MoveObjectTo(int64_t id, const Point &coordinate) ASSERT_NO_ROLLBACK;
  bool MoveObject(int64_t id, const Point &coordinates_delta,
                  Point *new_coordinates = NULL) ASSERT_NO_ROLLBACK;

  void FindObject(const Point &coordinates, float distance,
                  ObjectVector *objects);
  void FindObject(const Point &coordinates, float distance,
                  const FindOption &option, ObjectVector *objects,
                  DistanceVector *distances = NULL);
  void FindObject(const Point &coordinates, float distance,
                  const FindOption &option, const FindFilter &filter,
                  ObjectVector *objects, DistanceVector *distances = NULL);

  void FindObject(int64_t id, float distance, ObjectVector *objects);
  void FindObject(int64_t id, float distance, const FindOption &option,
                  ObjectVector *objects, DistanceVector *distances = NULL);
  void FindObject(int64_t id, float distance, const FindOption &option,
                  const FindFilter &filter, ObjectVector *objects,
                  DistanceVector *distances = NULL);

  void FindSession(const Point &coordinates, float distance,
                   SessionVector *out);
  void FindSession(const Point &coordinates, float distance,
                   const FindOption &option, SessionVector *out);
  void FindSession(const Point &coordinates, float distance,
                   const FindOption &option, const FindFilter &filter,
                   SessionVector *out);

  void FindSession(int64_t id, float distance, SessionVector *out);
  void FindSession(int64_t id, float distance, const FindOption &option,
                   SessionVector *out);
  void FindSession(int64_t id, float distance, const FindOption &option,
                   const FindFilter &filter, SessionVector *out);

  void Broadcast(const Point &coordinates, float distance,
                 const string &message_type, const Json &message,
                 Encryption encryption, TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;
  void Broadcast(const Point &coordinates, float distance,
                 const string &message_type, const Ptr<FunMessage> &message,
                 Encryption encryption, TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;
  void Broadcast(const Point &coordinates, float distance,
                 int32_t message_type, const Ptr<FunMessage> &message,
                 Encryption encryption, TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;
  void Broadcast(const Point &coordinates, float distance,
                 const ProtobufExtensionIdentifier &message_type,
                 const Ptr<FunMessage> &message, Encryption encryption,
                 TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;

  void Broadcast(int64_t id, float distance, const string &message_type,
                 const Json &message, Encryption encryption,
                 TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;
  void Broadcast(int64_t id, float distance, const string &message_type,
                 const Ptr<FunMessage> &message, Encryption encryption,
                 TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;
  void Broadcast(int64_t id, float distance, int32_t message_type,
                 const Ptr<FunMessage> &message, Encryption encryption,
                 TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;
  void Broadcast(int64_t id, float distance,
                 const ProtobufExtensionIdentifier &message_type,
                 const Ptr<FunMessage> &message, Encryption encryption,
                 TransportProtocol protocol,
                 const FindOption &option = kDefaultOption,
                 const FindFilter &filter = kNullFilter) ASSERT_NO_ROLLBACK;

  void Broadcast(const string &message_type, const Json &message,
                 Encryption encryption,
                 TransportProtocol protocol) ASSERT_NO_ROLLBACK;
  void Broadcast(const string &message_type, const Ptr<FunMessage> &message,
                 Encryption encryption,
                 TransportProtocol protocol) ASSERT_NO_ROLLBACK;
  void Broadcast(int32_t message_type, const Ptr<FunMessage> &message,
                 Encryption encryption,
                 TransportProtocol protocol) ASSERT_NO_ROLLBACK;
  void Broadcast(const ProtobufExtensionIdentifier &message_type,
                 const Ptr<FunMessage> &message, Encryption encryption,
                 TransportProtocol protocol) ASSERT_NO_ROLLBACK;

  void InsertStaticObject(const Point &coordinates,
                          const Ptr<Object> &object);
  void FindStaticObject(int64_t id, const FindOption &option,
                        const FindFilter &filter, ObjectVector *objects,
                        DistanceVector *distances = NULL);
  void FindStaticObject(const Point &coordinates, const FindOption &option,
                        const FindFilter &filter, ObjectVector *objects,
                        DistanceVector *distances = NULL);

  bool IsDeleted() const;

  void SetSingleThreadMode();

 private:
  friend class PrivateAccess;
  explicit World(const string &name, float index_block_length);
  Impl *impl_;
};


class FUNAPI_DLL_VISIBILITY WorldManager {
 public:
  struct FUNAPI_DLL_VISIBILITY Zone {
    string name;
    string type;
    World::Sphere sphere;
    Json argument;
  };
  typedef std::vector<Zone> ZoneVector;

  typedef function<void(const Ptr<World> &/*world*/)> CreateCallback;
  typedef function<void(const Rpc::PeerId &/*peer_id*/)> FindServerCallback;
  typedef function<
      void(const string &/*world name*/, const string &/*zone name*/,
           const string &/*type*/, const Json &/*arguments*/, bool /*enter*/,
           const Ptr<World::Object> &/*object*/)> ZoneHandler;

  static void Create(const string &name, const ZoneVector &zones,
                     float index_block_length, const CreateCallback &callback,
                     int64_t channel = 0) ASSERT_NO_ROLLBACK;
  static Ptr<World> Get(const string &name, int64_t channel = 0);
  static bool Delete(const string &name,
                     int64_t channel = 0) ASSERT_NO_ROLLBACK;
  static void FindServer(const string &name,
                         const FindServerCallback &callback,
                         int64_t channel = 0) ASSERT_NO_ROLLBACK;

  static Ptr<World> CreateLocal(const string &name, const ZoneVector &zones,
                                float index_block_length,
                                int64_t channel = 0) ASSERT_NO_ROLLBACK;
  static Ptr<World> GetLocal(const string &name, int64_t channel = 0);
  static bool DeleteLocal(const string &name,
                          int64_t channel = 0) ASSERT_NO_ROLLBACK;

  static void RegisterZoneHandler(const ZoneHandler &handler);
};


FUNAPI_DLL_VISIBILITY
std::ostream &operator<<(std::ostream &out, const World::Point &point);

FUNAPI_DLL_VISIBILITY
std::ostream &operator<<(std::ostream &out, const World::Sphere &sphere);

}  // namespace fun

#endif  // INCLUDE_FUNAPI_SERVICE_WORLD_H_