.. _program_listing_file_src_honeycomb_honeycomb.h:

Program Listing for File honeycomb.h
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_honeycomb_honeycomb.h>` (``src/honeycomb/honeycomb.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include <functional>  // for function
   
   #include "core/hex_grid.h"  // for HexGrid
   #include "honeycomb/honeycomb_honey.h"
   #include "tal/arrays.h"     // for Array
   #include "tal/noise.h"      // for FastNoiseLite
   #include "tal/reference.h"  // for Ref
   #include "tal/shader.h"     // for Shader
   #include "tal/texture.h"    // for Texture
   #include "tal/vector3.h"    // for Vector3
   
   namespace sota {
   class HoneycombHoney;
   
   class Honeycomb : public HexGrid {
     GDCLASS(Honeycomb, HexGrid)
   
    public:
     Honeycomb() = default;
     void set_cell_texture(const Ref<Texture> p_cell_texture);
     Ref<Texture> get_cell_texture() const;
   
     void set_honey_texture(const Ref<Texture> p_honey_texture);
     Ref<Texture> get_honey_texture() const;
   
     void set_selection_texture(const Ref<Texture> p_selection_texture);
     Ref<Texture> get_selection_texture() const;
   
     void set_noise(const Ref<FastNoiseLite> p_noise);
     Ref<FastNoiseLite> get_noise() const;
   
     void set_bottom_offset(float p_ridge_bottom_offset);
     float get_bottom_offset() const;
   
     void set_smooth_normals(bool p_smooth_normals);
     bool get_smooth_normals() const;
   
     void set_honey_random_level(bool p_honey_random_level);
     bool get_honey_random_level() const;
   
     void set_honey_min_offset(float p_honey_min_offset);
     float get_honey_min_offset() const;
   
     void set_honey_max_gain(float p_honey_max_gain);
     float get_honey_max_gain() const;
   
     void set_honey_fill_steps(int p_honey_fill_steps);
     int get_honey_fill_steps() const;
   
     void set_honey_shader(const Ref<Shader> p_honey_shader);
     Ref<Shader> get_honey_shader() const;
   
     void set_selection_shader(const Ref<Shader> p_selection_shader);
     Ref<Shader> get_selection_shader() const;
   
     Array get_cells() const;      // return all honey cells
     Array get_min_cells() const;  // find minimum honey level and return all cells which has that level
     Array get_max_cells() const;  // find maximum honey level and return all cells which has that level
     bool all_cells_empty() const;
   
    protected:
     static void _bind_methods();
   
     void init() override;
     void make_tiles() override;
   
     virtual int calculate_honey_id_offset() = 0;
   
    private:
     Ref<Texture> _cell_texture;
     Ref<Texture> _honey_texture;
     Ref<Texture> _selection_texture;
     Ref<Shader> _selection_shader;
     Ref<FastNoiseLite> _noise;
     Ref<Shader> _honey_shader;
     float _bottom_offset{-0.5};
     bool _smooth_normals{false};
     bool _honey_random_level{false};
   
     float _honey_min_offset{-0.45};
     float _honey_max_gain{0.3};
     int _honey_fill_steps{8};
   
     float generate_min_honey_y_offset();
     float generate_random_honey_y_offset();
     float generate_offset(int step);
     float get_honey_step_value();
     int generate_min_honey_step();
     int generate_random_honey_step();
   
     void prepare_heights_calculation();
     void calculate_final_heights();
   
     void calculate_cells();
     void calculate_normals() override;
   
     enum class SortingOrder { INCREASING, DECREASING };
   
     template <typename T>
     void sort(Honeycomb::SortingOrder order, T& container) const {
       if (order == SortingOrder::INCREASING) {
         std::sort(container.begin(), container.end());
       } else if (order == SortingOrder::DECREASING) {
         std::sort(container.rbegin(), container.rend());
       }
     }
   
     std::pair<std::vector<TileMesh*>, std::vector<TileMesh*>> meshes();
   
     Array get_cells_by_order(SortingOrder order, std::function<bool(HoneycombHoney*)> pred) const;
   };
   
   class RectHoneycomb : public Honeycomb {
     GDCLASS(RectHoneycomb, Honeycomb)
    public:
     void set_height(const int p_height);
     int get_height() const;
   
     void set_width(const int p_width);
     int get_width() const;
   
     void init_col_row_layout() override;
     int calculate_id(int row, int col) const override;
     int calculate_honey_id_offset() override;
   
    protected:
     int _height{0};
     int _width{0};
     static void _bind_methods();
   };
   
   class HexagonalHoneycomb : public Honeycomb {
     GDCLASS(HexagonalHoneycomb, Honeycomb)
    public:
     void set_size(const int p_size);
     int get_size() const;
   
     void init_col_row_layout() override;
     int calculate_id(int row, int col) const override;
     int calculate_honey_id_offset() override;
   
     Vector3 get_center() const;
   
    protected:
     int _size{0};
     static void _bind_methods();
   };
   
   }  // namespace sota