raycasting

#include <SFML/Graphics.hpp>
#include <vector>
#include <cmath>

#define PI 3.14159265

int calc_size(sf::Vector2f a1, float size, std::vector<sf::RectangleShape>& walls, float angle) {

    sf::Vector2f a2;
    a2.x = sin(PI * (angle - 180) / 180) * size + a1.x;
    a2.y = cos(PI * angle / 180) * size + a1.y;

    float min = size;

    for (int i = 0; i < walls.size(); ++i) {
        sf::Vector2f c;

        sf::Vector2f b1;
        b1.x = walls[i].getPosition().x;
        b1.y = walls[i].getPosition().y;

        sf::Vector2f b2;
        b2.x = sin(PI * (walls[i].getRotation() - 180) / 180) * walls[i].getSize().y + b1.x;
        b2.y = cos(PI * walls[i].getRotation() / 180) * walls[i].getSize().y + b1.y;

        float del = (a1.x - a2.x) * (b1.y - b2.y) - (a1.y - a2.y) * (b1.x - b2.x);

        if (del != 0) {
            float t = ((a1.x - b1.x) * (b1.y - b2.y) - (a1.y - b1.y) * (b1.x - b2.x)) / del;
            float u = ((a1.x - b1.x) * (a1.y - a2.y) - (a1.y - b1.y) * (a1.x - a2.x)) / del;

            if (0 < u && 0 < t && u < 1 && t < 1) {
                c.x = a1.x + t * (a2.x - a1.x);
                c.y = a1.y + t * (a2.y - a1.y);
                size = sqrt((c.x - a1.x) * (c.x - a1.x) + (c.y - a1.y) * (c.y - a1.y));
                if (size < min)
                    min = size;
            }
        }
    }


    return min;
}

void draw_walls(std::vector<sf::RectangleShape>& walls) {
    sf::RectangleShape wall1(sf::Vector2f(1, 250));
    wall1.setPosition(sf::Vector2f(200, 70));
    wall1.setRotation(45);

    sf::RectangleShape wall2(sf::Vector2f(1, 300));
    wall2.setPosition(sf::Vector2f(50, 400));
    wall2.setRotation(-60);

    sf::RectangleShape wall3(sf::Vector2f(1, 400));
    wall3.setPosition(sf::Vector2f(600, 250));
    wall3.setRotation(70);

    walls.push_back(wall1);
    walls.push_back(wall2);
    walls.push_back(wall3);
}

int WinMain()
{
    sf::ContextSettings settings;
    settings.antialiasingLevel = 8;
    sf::RenderWindow window(sf::VideoMode(600, 600), "", sf::Style::Default, settings);
    window.setFramerateLimit(60);

    sf::Event event;
    window.setMouseCursorGrabbed(true);
    window.setMouseCursorVisible(false);

    std::vector<sf::RectangleShape> walls;
    draw_walls(walls);

    std::vector <sf::RectangleShape> rays(180);
    int temp = 360 / rays.size();
    for (int i = 0; i < 360; i += temp) {
        rays[i / temp].setSize(sf::Vector2f(1, 3000));
        rays[i / temp].setRotation(i);
    }

    while (window.isOpen()) {
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();


            sf::Vector2i temp_mouse = sf::Mouse::getPosition(window);

            for (int i = 0; i < rays.size(); ++i) {
                rays[i].setPosition(sf::Vector2f(temp_mouse.x, temp_mouse.y));
                float new_size = calc_size(rays[i].getPosition(), 3000, walls, rays[i].getRotation());
                rays[i].setSize(sf::Vector2f(1, new_size));
            }
        }
        window.clear();

        for(int i = 0; i < walls.size();++i)
            window.draw(walls[i]);

        for (int i = 0; i < rays.size(); ++i)
            window.draw(rays[i]);

        window.display();
    }
    return 0;
}