RandomBinaryTree.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2022 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_RANDOM_BINARY_TREE_H
#define GF_RANDOM_BINARY_TREE_H
 
#include <functional>
#include <memory>
 
#include "CoreApi.h"
#include "Random.h"
#include "Rect.h"
#include "Vector.h"
 
namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif
 
  class GF_CORE_API RandomBinaryTree {
  public:
 
    class Node {
    public:
      Node(const RectI& area, std::size_t parent, int level)
      : m_parent(parent)
      , m_left(0)
      , m_right(0)
      , m_level(level)
      , m_area(area)
      {
 
      }
 
      int getLevel() const {
        return m_level;
      }
 
      bool isLeaf() const {
        return m_left == 0 && m_right == 0;
      }
 
      std::size_t getParentIndex() const {
        return m_parent;
      }
 
      std::size_t getLeftChildIndex() const {
        return m_left;
      }
 
      std::size_t getRightChildIndex() const {
        return m_right;
      }
 
      const RectI& getArea() const {
        return m_area;
      }
 
      bool contains(Vector2i position) const {
        return m_area.contains(position);
      }
 
      void setChildrenIndices(std::size_t left, std::size_t right) {
        m_left = left;
        m_right = right;
      }
 
    private:
      std::size_t m_parent;
      std::size_t m_left;
      std::size_t m_right;
      int m_level;
      RectI m_area;
    };
 
    using Callback = std::function<bool(const RandomBinaryTree&, const Node&)>;
 
    RandomBinaryTree(const RectI& area);
 
    void create(Random& random, int levelMax, Vector2i minSize, Vector2i maxSize, float maxRatio = 1.5f);
 
    const Node& getRoot() const;
 
    const Node& getLeftChild(const Node& node) const;
 
    const Node& getRightChild(const Node& node) const;
 
    const Node& getParent(const Node& node) const;
 
 
    bool contains(Vector2i position) const {
      return getRoot().contains(position);
    }
 
    const Node& find(Vector2i position) const;
 
    bool traversePreOrder(Callback callback) const;
 
    bool traverseInOrder(Callback callback) const;
 
    bool traversePostOrder(Callback callback) const;
 
    bool traverseLevelOrder(Callback callback) const;
 
    bool traverseInvertedLevelOrder(Callback callback) const;
 
  private:
    std::vector<Node> m_nodes;
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}
 
#endif // GF_RANDOM_BINARY_TREE_H