/*
 * Copyright 2018,2022 Jacob Lifshay
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */

// originally from https://github.com/programmerjake/rv32/tree/v0.1.0.1-alpha/software

#include <cstdint>
#include <limits>

#ifdef EMULATE_TARGET
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>

static inline void usb_putchar(int ch) noexcept
{
    unsigned char buf = ch;
    while(write(STDOUT_FILENO, static_cast<const void *>(&buf), 1) < 0)
    {
        int err = errno;
        switch(err)
        {
#if EAGAIN != EWOULDBLOCK
        case EWOULDBLOCK:
#endif
        case EAGAIN:
        {
            // stdin and stdout might be the same file, so we need to handle
            // O_NONBLOCK stuff here too
            pollfd fd = {.fd = STDOUT_FILENO, .events = POLLOUT, .revents = 0};
            while(poll(&fd, 1, -1) < 0)
            {
                err = errno;
                if(err != EINTR)
                    exit(1);
            }
            break;
        }
        case EINTR:
            break;
        default:
            exit(1);
        }
    }
}

static termios original_tios;

static void handle_exit()
{
    tcsetattr(0, TCSADRAIN, &original_tios);
}

static void handle_signal(int sig)
{
    signal(sig, SIG_DFL);
    handle_exit();
    raise(sig);
}

static void usb_console_init() noexcept
{
    struct termios tios;
    if(tcgetattr(0, &tios) < 0)
    {
        int err = errno;
        if(err != ENOTTY)
            exit(1);
    }
    else
    {
        original_tios = tios;
        atexit(handle_exit);
        cfmakeraw(&tios);
        tios.c_lflag |= ISIG;
        if(tcsetattr(0, TCSADRAIN, &tios) < 0)
            exit(1);
        if(signal(SIGINT, handle_signal) == SIG_IGN)
            signal(SIGINT, SIG_IGN);
        if(signal(SIGTERM, handle_signal) == SIG_IGN)
            signal(SIGTERM, SIG_IGN);
    }
    int flags = fcntl(STDIN_FILENO, F_GETFL);
    if(flags < 0)
        exit(1);
    flags |= O_NONBLOCK;
    if(fcntl(STDIN_FILENO, F_SETFL, flags) < 0)
        exit(1);
}

static int usb_peek_buf = -1;

static inline void usb_fill_buf() noexcept
{
    if(usb_peek_buf != -1)
        return;
    unsigned char buf;
    int result = read(STDIN_FILENO, static_cast<void *>(&buf), 1);
    if(result < 0)
    {
        int err = errno;
        switch(err)
        {
#if EAGAIN != EWOULDBLOCK
        case EWOULDBLOCK:
#endif
        case EAGAIN:
        case EINTR:
            break;
        default:
            exit(1);
        }
    }
    else if(result > 0)
        usb_peek_buf = buf;
}

static inline bool usb_havechar() noexcept
{
    usb_fill_buf();
    return usb_peek_buf != -1;
}

static inline int usb_getchar() noexcept
{
    // we don't need to ever bother to block, since the code always checks usb_havechar first
    usb_fill_buf();
    int retval = usb_peek_buf;
    usb_peek_buf = -1;
    return retval;
}
#else
#include "console.h"
#include "liteuart_console.h"
#endif

#if USE_CP437
#define USE_CP437 1
#define USE_UTF8 0
#else
#define USE_CP437 0
#define USE_UTF8 1
#endif

static inline void my_putchar_inner(unsigned char ch) noexcept
{
    usb_putchar(ch);
#ifndef EMULATE_TARGET
    putchar(ch);
#endif
}

static inline void my_puts_inner(const char *s) noexcept
{
    while(*s)
        my_putchar_inner(*s++);
}

static inline void my_putchar(int ch) noexcept
{
    ch = static_cast<unsigned char>(ch);
#if USE_UTF8
    switch(ch)
    {
    case 0xB2:
        my_puts_inner("\u2593");
        break;
    case 0xB1:
        my_puts_inner("\u2592");
        break;
    case 0xB0:
        my_puts_inner("\u2591");
        break;
    case 0xCE:
        my_puts_inner("\u256C");
        break;
    default:
        my_putchar_inner(ch);
    }
#else
    my_putchar_inner(ch);
#endif
}

