JailDoctor/wolf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Reestructuració masiva del codi

Browse Source 
- afegit el WAD del Doom 1
- Ja llegim FLATS i TEXTURES del WAD, falten els PATCH
This commit is contained in:
Raimon Zamora
2026-02-26 17:15:52 +01:00
parent 7102535deb
commit 8dbcd4fcb7
13 changed files with 525 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
main.cpp
View File

@@ -1,14 +1,20 @@
#include <SDL3/SDL.h>
#include "gif.c"
#include <vector>
#include <stdlib.h>
#include "jdebug.h"
#include "util.h"
#include "draw.h"
#include "wad.h"
#define M_PI 3.14159265358979323846
#define DEG_TO_RAD (M_PI/180.0f)
#define RAD_TO_DEG (180.0f/M_PI)
#define FOV 190
struct wall {
Uint16 v1, v2;
vec2 normal;
float u1, u2;
int portal;
};
struct vec2 { float x, y; };
struct wall { Uint16 v1, v2; vec2 normal; float u1, u2; int portal; };
struct sector {
float floor_height;
float ceiling_height;
@@ -16,15 +22,6 @@ struct sector {
std::vector<vec2> verts;
};
SDL_Window *sdl_window;
SDL_Renderer *sdl_renderer;
SDL_Texture *sdl_texture;
Uint32 *palette;
Uint8 *gif;
Uint8 *spr;
Uint8 screen[320*240];
float depth_buffer[320*240];
std::vector<sector> sectors;
int current_sector;
@@ -43,113 +40,9 @@ float bobbing = 0.0f;
float dt;
// 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 putpd(int x, int y, Uint8 color, float depth)
{
if (x<0 || y<0 || x>=320 || y>=240) return;
screen[x+y*320]=color;
depth_buffer[x+y*320]=depth;
}
void putps(int x, int y, Uint8 color, float depth)
{
if (x<0 || y<0 || x>=320 || y>=240 || color==0) return;
if (depth_buffer[x+y*320]>=depth)
{
screen[x+y*320]=color;
depth_buffer[x+y*320]=depth;
}
}
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;
}
}
namespace map
{
void putp(int x, int y, Uint8 color)
{
::putp(160+(x/8), 120+(y/8), color);
}
void line(int x1, int y1, int x2, int y2, Uint8 color)
{
::line(160+(x1/8), 120+(y1/8), 160+(x2/8), 120+(y2/8), color);
}
}
Uint32 *palette;
draw::surface_t *gif;
draw::surface_t *spr;
void createMap()
{
@@ -245,13 +138,13 @@ void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, v
const int tex_height = 64;
const float sector_height = s.ceiling_height - s.floor_height;
map::putp(result.x, result.y, 6);
draw::map::putp(result.x, result.y, 6);
float dist = stright_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))*tex_height;
float wall_height = (sector_height*277)/dist; // [64=altura sector]
float wall_height = (sector_height*FOV)/dist; // [64=altura sector]
float wall_cut = 0.0f;
float dpix = tex_height/wall_height; // [64=crec que altura sector]
float cpix = 0;
@@ -265,11 +158,11 @@ void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, v
// Pinta el sostre
for (int y=start; y<wall_start-1; y++) {
float straight_dist = (277 * (sector_height-(height-s.floor_height))) / (y - (240 >> 1));
float straight_dist = (FOV * (sector_height-(height-s.floor_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)) % tex_height;
int ty = abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) - position.y)) % tex_height;
putpd(screen_column, y, gif[tx+ty*tex_height], -straight_dist);
int tx = SDL_abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) - position.x)) % tex_height;
int ty = SDL_abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) - position.y)) % tex_height;
draw::putpd(screen_column, y, gif->pixels[tx+ty*tex_height], -straight_dist);
}
@@ -278,21 +171,21 @@ void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, v
// Pinta la pared
for (int i=0; i<wall_height; ++i) {
if (wall_start+i>=end) break;
putpd(screen_column, wall_start+i, gif[(int(v)%tex_height)+int(cpix)*tex_height], stright_dist);
draw::putpd(screen_column, wall_start+i, gif->pixels[(int(v)%tex_height)+int(cpix)*tex_height], stright_dist);
cpix += dpix;
}
} else {
if (sectors[w->portal].ceiling_height < s.ceiling_height)
{
float upper_height = s.ceiling_height - sectors[w->portal].ceiling_height;
float upper_wall_height = (upper_height*277)/dist;
float upper_wall_height = (upper_height*FOV)/dist;
upper_wall_height -= wall_cut;
if (upper_wall_height>0.0f)
{
// Pinta la pared
for (int i=0; i<upper_wall_height; ++i) {
if (wall_start+i>=end) break;
putpd(screen_column, wall_start+i, gif[(int(v)%tex_height)+int(cpix)*tex_height], stright_dist);
draw::putpd(screen_column, wall_start+i, gif->pixels[(int(v)%tex_height)+int(cpix)*tex_height], stright_dist);
cpix += dpix;
}
wall_start += upper_wall_height;
@@ -300,7 +193,7 @@ void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, v
}
}
float lower_height = sectors[w->portal].floor_height - s.floor_height;
float lower_wall_height = (lower_height*277)/dist;
float lower_wall_height = (lower_height*FOV)/dist;
int wall_end = wall_start+wall_height+1;
if (lower_wall_height>0.0f) wall_end -= lower_wall_height;
wall_end = SDL_min(wall_end, end);
@@ -313,7 +206,7 @@ void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, v
// Pinta la pared
for (int i=0; i<lower_wall_height; ++i) {
if (wall_end+i>=end) break;
putpd(screen_column, wall_end+i, gif[(int(v)%tex_height)+int(cpix)*tex_height], stright_dist);
draw::putpd(screen_column, wall_end+i, gif->pixels[(int(v)%tex_height)+int(cpix)*tex_height], stright_dist);
cpix += dpix;
}
//wall_start += upper_wall_height;
@@ -325,11 +218,11 @@ void drawColumn(sector &s, int screen_column, int start, int end, float a_inc, v
// 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-s.floor_height)) / (y - (240 >> 1));
float straight_dist = (FOV * (height-s.floor_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)) % tex_height;
int ty = abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) + position.y)) % tex_height;
putpd(screen_column, y, gif[tx+ty*tex_height], straight_dist);
int tx = SDL_abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) + position.x)) % tex_height;
int ty = SDL_abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) + position.y)) % tex_height;
draw::putpd(screen_column, y, gif->pixels[tx+ty*tex_height], straight_dist);
}
//line(screen_column, 120-(wall_height), screen_column, 120+(wall_height), 5);
}
@@ -380,65 +273,17 @@ bool tryMove(float angle, float speed)
return moved;
}
float is_enemy_in_fov(double Ax, double Ay, double orientation_deg,
double Bx, double By) {
// Convert orientation angle to radians
double orientation_rad = orientation_deg * DEG_TO_RAD;
// Compute view direction vector from angle
double view_dx = SDL_cosf(orientation_rad);
double view_dy = SDL_sinf(orientation_rad);
// Vector from A to B
double to_enemy_dx = Bx - Ax;
double to_enemy_dy = By - Ay;
// Normalize both vectors
double len = SDL_sqrtf(to_enemy_dx * to_enemy_dx + to_enemy_dy * to_enemy_dy);
if (len == 0) return 0.0; // Same position
to_enemy_dx /= len;
to_enemy_dy /= len;
// Compute signed angle using atan2 of perp-dot and dot
double dot = view_dx * to_enemy_dx + view_dy * to_enemy_dy;
double cross = view_dx * to_enemy_dy - view_dy * to_enemy_dx;
float angle_rad = SDL_atan2f(cross, dot);
return angle_rad * RAD_TO_DEG; // Signed angle in degrees
}
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);
wad::init("doom1.wad");
debug::init(sdl_renderer);
draw::init();
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);
f = fopen("player1.gif", "rb");
fseek(f, 0, SEEK_END);
filesize = ftell(f);
fseek(f, 0, SEEK_SET);
buffer = (Uint8*)malloc(filesize);
fread(buffer, filesize, 1, f);
fclose(f);
spr = LoadGif(buffer, &w, &h);
free(buffer);
gif = wad::loadFlat("FLOOR4_8"); //draw::loadgif("walls.gif");
//palette = draw::loadpal("walls.gif");
palette = wad::loadPalette(0);
draw::setpal(palette);
spr = draw::loadgif("player1.gif");
// [DEBUG] Paleta per al depth buffer
//for(int i=0;i<256;++i) palette[i] = (255-i) | ((255-i)<<8) | ((255-i)<<16);
@@ -538,14 +383,14 @@ int main(int argc, char *argv[])
debug::print("angle:");debug::print(orientation);debug::newline();
vec2 enemy = {256.0f, 256.0f};
map::putp(enemy.x, enemy.y, 9);
draw::map::putp(enemy.x, enemy.y, 9);
float angle_to_enemy = is_enemy_in_fov(position.x, position.y, orientation, enemy.x, enemy.y);
if (SDL_fabsf(angle_to_enemy) <= 64.0f)
{
const float d = distance(position, enemy);// * SDL_cosf(a_inc*DEG_TO_RAD);
float dist = d * SDL_cosf(angle_to_enemy*DEG_TO_RAD);
float wall_height = (32.0f*277)/dist;
float wall_height = (32.0f*FOV)/dist;
float wall_start = 120-(wall_height/32.0f)*(32.0f-(height-sectors[0].floor_height));
debug::println("enemy height: ", wall_height);
debug::println("enemy start: ", wall_start);
@@ -558,7 +403,7 @@ int main(int argc, char *argv[])
for (int j=0;j<wall_height;++j)
{
int ty = j * 32 / wall_height;
putps(c, wall_start+j, spr[tx+ty*32], d); //120-(wall_height/2)
draw::putps(c, wall_start+j, getp(spr,tx,ty), d); //120-(wall_height/2)
}
}
}
@@ -579,7 +424,7 @@ int main(int argc, char *argv[])
for (auto &s : sectors)
{
for (auto &w : s.walls) {
map::line(s.verts[w.v1].x, s.verts[w.v1].y, s.verts[w.v2].x, s.verts[w.v2].y, sec==current_sector?3:4);
draw::map::line(s.verts[w.v1].x, s.verts[w.v1].y, s.verts[w.v2].x, s.verts[w.v2].y, sec==current_sector?3:4);
}
sec++;
}
@@ -588,22 +433,16 @@ int main(int argc, char *argv[])
vec2 lookat;
lookat.x = position.x + SDL_cosf(orientation*DEG_TO_RAD)*20;
lookat.y = position.y + SDL_sinf(orientation*DEG_TO_RAD)*20;
map::line(position.x, position.y, lookat.x, lookat.y, 3);
map::putp(position.x, position.y, 7);
draw::map::line(position.x, position.y, lookat.x, lookat.y, 3);
draw::map::putp(position.x, position.y, 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]];
// [DEBUG] Visualització del depth buffer
//pixels[i] = 0xFF000000 | palette[SDL_min(int(depth_buffer[i]),255)];
for (int i=0;i<256;++i) {
draw::putp((i&0xf)*2, (i>>4)*2, i);
draw::putp((i&0xf)*2+1, (i>>4)*2, i);
draw::putp((i&0xf)*2+1, (i>>4)*2+1, i);
draw::putp((i&0xf)*2, (i>>4)*2+1, i);
}
SDL_UnlockTexture(sdl_texture);
SDL_RenderTexture(sdl_renderer, sdl_texture, NULL, NULL);
draw::render();
fps_count++;
if (SDL_GetTicks()-fps_time>=1000)
@@ -617,9 +456,9 @@ int main(int argc, char *argv[])
debug::println("height:", real_height);
debug::println("ceil_height:", sectors[0].ceiling_height);
debug::println("floor_height:", sectors[0].floor_height);
debug::render(sdl_renderer);
debug::render();
SDL_RenderPresent(sdl_renderer);
draw::flip();
}
return 0;