.. _program_listing_file_libtcod_tileset.hpp:

Program Listing for File tileset.hpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_libtcod_tileset.hpp>` (``libtcod/tileset.hpp``)

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

.. code-block:: cpp

   /* BSD 3-Clause License
    *
    * Copyright © 2008-2025, Jice and the libtcod contributors.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    *
    * 2. Redistributions in binary form must reproduce the above copyright notice,
    *    this list of conditions and the following disclaimer in the documentation
    *    and/or other materials provided with the distribution.
    *
    * 3. Neither the name of the copyright holder nor the names of its
    *    contributors may be used to endorse or promote products derived from
    *    this software without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    * POSSIBILITY OF SUCH DAMAGE.
    */
   #pragma once
   #ifndef LIBTCOD_TILESET_HPP_
   #define LIBTCOD_TILESET_HPP_
   #include <array>
   #include <filesystem>
   #include <memory>
   
   #include "error.hpp"
   #include "tileset.h"
   
   namespace tcod {
   static constexpr std::array<int, 256> CHARMAP_CP437 = TCOD_CHARMAP_CP437_;
   static constexpr std::array<int, 256> CHARMAP_TCOD = TCOD_CHARMAP_TCOD_;
   
   struct TilesetDeleter {
     void operator()(TCOD_Tileset* tileset) const { TCOD_tileset_delete(tileset); }
   };
   typedef std::unique_ptr<TCOD_Tileset, TilesetDeleter> TilesetPtr;
   
   class Tileset {
    public:
   
     Tileset() = default;
   
     explicit Tileset(int tile_width, int tile_height) : tileset_{TCOD_tileset_new(tile_width, tile_height)} {
       if (!tileset_) throw std::runtime_error(TCOD_get_error());
     }
   
     explicit Tileset(const std::array<int, 2>& tile_shape) : Tileset{tile_shape.at(0), tile_shape.at(1)} {}
   
     explicit Tileset(TilesetPtr ptr) : tileset_{std::move(ptr)} {
       if (!tileset_) throw std::invalid_argument("Pointer must not be nullptr.");
     }
   
     explicit Tileset(TCOD_Tileset* ptr) : tileset_{ptr} {
       if (!tileset_) throw std::invalid_argument("Pointer must not be nullptr.");
     }
   
     [[nodiscard]] auto get_tile_width() const noexcept -> int { return tileset_->tile_width; }
   
     [[nodiscard]] auto get_tile_height() const noexcept -> int { return tileset_->tile_height; }
   
     [[nodiscard]] auto get_tile_shape() const noexcept -> std::array<int, 2> {
       return {tileset_->tile_width, tileset_->tile_height};
     }
   
     [[nodiscard]] auto get() noexcept -> TCOD_Tileset* { return tileset_.get(); }
   
     [[nodiscard]] auto get() const noexcept -> TCOD_Tileset* { return tileset_.get(); }
   
     auto release() noexcept -> TCOD_Tileset* { return tileset_.release(); }
   
     [[nodiscard]] operator TCOD_Tileset&() { return *tileset_; }
   
     [[nodiscard]] operator const TCOD_Tileset&() const { return *tileset_; }
   
    private:
     TilesetPtr tileset_ = nullptr;
   };
   #ifndef TCOD_NO_PNG
   template <typename ArrayType>
   TCOD_NODISCARD inline auto load_tilesheet(
       const std::filesystem::path& path, const std::array<int, 2>& columns_rows, const ArrayType& charmap) -> Tileset {
     tcod::check_path(path);
     TilesetPtr tileset{TCOD_tileset_load(
         path.string().c_str(), columns_rows.at(0), columns_rows.at(1), static_cast<int>(charmap.size()), charmap.data())};
     if (!tileset) throw std::runtime_error(TCOD_get_error());
     return Tileset{std::move(tileset)};
   }
   #endif  // TCOD_NO_PNG
   }  // namespace tcod
   #endif  // LIBTCOD_TILESET_HPP_