189 lines
5.0 KiB
C++
189 lines
5.0 KiB
C++
#include "level.h"
|
|
#include <stdio.h>
|
|
|
|
#include "maths.h"
|
|
|
|
#define WIDTH 5
|
|
#define HEIGHT 5
|
|
|
|
static void drawGrid();
|
|
static void drawGridLine(unsigned int step, bool isHorizontal);
|
|
static sf::Vertex getGridLineVertex(unsigned int n, unsigned int maxDimension, bool isStart, bool isHorizontal);
|
|
|
|
static void castRay(sf::Vector2f point, float direction);
|
|
static void getGridIndex(sf::Vector2f point, int* x, int* y);
|
|
|
|
static sf::RenderWindow* window = nullptr;
|
|
|
|
static unsigned int level[WIDTH * HEIGHT] = {
|
|
1, 1, 1, 1, 1,
|
|
1, 0, 0, 0, 0,
|
|
1, 0, 1, 0, 1,
|
|
1, 0, 0, 0, 0,
|
|
1, 0, 1, 0, 1,
|
|
};
|
|
|
|
int level_init(sf::RenderWindow* renderWindow)
|
|
{
|
|
printf("level_init()\n");
|
|
window = renderWindow;
|
|
return 1;
|
|
}
|
|
|
|
int level_update()
|
|
{
|
|
if (!window) return 0;
|
|
drawGrid();
|
|
return 1;
|
|
}
|
|
|
|
void level_end()
|
|
{
|
|
printf("level_end()\n");
|
|
return;
|
|
}
|
|
|
|
float level_rayCastDistance(sf::Vector2f point, float direction)
|
|
{
|
|
castRay(point, direction);
|
|
return 1000.f;
|
|
}
|
|
|
|
static void drawGrid()
|
|
{
|
|
const sf::Vector2u windowSize = window->getSize();
|
|
const unsigned int stepX = windowSize.x/WIDTH;
|
|
const unsigned int stepY = windowSize.y/HEIGHT;
|
|
|
|
for (unsigned int x = 0; x < WIDTH; x++) {
|
|
for (unsigned int y = 0; y < HEIGHT; y++) {
|
|
if (!level[y * HEIGHT + x]) continue;
|
|
|
|
sf::RectangleShape rectangle(sf::Vector2f(stepY, stepY));
|
|
rectangle.setPosition(x * stepX, y * stepY);
|
|
|
|
window->draw(rectangle);
|
|
}
|
|
}
|
|
|
|
drawGridLine(stepX, true);
|
|
drawGridLine(stepY, false);
|
|
}
|
|
|
|
static void drawGridLine(unsigned int step, bool isHorizontal)
|
|
{
|
|
unsigned int lines = isHorizontal? WIDTH : HEIGHT;
|
|
|
|
for (unsigned int n = 0; n < lines; n++) {
|
|
if (n == 0) continue;
|
|
unsigned int offset = n * step;
|
|
unsigned int maxDimension = lines * step;
|
|
sf::Vertex line[] =
|
|
{
|
|
getGridLineVertex(offset, maxDimension, true, isHorizontal),
|
|
getGridLineVertex(offset, maxDimension, false, isHorizontal)
|
|
};
|
|
|
|
window->draw(line, 2, sf::Lines);
|
|
}
|
|
}
|
|
|
|
static sf::Vertex getGridLineVertex(unsigned int offset, unsigned int maxDimension, bool isStart, bool isHorizontal)
|
|
{
|
|
sf::Vertex start;
|
|
sf::Vertex end;
|
|
|
|
if (isHorizontal) {
|
|
start = sf::Vertex(sf::Vector2f(offset, 0));
|
|
end = sf::Vertex(sf::Vector2f(offset, maxDimension));
|
|
}
|
|
else {
|
|
start = sf::Vertex(sf::Vector2f(0, offset));
|
|
end = sf::Vertex(sf::Vector2f(maxDimension, offset));
|
|
}
|
|
|
|
start.color = sf::Color(100, 100, 100);
|
|
end.color = sf::Color(100, 100, 100);
|
|
return isStart? start : end;
|
|
}
|
|
|
|
static void castRay(sf::Vector2f point, float direction)
|
|
{
|
|
const sf::Vector2u windowSize = window->getSize();
|
|
const unsigned int tileWidth = windowSize.x/WIDTH;
|
|
const unsigned int tileHeight = windowSize.y/HEIGHT;
|
|
|
|
// dx and dy are the delta x and delta y of closest grid intersection
|
|
int indexX, indexY;
|
|
float dx, dy;
|
|
|
|
getGridIndex(point, &indexX, &indexY);
|
|
|
|
direction = maths_modulo(direction, 2.0f*PI);
|
|
bool goingDown = direction < PI;
|
|
int signDown = goingDown? 1 : -1;
|
|
|
|
dy = (float)((indexY + goingDown) * tileHeight) - point.y;
|
|
dx = dy/tan(direction);
|
|
|
|
float horizontalStepX = (float)(signDown * (tileWidth/tan(direction)));
|
|
float horizontalStepY = (float)(signDown * (int)tileHeight);
|
|
float horizontalProjectedX = point.x + dx;
|
|
float horizontalProjectedY = (indexY + goingDown) * tileHeight;
|
|
|
|
direction = maths_modulo(direction + 0.5f*PI, 2.0f*PI);
|
|
bool goingRight = direction < PI;
|
|
int signRight = goingRight? 1 : -1;
|
|
|
|
dx = (float)((indexX + goingRight) * tileWidth) - point.x;
|
|
dy = -dx/tan(direction);
|
|
|
|
float verticalStepY = -(float)(signRight * (tileHeight/tan(direction)));
|
|
float verticalStepX = (float)(signRight * (int)tileHeight);
|
|
float verticalProjectedY = point.y + dy;
|
|
float verticalProjectedX = (indexX + goingRight) * tileWidth;
|
|
|
|
bool inLevel;
|
|
do {
|
|
const float circleRadius = 3.f;
|
|
sf::CircleShape circle(circleRadius);
|
|
|
|
circle.setFillColor(sf::Color::Red);
|
|
|
|
circle.setPosition(sf::Vector2f(horizontalProjectedX, horizontalProjectedY));
|
|
circle.setOrigin(circleRadius, circleRadius);
|
|
window->draw(circle);
|
|
|
|
circle.setPosition(sf::Vector2f(verticalProjectedX, verticalProjectedY));
|
|
circle.setOrigin(circleRadius, circleRadius);
|
|
window->draw(circle);
|
|
|
|
horizontalProjectedX += horizontalStepX;
|
|
horizontalProjectedY += horizontalStepY;
|
|
|
|
verticalProjectedX += verticalStepX;
|
|
verticalProjectedY += verticalStepY;
|
|
|
|
int indexX0, indexY0;
|
|
int indexX1, indexY1;
|
|
getGridIndex(sf::Vector2f(horizontalProjectedX, horizontalProjectedY), &indexX0, &indexY0);
|
|
getGridIndex(sf::Vector2f(verticalProjectedX, verticalProjectedY), &indexX1, &indexY1);
|
|
|
|
bool inLevel0 = ((indexX0 >= 0 && indexX0 < WIDTH) && (indexY0 >= 0 && indexY0 < HEIGHT));
|
|
bool inLevel1 = ((indexX1 >= 0 && indexX1 < WIDTH) && (indexY1 >= 0 && indexY1 < HEIGHT));
|
|
|
|
inLevel = inLevel0 || inLevel1;
|
|
} while (inLevel);
|
|
}
|
|
|
|
static void getGridIndex(sf::Vector2f point, int* x, int* y)
|
|
{
|
|
const sf::Vector2u windowSize = window->getSize();
|
|
|
|
*x = point.x / (int)(windowSize.x / WIDTH);
|
|
*y = point.y / (int)(windowSize.y / HEIGHT);
|
|
|
|
if (*x < 0 || WIDTH <= *x) *x = -1;
|
|
if (*y < 0 || HEIGHT <= *y) *y = -1;
|
|
}
|