static inline void write_hex_digit(int value)
{
    my_putchar("0123456789ABCDEF"[value]);
}

static inline void write_hex_u8(std::uint8_t value)
{
    write_hex_digit(value >> 4);
    write_hex_digit(value & 0xF);
}

static inline void write_hex_u16(std::uint16_t value)
{
    write_hex_u8(value >> 8);
    write_hex_u8(value & 0xFF);
}

static inline void write_hex_u32(std::uint32_t value)
{
    write_hex_u16(value >> 16);
    write_hex_u16(value & 0xFFFF);
}

static inline void my_puts(const char *str)
{
    while(*str)
        my_putchar(*str++);
}

constexpr std::size_t screen_x_size = 800 / 8;
constexpr std::size_t screen_y_size = 600 / 8;

template <typename T>
struct get_double_length_type;

template <>
struct get_double_length_type<std::uint8_t>
{
    typedef std::uint16_t type;
};

template <>
struct get_double_length_type<std::uint16_t>
{
    typedef std::uint32_t type;
};

template <>
struct get_double_length_type<std::uint32_t>
{
    typedef std::uint64_t type;
};

template <>
struct get_double_length_type<std::int8_t>
{
    typedef std::int16_t type;
};

template <>
struct get_double_length_type<std::int16_t>
{
    typedef std::int32_t type;
};

template <>
struct get_double_length_type<std::int32_t>
{
    typedef std::int64_t type;
};

template <typename T>
constexpr T bidirectional_shift_left(T value, int amount) noexcept
{
    int max_shift = std::numeric_limits<T>::digits;
    if(amount <= -max_shift)
        return value < 0 ? -1 : 0;
    if(amount < 0)
        return value >> -amount;
    return value << amount;
}

template <typename T>
constexpr T bidirectional_shift_right(T value, int amount) noexcept
{
    return bidirectional_shift_left(value, -amount);
}

template <typename T = std::int32_t, std::size_t FractionalBits = 16>
class Fixed
{
public:
    typedef T underlying_type;
    typedef typename get_double_length_type<T>::type double_length_type;
    static constexpr std::size_t total_bits = std::numeric_limits<T>::digits;
    static constexpr std::size_t fractional_bits = FractionalBits;
    static constexpr std::size_t integer_bits = total_bits - fractional_bits;
    static constexpr T fraction_mask = (static_cast<T>(1) << fractional_bits) - 1;
    static constexpr T integer_mask = ~fraction_mask;
    static_assert(total_bits >= fractional_bits, "");

private:
    underlying_type value;

public:
    constexpr Fixed() noexcept : value(0)
    {
    }
    constexpr Fixed(signed char v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(short v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(int v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(long v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(long long v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(unsigned char v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(char v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(unsigned short v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(unsigned v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(unsigned long v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(unsigned long long v) noexcept : value(static_cast<T>(v) << fractional_bits)
    {
    }
    constexpr Fixed(float v) noexcept
        : value(static_cast<T>(static_cast<float>(1ULL << fractional_bits) * v))
    {
    }
    constexpr Fixed(double v) noexcept
        : value(static_cast<T>(static_cast<double>(1ULL << fractional_bits) * v))
    {
    }
    constexpr explicit operator T() const noexcept
    {
        if(value < 0)
            return (value + fraction_mask) >> fractional_bits;
        return value >> fractional_bits;
    }
    constexpr explicit operator double() const noexcept
    {
        return value * (1.0 / (1ULL << fractional_bits));
    }
    static constexpr Fixed make(T underlying_value) noexcept
    {
        Fixed retval;
        retval.value = underlying_value;
        return retval;
    }
    constexpr Fixed operator+() const noexcept
    {
        return *this;
    }
    constexpr Fixed operator-() const noexcept
    {
        return make(-value);
    }
    friend constexpr Fixed operator+(Fixed a, Fixed b) noexcept
    {
        return make(a.value + b.value);
    }
    friend constexpr Fixed operator-(Fixed a, Fixed b) noexcept
    {
        return make(a.value - b.value);
    }
    friend constexpr Fixed operator*(Fixed a, Fixed b) noexcept
    {
        return make(static_cast<double_length_type>(a.value) * b.value >> fractional_bits);
    }
    friend constexpr Fixed operator/(Fixed a, Fixed b) noexcept
    {
        if(b.value == 0)
        {
            b.value = 1;
        }
        return make((static_cast<double_length_type>(a.value) << fractional_bits) / b.value);
    }
    constexpr Fixed &operator+=(Fixed rt) noexcept
    {
        return *this = *this + rt;
    }
    constexpr Fixed &operator-=(Fixed rt) noexcept
    {
        return *this = *this - rt;
    }
    constexpr Fixed &operator*=(Fixed rt) noexcept
    {
        return *this = *this * rt;
    }
    constexpr Fixed &operator/=(Fixed rt) noexcept
    {
        return *this = *this / rt;
    }
    constexpr T underlying_value() const noexcept
    {
        return value;
    }
    friend constexpr bool operator==(Fixed a, Fixed b) noexcept
    {
        return a.value == b.value;
    }
    friend constexpr bool operator!=(Fixed a, Fixed b) noexcept
    {
        return a.value != b.value;
    }
    friend constexpr bool operator<=(Fixed a, Fixed b) noexcept
    {
        return a.value <= b.value;
    }
    friend constexpr bool operator>=(Fixed a, Fixed b) noexcept
    {
        return a.value >= b.value;
    }
    friend constexpr bool operator<(Fixed a, Fixed b) noexcept
    {
        return a.value < b.value;
    }
    friend constexpr bool operator>(Fixed a, Fixed b) noexcept
    {
        return a.value > b.value;
    }
    friend constexpr Fixed floor(Fixed v) noexcept
    {
        v.value &= integer_mask;
        return v;
    }
    friend constexpr Fixed fracf(Fixed v) noexcept
    {
        v.value &= fraction_mask;
        return v;
    }
    friend constexpr Fixed ceil(Fixed v) noexcept
    {
        v.value += fraction_mask;
        return floor(v);
    }
    friend constexpr Fixed round(Fixed v) noexcept
    {
        constexpr Fixed one_half = 0.5;
        v += one_half;
        return floor(v);
    }
    friend constexpr T floori(Fixed v) noexcept
    {
        return v.value >> fractional_bits;
    }
    friend constexpr T ceili(Fixed v) noexcept
    {
        v.value += fraction_mask;
        return floori(v);
    }
    friend constexpr T roundi(Fixed v) noexcept
    {
        constexpr Fixed one_half = 0.5;
        v += one_half;
        return floori(v);
    }
    friend constexpr Fixed abs(Fixed v) noexcept
    {
        if(v.value < 0)
            return -v;
        return v;
    }
    friend constexpr Fixed sqrt(Fixed v) noexcept
    {
        if(v <= 0)
            return 0;
        Fixed guess = 0;
        double_length_type guess_squared = 0;
        for(int bit_index = (integer_bits + 1) / 2; bit_index >= -static_cast<int>(fractional_bits);
            bit_index--)
        {
            Fixed new_guess = guess + make(static_cast<T>(1) << (bit_index + fractional_bits));
            double_length_type new_guess_squared = guess_squared;
            new_guess_squared += bidirectional_shift_left(
                static_cast<double_length_type>(guess.value), bit_index + 1);
            new_guess_squared += bidirectional_shift_left(
                static_cast<double_length_type>(Fixed(1).value), 2 * bit_index);
            if(new_guess_squared < v.value)
            {
                guess = new_guess;
                guess_squared = new_guess_squared;
            }
            else if(new_guess_squared == v.value)
                return new_guess;
        }
        return guess;
    }
};

enum class Block : char
{
    Empty = ' ',
    Wall = '|',
    End = 'X'
};

constexpr double constexpr_sin2pi(double x) noexcept
{
    x -= static_cast<long long>(x);
    if(x < 0)
        x += 1;
    if(x == 0)
        return 0;
    if(x == 0.25)
        return 1;
    if(x == 0.5)
        return 0;
    if(x == 0.75)
        return -1;
    double x2 = x * x;
    const double coefficients[] = {
        1.5873670538243229332222957023504872028033458258785e-8,
        -3.2649283479971170585768247133750680886632233028762e-7,
        5.8056524029499061679627827975252772363553363262495e-6,
        -8.8235335992430051344844841671401871742374913922057e-5,
        1.1309237482517961877702180414488525515732161905954e-3,
        -1.2031585942120627233202567845286556653885737182738e-2,
        1.0422916220813984117271044898760411097029995316417e-1,
        -7.1812230177850051223174027860686238053986168884284e-1,
        3.8199525848482821277337920673404661254406128731422,
        -1.5094642576822990391826616232531520514481435107371e1,
        4.205869394489765314498681114813355254161277992845e1,
        -7.6705859753061385841630641093893125889966539055122e1,
        8.1605249276075054203397682678249495061413521767487e1,
        -4.1341702240399760233968420089468526936300384754514e1,
        6.2831853071795864769252867665590057683943387987502,
    };
    double v = 0;
    for(double coeff : coefficients)
        v = v * x2 + coeff;
    return x * v;
}

constexpr double constexpr_cos2pi(double x) noexcept
{
    x -= static_cast<long long>(x);
    x += 0.25;
    return constexpr_sin2pi(x);
}

template <std::size_t N = 65>
struct SinCosList
{
    static_assert(N > 1, "");
    constexpr std::size_t size() const noexcept
    {
        return N;
    }
    Fixed<> sin_table[N];
    constexpr SinCosList() noexcept : sin_table{}
    {
        for(std::size_t i = 0; i < N; i++)
        {
            double rotations = i / (4.0 * (N - 1));
            sin_table[i] = constexpr_sin2pi(rotations);
        }
    }
    constexpr void get(Fixed<> &sin_out, Fixed<> &cos_out, Fixed<> rotations) const noexcept
    {
        rotations = fracf(rotations) * 4;
        int quadrent = floori(rotations);
        rotations = (N - 1) * fracf(rotations);
        auto int_part = floori(rotations);
        auto fraction = fracf(rotations);
        auto sin_value =
            sin_table[int_part] + fraction * (sin_table[int_part + 1] - sin_table[int_part]);
        auto cos_value =
            sin_table[N - 1 - int_part]
            + fraction * (sin_table[N - 1 - int_part - 1] - sin_table[N - 1 - int_part]);
        switch(quadrent)
        {
        case 1:
            sin_out = cos_value;
            cos_out = -sin_value;
            break;
        case 2:
            sin_out = -sin_value;
            cos_out = -cos_value;
            break;
        case 3:
            sin_out = -cos_value;
            cos_out = sin_value;
            break;
        default:
            sin_out = sin_value;
            cos_out = cos_value;
            break;
        }
    }
    constexpr Fixed<> get_sin(Fixed<> rotations) const noexcept
    {
        Fixed<> sin, cos;
        get(sin, cos, rotations);
        return sin;
    }
    constexpr Fixed<> get_cos(Fixed<> rotations) const noexcept
    {
        Fixed<> sin, cos;
        get(sin, cos, rotations);
        return cos;
    }
};

constexpr auto sin_cos_list = SinCosList<>();

constexpr void rotate(Fixed<> &x, Fixed<> &y, Fixed<> rotations)
{
    Fixed<> sin, cos;
    sin_cos_list.get(sin, cos, rotations);
    auto new_x = x * cos - y * sin;
    auto new_y = x * sin + y * cos;
    x = new_x;
    y = new_y;
}

inline void write_fixed(Fixed<> v)
{
    write_hex_u32(floori(v));
    my_putchar('.');
    write_hex_u16(floori(fracf(v) * 0x10000));
}

template <typename T>
struct Vec2D
{
    typedef T element_type;
    T x, y;
    constexpr Vec2D() noexcept : x(), y()
    {
    }
    constexpr explicit Vec2D(T v) noexcept : x(v), y(v)
    {
    }
    constexpr Vec2D(T x, T y) noexcept : x(x), y(y)
    {
    }
    friend constexpr Vec2D operator+(Vec2D a, Vec2D b) noexcept
    {
        return Vec2D(a.x + b.x, a.y + b.y);
    }
    constexpr Vec2D operator-() const noexcept
    {
        return Vec2D(-x, -y);
    }
    friend constexpr Vec2D operator-(Vec2D a, Vec2D b) noexcept
    {
        return Vec2D(a.x - b.x, a.y - b.y);
    }
    friend constexpr Vec2D operator*(T a, Vec2D b) noexcept
    {
        return Vec2D(a * b.x, a * b.y);
    }
    friend constexpr Vec2D operator*(Vec2D a, T b) noexcept
    {
        return Vec2D(a.x * b, a.y * b);
    }
    friend constexpr Vec2D operator/(Vec2D a, T b) noexcept
    {
        return Vec2D(a.x / b, a.y / b);
    }
    constexpr Vec2D &operator+=(Vec2D rt) noexcept
    {
        return *this = *this + rt;
    }
    constexpr Vec2D &operator-=(Vec2D rt) noexcept
    {
        return *this = *this - rt;
    }
    constexpr Vec2D &operator*=(T rt) noexcept
    {
        return *this = *this * rt;
    }
    constexpr Vec2D &operator/=(T rt) noexcept
    {
        return *this = *this / rt;
    }
};

constexpr Vec2D<Fixed<>> rotate(Vec2D<Fixed<>> v, Fixed<> rotations) noexcept
{
    rotate(v.x, v.y, rotations);
    return v;
}

constexpr void init_ray_cast_dimension(Fixed<> ray_direction,
                                       Fixed<> ray_start_position,
                                       Fixed<> &next_t,
                                       Fixed<> &step_t,
                                       std::int32_t &delta_position)
{
    if(ray_direction == 0)
        return;
    auto inverse_direction = 1 / ray_direction;
    step_t = abs(inverse_direction);
    std::int32_t target_position{};
    if(ray_direction < 0)
    {
        target_position = ceili(ray_start_position) - 1;
        delta_position = -1;
    }
    else
    {
        target_position = floori(ray_start_position) + 1;
        delta_position = 1;
    }
    next_t = (target_position - ray_start_position) * inverse_direction;
}

struct RayCaster
{
    Vec2D<Fixed<>> ray_start_position;
    Vec2D<Fixed<>> ray_direction;
    Vec2D<std::int32_t> current_position;
    Fixed<> current_t;
    Vec2D<Fixed<>> next_t;
    Vec2D<Fixed<>> step_t;
    Vec2D<std::int32_t> delta_position;
    int last_hit_dimension = -1;
    constexpr RayCaster(Vec2D<Fixed<>> ray_start_position, Vec2D<Fixed<>> ray_direction) noexcept
        : ray_start_position(ray_start_position),
          ray_direction(ray_direction),
          current_position(floori(ray_start_position.x), floori(ray_start_position.y)),
          current_t(Fixed<>::make(1)),
          next_t(0),
          step_t(0),
          delta_position(0)
    {
        init_ray_cast_dimension(
            ray_direction.x, ray_start_position.x, next_t.x, step_t.x, delta_position.x);
        init_ray_cast_dimension(
            ray_direction.y, ray_start_position.y, next_t.y, step_t.y, delta_position.y);
    }
    constexpr void step() noexcept
    {
        if(ray_direction.x != 0 && (ray_direction.y == 0 || next_t.x < next_t.y))
        {
            current_t = next_t.x;
            next_t.x += step_t.x;
            current_position.x += delta_position.x;
            last_hit_dimension = 0;
        }
        else if(ray_direction.y != 0)
        {
            current_t = next_t.y;
            next_t.y += step_t.y;
            current_position.y += delta_position.y;
            last_hit_dimension = 1;
        }
    }
};

struct KeyboardStatus
{
    std::int32_t right_count = 0; // positive for right, negative for left
    std::int32_t up_count = 0; // positive for up, negative for down
    bool reset = false;
    void operator+=(KeyboardStatus rt) noexcept
    {
        right_count += rt.right_count;
        up_count += rt.up_count;
        reset |= rt.reset;
    }
};

template <bool (*HAVECHAR)(), int (*GETCHAR)()>
class KeyboardReader
{
private:
    enum class State
    {
        Initial,
        GotEsc,
        GotLBracket,
    };
    State state = State::Initial;

public:
    KeyboardStatus poll() noexcept
    {
        KeyboardStatus status;
        for(int i = 0; i < 32; i++)
        {
            if(!HAVECHAR())
                break;
            std::uint8_t ch = GETCHAR();
            if(ch == 0x3) // Ctrl+C
            {
                *this = KeyboardReader();
                status = KeyboardStatus();
                status.reset = true;
                break;
            }
            switch(state)
            {
            case State::Initial:
                switch(ch)
                {
                case 0x1B: // Esc
                    state = State::GotEsc;
                    break;
                case 'w':
                case 'W':
                    status.up_count++;
                    break;
                case 'a':
                case 'A':
                    status.right_count--;
                    break;
                case 's':
                case 'S':
                    status.up_count--;
                    break;
                case 'd':
                case 'D':
                    status.right_count++;
                    break;
                }
                break;
            case State::GotEsc:
                switch(ch)
                {
                case 0x1B:
                    break;
                case '[':
                    state = State::GotLBracket;
                    break;
                default:
                    state = State::Initial;
                }
                break;
            case State::GotLBracket:
                state = State::Initial;
                switch(ch)
                {
                case 0x1B:
                    state = State::GotEsc;
                    break;
                case 'D':
                    status.right_count--;
                    break;
                case 'C':
                    status.right_count++;
                    break;
                case 'A':
                    status.up_count++;
                    break;
                case 'B':
                    status.up_count--;
                    break;
                }
                break;
            }
        }
        return status;
    }
};

int main()
{
    usb_console_init();
#ifndef EMULATE_TARGET
    console_init();
#endif
    static std::uint8_t start_col[screen_x_size] = {}, end_col[screen_x_size] = {};
    static char col_color[screen_x_size] = {};
    constexpr std::size_t world_x_size = 16, world_z_size = 16;
    static const char world[world_x_size][world_z_size] = {
        // clang-format off
        {'|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', 'X', 'X'},
        {'|', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', ' ', 'X'},
        {'|', ' ', '|', '|', '|', '|', '|', '|', '|', ' ', ' ', '|', ' ', ' ', ' ', 'X'},
        {'|', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', '|', ' ', '|', 'X', 'X'},
        {'|', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', '|', ' ', '|', '|', '|'},
        {'|', ' ', '|', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', '|', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', '|', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '|', '|', ' ', '|'},
        {'|', ' ', '|', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', '|', '|', '|', '|', '|', '|', '|', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', '|', '|', '|', '|', '|', '|', '|', ' ', ' ', '|', ' ', ' ', ' ', '|'},
        {'|', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '|'},
        {'|', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '|'},
        {'|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'},
        // clang-format on
    };
    constexpr Vec2D<Fixed<>> initial_view_position(1.5, 1.5);
    constexpr Fixed<> initial_view_angle(0);
    constexpr std::uint32_t initial_flash_counter = 0;
    auto view_position = initial_view_position;
    auto view_angle = initial_view_angle;
    auto flash_counter = initial_flash_counter;
    constexpr std::uint32_t flash_period = 10;
    KeyboardReader<usb_havechar, usb_getchar> usb_reader;
#ifndef EMULATE_TARGET
    KeyboardReader<console_havechar, getchar> console_reader;
#endif
    while(true)
    {
        flash_counter++;
        if(flash_counter >= flash_period)
            flash_counter = 0;
        auto status = usb_reader.poll();
#ifndef EMULATE_TARGET
        status += console_reader.poll();
#endif
        if(status.reset)
        {
            view_position = initial_view_position;
            view_angle = initial_view_angle;
            flash_counter = initial_flash_counter;
        }
        while(status.right_count != 0)
        {
            if(status.right_count > 0)
            {
                view_angle -= 0.01;
                view_angle = fracf(view_angle);
                status.right_count--;
            }
            else
            {
                view_angle += 0.01;
                view_angle = fracf(view_angle);
                status.right_count++;
            }
        }
        while(status.up_count != 0)
        {
            Vec2D<Fixed<>> forward(0, 0.2);
            if(status.up_count > 0)
            {
                status.up_count--;
            }
            else
            {
                forward = -forward;
                status.up_count++;
            }
            forward = rotate(forward, view_angle);
            auto new_view_position = view_position + forward;
            Vec2D<std::int32_t> new_block_position(floori(new_view_position.x),
                                                   floori(new_view_position.y));
#if 1
            auto block = world[new_block_position.x][new_block_position.y];
            if(block == ' ')
                view_position = new_view_position;
#else
            Fixed<> closest_distance(100);
            for(int dx = -1; dx <= 1; dx++)
            {
                for(int dy = -1; dy <= 1; dy++)
                {
                    auto block_position = new_block_position;
                    block_position.x += dx;
                    block_position.y += dy;
                    auto block = world[block_position.x][block_position.y];
                    if(block == ' ')
                        continue;
                    auto closest_position = new_view_position;
                    if(closest_position.x < block_position.x)
                        closest_position.x = block_position.x;
                    else if(closest_position.x > block_position.x + 1)
                        closest_position.x = block_position.x + 1;
                    if(closest_position.y < block_position.y)
                        closest_position.y = block_position.y;
                    else if(closest_position.y > block_position.y + 1)
                        closest_position.y = block_position.y + 1;
                    auto current_distance_x = abs(closest_position.x - block_position.x);
                    auto current_distance_y = abs(closest_position.y - block_position.y);
                    auto current_distance = current_distance_x;
                    if(current_distance < current_distance_y)
                        current_distance = current_distance_y;
                    if(current_distance < closest_distance)
                        closest_distance = current_distance;
                }
            }
            if(closest_distance >= 0.1)
                view_position = new_view_position;
#endif
        }
        for(std::size_t x = 0; x < screen_x_size; x++)
        {
            Vec2D<Fixed<>> ray_direction(
                (Fixed<>(x) + (0.5 - screen_x_size / 2.0)) * (2.0 / screen_x_size), 1);
            ray_direction = rotate(ray_direction, view_angle);
            RayCaster ray_caster(view_position, ray_direction);
            auto hit_block = world[ray_caster.current_position.x][ray_caster.current_position.y];
            while(hit_block == ' ')
            {
                ray_caster.step();
                hit_block = world[ray_caster.current_position.x][ray_caster.current_position.y];
            }
            constexpr Fixed<> max_height = 10;
            Fixed<> height =
                ray_caster.current_t != Fixed<>::make(1) ? 1 / ray_caster.current_t : max_height;
            if(height > max_height)
                height = max_height;
            height *= screen_x_size / 2.0;
            auto iheight = roundi(height);
            if(iheight > static_cast<int>(screen_y_size))
                iheight = screen_y_size;
            else if(iheight < 0)
                iheight = 0;
            start_col[x] = screen_y_size / 2 - iheight / 2;
            end_col[x] = screen_y_size / 2 + (iheight + 1) / 2;
            bool odd = (ray_caster.current_position.x + ray_caster.current_position.y) % 2;
            if(hit_block == 'X' && flash_counter >= flash_period / 2)
            {
                col_color[x] = '#';
                if(ray_caster.last_hit_dimension == 0)
                    col_color[x] = 'X';
            }
            else if(ray_caster.last_hit_dimension == 0)
            {
                col_color[x] = odd ? 0xB2 : 0xB1;
            }
            else
            {
                col_color[x] = odd ? 0xB1 : 0xB0;
            }
        }
        my_puts("\x1B[H");
        for(std::size_t y = 0; y < screen_y_size; y++)
        {
            for(std::size_t x = 0,
                            x_end = (y == screen_y_size - 1 ? screen_x_size - 1 : screen_x_size);
                x < x_end;
                x++)
            {
                if(y >= end_col[x])
                    my_putchar(0xCE);
                else if(y >= start_col[x])
                    my_putchar(col_color[x]);
                else
                    my_putchar(0x20);
            }
            my_puts("\r\n");
        }
    }
}