JailDoctor/wolf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
513f7426bf2c3ad7f835da9e13b8932331f3c153
wolf/main.cpp

393 lines
13 KiB
C++
Raw Blame History

#include <SDL3/SDL.h>
#include "gif.c"
#include <vector>
#include "jdebug.h"
#define M_PI 3.14159265358979323846
#define DEG_TO_RAD M_PI/180.0f
struct vec2 { float x, y; };
struct wall { Uint16 v1, v2; vec2 normal; float u1, u2; };
struct sector {
std::vector<wall> walls;
std::vector<vec2> verts;
};
SDL_Window *sdl_window;
SDL_Renderer *sdl_renderer;
SDL_Texture *sdl_texture;
Uint32 *palette;
Uint8 *gif;
Uint8 screen[320*240];
std::vector<sector> sectors;
int current_sector;
vec2 position = { 128.0f, 192.0f };
float speed = 200.0f;
float height = 32.0f;
float orientation = 90.0f;
// Returns 1 if the lines intersect, otherwise 0. In addition, if the lines
// intersect the intersection point may be stored in the floats i_x and i_y.
const bool get_line_intersection(vec2 p0, vec2 p1, vec2 p2, vec2 p3, vec2 *i)
{
vec2 s1, s2;
s1.x = p1.x - p0.x; s1.y = p1.y - p0.y;
s2.x = p3.x - p2.x; s2.y = p3.y - p2.y;
float s, t;
s = (-s1.y * (p0.x - p2.x) + s1.x * (p0.y - p2.y)) / (-s2.x * s1.y + s1.x * s2.y);
t = ( s2.x * (p0.y - p2.y) - s2.y * (p0.x - p2.x)) / (-s2.x * s1.y + s1.x * s2.y);
if (s >= 0 && s <= 1 && t >= 0 && t <= 1)
{
// Collision detected
if (i != NULL)
{
i->x = p0.x + (t * s1.x);
i->y = p0.y + (t * s1.y);
}
return true;
}
return false; // No collision
}
inline const float distance(vec2 p1, vec2 p2)
{
const float xx = p2.x-p1.x;
const float yy = p2.y-p1.y;
return SDL_sqrtf(xx*xx+yy*yy);
}
inline const void normalize(vec2 *v)
{
const float length = SDL_sqrtf(v->x*v->x + v->y*v->y);
if (length > 0.0f) {
v->x /= length;
v->y /= length;
}
}
inline const float dot(vec2 v1, vec2 v2)
{
return v1.x*v2.x + v1.y*v2.y;
}
void putp(int x, int y, Uint8 color)
{
if (x<0 || y<0 || x>=320 || y>=240) return;
screen[x+y*320]=color;
}
void line(int x1, int y1, int x2, int y2, Uint8 color)
{
float dx = float(x2-x1);
float dy = float(y2-y1);
float steps = SDL_max(SDL_fabsf(dx), SDL_fabsf(dy));
if (steps==0) { putp(x1,y1,color); return; }
float incx = dx / steps;
float incy = dy / steps;
float x = (float)x1;
float y = (float)y1;
for (int i=0; i<=int(steps); ++i)
{
putp(int(x+0.5f),int(y+0.5f),color);
x += incx;
y += incy;
}
}
void createMap()
{
current_sector = 0;
sector s;
s.verts.push_back({ 64.0f, 0.0f});
s.verts.push_back({256.0f, 0.0f});
s.verts.push_back({256.0f, 64.0f});
s.verts.push_back({320.0f, 64.0f});
s.verts.push_back({320.0f, 320.0f});
s.verts.push_back({ 0.0f, 320.0f});
s.verts.push_back({ 0.0f, 64.0f});
s.verts.push_back({ 64.0f, 64.0f});
s.walls.push_back({0,1,{0,0},0.0f,0.0f});
s.walls.push_back({1,2,{0,0},0.0f,0.0f});
s.walls.push_back({2,3,{0,0},0.0f,0.0f});
s.walls.push_back({3,4,{0,0},0.0f,0.0f});
s.walls.push_back({4,5,{0,0},0.0f,0.0f});
s.walls.push_back({5,6,{0,0},0.0f,0.0f});
s.walls.push_back({6,7,{0,0},0.0f,0.0f});
s.walls.push_back({7,0,{0,0},0.0f,0.0f});
for (auto &w : s.walls )
{
w.u2 = distance(s.verts[w.v1], s.verts[w.v2]) / 64.0f;
vec2 norm = { s.verts[w.v2].x - s.verts[w.v1].x, s.verts[w.v2].y - s.verts[w.v1].y};
normalize(&norm);
const float tmp = norm.x; norm.x = -norm.y; norm.y = tmp;
w.normal = norm;
}
sectors.push_back(s);
}
void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, vec2 infi)
{
const float angle = orientation + a_inc;
vec2 normal = { SDL_cosf(angle*DEG_TO_RAD), SDL_sinf(angle*DEG_TO_RAD) };
vec2 result, tmp_result;
wall *w = nullptr;
float dist=100000.0f;
for (auto &wall : s.walls)
{
if (dot(normal, wall.normal) >= 0) continue;
if (get_line_intersection(position, infi, s.verts[wall.v1], s.verts[wall.v2], &tmp_result))
{
const float d = distance(position, tmp_result);// * SDL_cosf(a_inc*DEG_TO_RAD);
if (d<dist) {
dist = d;
result = tmp_result;
w = &wall;
}
}
}
if (w) {
putp(int(result.x/8),int(result.y/8),6);
dist *= SDL_cosf(a_inc*DEG_TO_RAD);
const vec2 AB = {s.verts[w->v2].x-s.verts[w->v1].x, s.verts[w->v2].y-s.verts[w->v1].y};
const vec2 AP = {result.x-s.verts[w->v1].x, result.y-s.verts[w->v1].y};
float v = dot(AP,AB) / dot(AB,AB); v *= w->u2; v = (v-int(v))*64.0f;
//const float v = distance(s.verts[w.v1], result);
float wall_height = (64*277)/dist;
float dpix = 64/wall_height;
float cpix = 0;
float wall_start = 120-(wall_height/64)*(64-height);
if (wall_start<start) {
cpix = (start-wall_start)*dpix;
wall_height -= (start-wall_start);
wall_start=start;
}
// Pinta el sostre
for (int y=start; y<wall_start-1; y++) {
float straight_dist = (277 * (64-height)) / (y - (240 >> 1));
float actual_dist = straight_dist / SDL_cosf(a_inc*DEG_TO_RAD);
int tx = abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) - position.x)) % 64;
int ty = abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) - position.y)) % 64;
putp(screen_column, y, gif[tx+ty*64]);
}
// Pinta la pared
for (int i=0; i<wall_height; ++i) {
if (wall_start+i>=end) break;
putp(screen_column, wall_start+i, gif[(int(v)%64)+int(cpix)*64]);
cpix += dpix;
}
// Pinta el piso
int paint_end = wall_start+wall_height-1;
for (int y=paint_end+1; y<end-1; y++) {
float straight_dist = (277 * height) / (y - (240 >> 1));
float actual_dist = straight_dist / SDL_cosf(a_inc*DEG_TO_RAD);
int tx = abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) + position.x)) % 64;
int ty = abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) + position.y)) % 64;
putp(screen_column, y, gif[tx+ty*64]);
}
//line(screen_column, 120-(wall_height), screen_column, 120+(wall_height), 5);
}
}
int main(int argc, char *argv[])
{
SDL_Init(SDL_INIT_VIDEO);
sdl_window = SDL_CreateWindow("WOLF", 640, 480, 0);
SDL_SetWindowPosition(sdl_window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
sdl_renderer = SDL_CreateRenderer(sdl_window, NULL);
sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 320, 240);
debug::init(sdl_renderer);
FILE *f = fopen("walls.gif", "rb");
fseek(f, 0, SEEK_END);
int filesize = ftell(f);
fseek(f, 0, SEEK_SET);
Uint8 *buffer = (Uint8*)malloc(filesize);
fread(buffer, filesize, 1, f);
fclose(f);
Uint16 w, h;
gif = LoadGif(buffer, &w, &h);
palette = LoadPalette(buffer);
free(buffer);
createMap();
SDL_Event e;
bool should_exit = false;
Uint32 millis = SDL_GetTicks();
float dt;
int fps = 0;
int fps_count = 0;
int fps_time = SDL_GetTicks();
while (!should_exit)
{
dt = float(SDL_GetTicks() - millis)/1000.0f;
millis = SDL_GetTicks();
while (SDL_PollEvent(&e))
{
if (e.type==SDL_EVENT_QUIT) { should_exit=true; break; }
if (e.type==SDL_EVENT_KEY_DOWN && e.key.scancode==SDL_SCANCODE_ESCAPE) { should_exit=true; break; }
}
sector &s = sectors[current_sector];
const bool *keys = SDL_GetKeyboardState(NULL);
if (keys[SDL_SCANCODE_Q]) height += dt*speed;
if (keys[SDL_SCANCODE_A]) height -= dt*speed;
if (keys[SDL_SCANCODE_RIGHT]) orientation += dt*speed;
if (keys[SDL_SCANCODE_LEFT]) orientation -= dt*speed;
if (keys[SDL_SCANCODE_UP])
{
vec2 newpos = { position.x + SDL_cosf(orientation*DEG_TO_RAD)*5, position.y };
bool collision=false;
for (auto w : s.walls) if (get_line_intersection(position, newpos, s.verts[w.v1], s.verts[w.v2], NULL)) { collision=true; break; }
if (!collision) position.x += SDL_cosf(orientation*DEG_TO_RAD)*dt*speed;
newpos = { position.x, position.y + SDL_sinf(orientation*DEG_TO_RAD)*5 };
collision=false;
for (auto w : s.walls) if (get_line_intersection(position, newpos, s.verts[w.v1], s.verts[w.v2], NULL)) { collision=true; break; }
if (!collision) position.y += SDL_sinf(orientation*DEG_TO_RAD)*dt*speed;
}
if (keys[SDL_SCANCODE_DOWN])
{
position.x -= SDL_cosf(orientation*DEG_TO_RAD)*dt*speed;
position.y -= SDL_sinf(orientation*DEG_TO_RAD)*dt*speed;
}
// Clear screen
SDL_memset4(screen, 0x00000000, (320*240)>>2);
int screen_column = 0;
for (float a_inc=-32.0f; a_inc<=32.0f; a_inc+=0.2f)
{
const float angle = orientation + a_inc;
vec2 infi;
infi.x = position.x + SDL_cosf(angle*DEG_TO_RAD)*40000;
infi.y = position.y + SDL_sinf(angle*DEG_TO_RAD)*40000;
drawColumn(s, screen_column, 10, 220, a_inc, infi);
/*
vec2 result, tmp_result;
wall *w = nullptr;
float dist=100000.0f;
for (auto &wall : s.walls)
{
if (get_line_intersection(position, infi, s.verts[wall.v1], s.verts[wall.v2], &tmp_result))
{
const float d = distance(position, tmp_result);// * SDL_cosf(a_inc*DEG_TO_RAD);
if (d<dist) {
dist = d;
result = tmp_result;
w = &wall;
}
}
}
if (w) {
putp(int(result.x/8),int(result.y/8),6);
dist *= SDL_cosf(a_inc*DEG_TO_RAD);
const vec2 AB = {s.verts[w->v2].x-s.verts[w->v1].x, s.verts[w->v2].y-s.verts[w->v1].y};
const vec2 AP = {result.x-s.verts[w->v1].x, result.y-s.verts[w->v1].y};
float v = dot(AP,AB) / dot(AB,AB); v *= w->u2; v = (v-int(v))*64.0f;
//const float v = distance(s.verts[w.v1], result);
float wall_height = (64*277)/dist;
float dpix = 64/wall_height;
float cpix = 0;
float wall_start = 120-(wall_height/64)*(64-height);
if (wall_start<0) {
cpix = -wall_start*dpix;
wall_height += wall_start;
wall_start=0;
}
// Pinta el sostre
for (int y=0; y<wall_start-1; y++) {
float straight_dist = (277 * (64-height)) / (y - (240 >> 1));
float actual_dist = straight_dist / SDL_cosf(a_inc*DEG_TO_RAD);
int tx = abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) - position.x)) % 64;
int ty = abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) - position.y)) % 64;
putp(screen_column, y, gif[tx+ty*64]);
}
// Pinta la pared
for (int i=0; i<wall_height; ++i) {
if (i>=240) break;
putp(screen_column, wall_start+i, gif[(int(v)%64)+int(cpix)*64]);
cpix += dpix;
}
// Pinta el piso
int paint_end = wall_start+wall_height-1;
for (int y=paint_end+1; y<240-1; y++) {
float straight_dist = (277 * height) / (y - (240 >> 1));
float actual_dist = straight_dist / SDL_cosf(a_inc*DEG_TO_RAD);
int tx = abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) + position.x)) % 64;
int ty = abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) + position.y)) % 64;
putp(screen_column, y, gif[tx+ty*64]);
}
//line(screen_column, 120-(wall_height), screen_column, 120+(wall_height), 5);
}
*/
screen_column++;
}
// Draw map walls
for (auto &w : s.walls) {
line(s.verts[w.v1].x/8, s.verts[w.v1].y/8, s.verts[w.v2].x/8, s.verts[w.v2].y/8, 4);
}
// Draw map hero
vec2 lookat;
lookat.x = position.x + SDL_cosf(orientation*DEG_TO_RAD)*4;
lookat.y = position.y + SDL_sinf(orientation*DEG_TO_RAD)*4;
line(position.x/8, position.y/8, lookat.x/8, lookat.y/8, 1);
putp(int(position.x/8),int(position.y/8),7);
// Send to texture and render
Uint32 *pixels;
int pitch;
SDL_LockTexture(sdl_texture, NULL, (void**)&pixels, &pitch);
for (int i=0; i<(320*240); ++i)
{
pixels[i] = 0xFF000000 | palette[screen[i]];
}
SDL_UnlockTexture(sdl_texture);
SDL_RenderTexture(sdl_renderer, sdl_texture, NULL, NULL);
fps_count++;
if (SDL_GetTicks()-fps_time>=1000)
{
fps = fps_count;
fps_count = 0;
fps_time = SDL_GetTicks();
}
debug::println("fps:", fps);
debug::render(sdl_renderer);
SDL_RenderPresent(sdl_renderer);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink