.. _program_listing_file_libtcod_console.h:

Program Listing for File console.h
==================================

|exhale_lsh| :ref:`Return to documentation for file <file_libtcod_console.h>` (``libtcod/console.h``)

.. |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 TCOD_CONSOLE_H_
   #define TCOD_CONSOLE_H_
   
   #include <stdbool.h>
   #ifdef __cplusplus
   #include <algorithm>
   #include <array>
   #include <memory>
   #include <optional>
   #include <stdexcept>
   #include <utility>
   
   #include "error.hpp"
   #endif  // __cplusplus
   
   #include "color.h"
   #include "config.h"
   #include "error.h"
   #include "tileset.h"
   typedef enum {
     TCOD_BKGND_NONE,
     TCOD_BKGND_SET,
     TCOD_BKGND_MULTIPLY,
     TCOD_BKGND_LIGHTEN,
     TCOD_BKGND_DARKEN,
     TCOD_BKGND_SCREEN,
     TCOD_BKGND_COLOR_DODGE,
     TCOD_BKGND_COLOR_BURN,
     TCOD_BKGND_ADD,
     TCOD_BKGND_ADDA,
     TCOD_BKGND_BURN,
     TCOD_BKGND_OVERLAY,
     TCOD_BKGND_ALPH,
     TCOD_BKGND_DEFAULT
   } TCOD_bkgnd_flag_t;
   typedef enum { TCOD_LEFT, TCOD_RIGHT, TCOD_CENTER } TCOD_alignment_t;
   
   typedef struct TCOD_ConsoleTile {
   #ifdef __cplusplus
     bool operator==(const TCOD_ConsoleTile& rhs) const noexcept { return ch == rhs.ch && fg == rhs.fg && bg == rhs.bg; }
     bool operator!=(const TCOD_ConsoleTile& rhs) const noexcept { return !(*this == rhs); }
   #endif  // __cplusplus
   
     int ch;
   
     TCOD_ColorRGBA fg;
   
     TCOD_ColorRGBA bg;
   } TCOD_ConsoleTile;
   
   struct TCOD_Console {
   #ifdef __cplusplus
   
     [[nodiscard]] auto begin() noexcept -> TCOD_ConsoleTile* { return tiles; }
   
     [[nodiscard]] auto begin() const noexcept -> const TCOD_ConsoleTile* { return tiles; }
   
     [[nodiscard]] auto end() noexcept -> TCOD_ConsoleTile* { return tiles + elements; }
   
     [[nodiscard]] auto end() const noexcept -> const TCOD_ConsoleTile* { return tiles + elements; }
   
     void clear(const TCOD_ConsoleTile& tile = {0x20, {255, 255, 255, 255}, {0, 0, 0, 255}}) noexcept {
       for (auto& it : *this) it = tile;
     }
   
     [[nodiscard]] auto operator[](const std::array<int, 2>& xy) noexcept -> TCOD_ConsoleTile& {
       return tiles[get_index(xy)];
     }
   
     [[nodiscard]] auto operator[](const std::array<int, 2>& xy) const noexcept -> const TCOD_ConsoleTile& {
       return tiles[get_index(xy)];
     }
   
     [[nodiscard]] auto at(const std::array<int, 2>& xy) -> TCOD_ConsoleTile& { return tiles[bounds_check(xy)]; }
   
     [[nodiscard]] auto at(const std::array<int, 2>& xy) const -> const TCOD_ConsoleTile& {
       return tiles[bounds_check(xy)];
     }
   
     [[nodiscard]] auto at(int x, int y) -> TCOD_ConsoleTile& { return at({x, y}); }
   
     [[nodiscard]] auto at(int x, int y) const -> const TCOD_ConsoleTile& { return at({x, y}); }
   
     [[nodiscard]] int get_index(const std::array<int, 2>& xy) const noexcept { return w * xy[1] + xy[0]; }
   
     [[nodiscard]] bool in_bounds(const std::array<int, 2>& xy) const noexcept {
       return 0 <= xy[0] && xy[0] < w && 0 <= xy[1] && xy[1] < h;
     }
   
    private:
   
     int bounds_check(const std::array<int, 2>& xy) const {
       if (!in_bounds(xy)) {
         throw std::out_of_range(
             std::string("Out of bounds lookup {") + std::to_string(xy[0]) + ", " + std::to_string(xy[1]) +
             "} on console of shape {" + std::to_string(w) + ", " + std::to_string(h) + "}.");
       }
       return get_index(xy);
     }
   
    public:
   #endif  // __cplusplus
     int w, h;
     TCOD_ConsoleTile* __restrict tiles;
     TCOD_bkgnd_flag_t bkgnd_flag;
     TCOD_alignment_t alignment;
     TCOD_color_t fore, back;
     bool has_key_color;
     TCOD_color_t key_color;
     int elements;
     void* userdata;
     void (*on_delete)(struct TCOD_Console* self);
   };
   typedef struct TCOD_Console TCOD_Console;
   typedef struct TCOD_Console* TCOD_console_t;
   #ifdef __cplusplus
   extern "C" {
   #endif  // __cplusplus
   TCOD_PUBLIC TCOD_NODISCARD TCOD_Console* TCOD_console_new(int w, int h);
   TCOD_PUBLIC TCOD_NODISCARD int TCOD_console_get_width(const TCOD_Console* con);
   TCOD_PUBLIC TCOD_NODISCARD int TCOD_console_get_height(const TCOD_Console* con);
   TCOD_PUBLIC void TCOD_console_set_key_color(TCOD_Console* con, TCOD_color_t col);
   TCOD_PUBLIC void TCOD_console_blit(
       const TCOD_Console* __restrict src,
       int xSrc,
       int ySrc,
       int wSrc,
       int hSrc,
       TCOD_Console* __restrict dst,
       int xDst,
       int yDst,
       float foreground_alpha,
       float background_alpha);
   TCOD_PUBLIC void TCOD_console_blit_key_color(
       const TCOD_Console* __restrict src,
       int xSrc,
       int ySrc,
       int wSrc,
       int hSrc,
       TCOD_Console* __restrict dst,
       int xDst,
       int yDst,
       float foreground_alpha,
       float background_alpha,
       const TCOD_color_t* key_color);
   TCOD_PUBLIC void TCOD_console_delete(TCOD_Console* console);
   
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC void TCOD_console_set_default_background(TCOD_Console* con, TCOD_color_t col);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC void TCOD_console_set_default_foreground(TCOD_Console* con, TCOD_color_t col);
   TCOD_PUBLIC void TCOD_console_clear(TCOD_Console* con);
   TCOD_DEPRECATED("Replace with TCOD_console_put_rgb.")
   TCOD_PUBLIC void TCOD_console_set_char_background(
       TCOD_Console* con, int x, int y, TCOD_color_t col, TCOD_bkgnd_flag_t flag);
   TCOD_DEPRECATED("Replace with TCOD_console_put_rgb.")
   TCOD_PUBLIC void TCOD_console_set_char_foreground(TCOD_Console* con, int x, int y, TCOD_color_t col);
   TCOD_DEPRECATED("Replace with TCOD_console_put_rgb.")
   TCOD_PUBLIC void TCOD_console_set_char(TCOD_Console* con, int x, int y, int c);
   TCOD_DEPRECATED("Replace with TCOD_console_put_rgb.")
   TCOD_PUBLIC void TCOD_console_put_char(TCOD_Console* con, int x, int y, int c, TCOD_bkgnd_flag_t flag);
   TCOD_DEPRECATED("Replace with TCOD_console_put_rgb.")
   TCOD_PUBLIC void TCOD_console_put_char_ex(TCOD_Console* con, int x, int y, int c, TCOD_color_t fore, TCOD_color_t back);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC void TCOD_console_set_background_flag(TCOD_Console* con, TCOD_bkgnd_flag_t flag);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC TCOD_NODISCARD TCOD_bkgnd_flag_t TCOD_console_get_background_flag(TCOD_Console* con);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC void TCOD_console_set_alignment(TCOD_Console* con, TCOD_alignment_t alignment);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC TCOD_NODISCARD TCOD_alignment_t TCOD_console_get_alignment(TCOD_Console* con);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC TCOD_NODISCARD TCOD_color_t TCOD_console_get_default_background(TCOD_Console* con);
   TCOD_DEPRECATED("Console defaults have been deprecated.")
   TCOD_PUBLIC TCOD_NODISCARD TCOD_color_t TCOD_console_get_default_foreground(TCOD_Console* con);
   TCOD_PUBLIC TCOD_NODISCARD TCOD_color_t TCOD_console_get_char_background(const TCOD_Console* con, int x, int y);
   TCOD_PUBLIC TCOD_NODISCARD TCOD_color_t TCOD_console_get_char_foreground(const TCOD_Console* con, int x, int y);
   TCOD_PUBLIC TCOD_NODISCARD int TCOD_console_get_char(const TCOD_Console* con, int x, int y);
   TCOD_DEPRECATED("This function does not support contexts.")
   TCOD_PUBLIC
   void TCOD_console_set_fade(uint8_t val, TCOD_color_t fade_color);
   TCOD_PUBLIC TCOD_NODISCARD uint8_t TCOD_console_get_fade(void);
   TCOD_PUBLIC TCOD_NODISCARD TCOD_color_t TCOD_console_get_fading_color(void);
   void TCOD_console_resize_(TCOD_Console* console, int width, int height);
   #ifdef __cplusplus
   }  // extern "C"
   #endif  // __cplusplus
   #endif  // TCOD_CONSOLE_H_