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

752 lines
25 KiB
C++
Raw Blame History

#include <SDL3/SDL.h>
#include <vector>
#include <stdlib.h>
#include "jdebug.h"
#include "util.h"
#include "draw.h"
#include "wad.h"
#include <ctype.h>
#include <stdio.h>
#include <vector>
#include <unordered_map>
#include <stdexcept>
#include <algorithm>
#define FOV 277
std::vector<vec2> verts;
struct wall {
Uint16 v1 {0};
Uint16 v2 {0};
vec2 normal {0.0f, 0.0f};
float u1 {0.0f};
float u2 {0.0f};
int portal {-1};
draw::surface_t *surf {nullptr};
draw::surface_t *upper_surf {nullptr};
draw::surface_t *lower_surf {nullptr};
};
struct sector {
float floor_height {0.0f};
float ceiling_height {64.0f};
draw::surface_t *floor_surf {nullptr};
draw::surface_t *ceil_surf {nullptr};
std::vector<wall> walls;
};
std::vector<sector> sectors;
int current_sector = 38;
int current_sector2 = 38;
vec2 position = { 1056.0f, -3616.0f };
float height = 48.0f;
float real_height = 48.0f;
float orientation = 270.0f;
float accel = 500.0f;
float speed = 0.0f;
float max_speed = 200.0f;
float rspeed = 200.0f;
float bobbing = 0.0f;
float dt;
Uint32 *palette;
//draw::surface_t *gif;
draw::surface_t *spr;
#pragma pack(push, 1)
struct sidedef {
int16_t xoffset;
int16_t yoffset;
char upper_texture[8];
char lower_texture[8];
char middle_texture[8];
int16_t sector;
};
#pragma pack(pop)
// ------------------------------------------------------------
// Área firmada de un contorno
// ------------------------------------------------------------
float signed_area(const std::vector<wall>& contour,
const std::vector<vec2>& verts)
{
float area = 0.0f;
for (size_t i = 0; i < contour.size(); i++) {
int a = contour[i].v1;
int b = contour[i].v2;
const vec2& p = verts[a];
const vec2& q = verts[b];
area += (p.x * q.y - q.x * p.y);
}
return area * 0.5f;
}
// ------------------------------------------------------------
// Extrae todos los contornos (ciclos) del sector
// ------------------------------------------------------------
std::vector<std::vector<wall>>
extract_contours(std::vector<wall> walls)
{
std::vector<std::vector<wall>> contours;
std::unordered_multimap<int,int> startMap;
for (int i = 0; i < (int)walls.size(); i++)
startMap.emplace(walls[i].v1, i);
std::vector<bool> used(walls.size(), false);
for (int i = 0; i < (int)walls.size(); i++) {
if (used[i]) continue;
std::vector<wall> contour;
int current = i;
contour.push_back(walls[current]);
used[current] = true;
int v = walls[current].v2;
while (true) {
auto range = startMap.equal_range(v);
int next = -1;
for (auto it = range.first; it != range.second; ++it) {
int idx = it->second;
if (!used[idx]) {
next = idx;
break;
}
}
if (next == -1)
break; // ciclo cerrado
contour.push_back(walls[next]);
used[next] = true;
v = walls[next].v2;
}
contours.push_back(contour);
}
return contours;
}
// ------------------------------------------------------------
// Ordena y fuerza sentido horario en contorno exterior
// ------------------------------------------------------------
void order_sector_walls_with_holes(sector& sector)
{
if (sector.walls.empty()) return;
// 1. Extraer contornos
auto contours = extract_contours(sector.walls);
// 2. Clasificar contornos por área
struct ContourInfo {
std::vector<wall> walls;
float area;
};
std::vector<ContourInfo> info;
info.reserve(contours.size());
for (auto& c : contours) {
float a = signed_area(c, verts);
info.push_back({c, a});
}
// 3. Encontrar el contorno exterior (el de mayor área absoluta)
int exteriorIndex = 0;
float maxAbsArea = std::abs(info[0].area);
for (int i = 1; i < (int)info.size(); i++) {
float absA = std::abs(info[i].area);
if (absA > maxAbsArea) {
maxAbsArea = absA;
exteriorIndex = i;
}
}
// 4. Forzar sentido horario en el contorno exterior
if (info[exteriorIndex].area < 0.0f) {
std::reverse(info[exteriorIndex].walls.begin(),
info[exteriorIndex].walls.end());
for (auto& w : info[exteriorIndex].walls)
std::swap(w.v1, w.v2);
}
// 5. Mantener agujeros en antihorario (o invertir si tu motor lo exige)
for (int i = 0; i < (int)info.size(); i++) {
if (i == exteriorIndex) continue;
// Si quieres agujeros en horario, descomenta:
/*
if (info[i].area < 0.0f) {
std::reverse(info[i].walls.begin(), info[i].walls.end());
for (auto& w : info[i].walls)
std::swap(w.v1, w.v2);
}
*/
}
// 6. Reconstruir la lista final de paredes
sector.walls.clear();
for (auto& c : info)
for (auto& w : c.walls)
sector.walls.push_back(w);
}
void loadMap(const char* name)
{
int size;
int16_t *vertices = (int16_t *)wad::load(name, "VERTEXES", &size);
const int num_vertices = size/4;
for (int i=0;i<num_vertices;++i)
verts.emplace_back(vec2{float(vertices[i*2]), float(vertices[i*2+1])});
free(vertices);
uint8_t *sectors_lump = wad::load(name, "SECTORS", &size);
const int num_sectors = size/26;
uint8_t *s = sectors_lump;
for (int i=0;i<num_sectors;++i) {
sector sec;
sec.floor_height = int16_t(*s); s+=2;
sec.ceiling_height = int16_t(*s); s+=2;
char txt[9]; txt[8]=0;
for (int i=0;i<8;++i) txt[i] = toupper(*(s++));
sec.floor_surf = wad::loadFlat(txt);
for (int i=0;i<8;++i) txt[i] = toupper(*(s++));
sec.ceil_surf = wad::loadFlat(txt);
s += 6;
sectors.push_back(sec);
}
free(sectors_lump);
uint8_t *sidedefs_lump = wad::load(name, "SIDEDEFS", &size);
int count = size / sizeof(struct sidedef);
struct sidedef* arr = (struct sidedef*)sidedefs_lump;
uint8_t *linedefs_lump = wad::load(name, "LINEDEFS", &size);
uint16_t *l = (uint16_t *)linedefs_lump;
size /= 28;
for (int i=0; i<size; ++i) {
const int16_t v1 = *(l++);
const int16_t v2 = *(l++);
l+=3;
const int16_t ld1 = *(l++);
const int16_t ld2 = *(l++);
const bool portal = (ld1 != -1) && (ld2 != -1);
if (ld1 != -1) {
wall w;
w.v1 = v2; w.v2 = v1;
w.portal = portal ? arr[ld2].sector : -1;
char txt[9]; txt[8]=0;
for (int i=0;i<8;++i) txt[i] = toupper(arr[ld1].middle_texture[i]);
if (txt[0]!='-') w.surf = wad::loadTexture(txt);
for (int i=0;i<8;++i) txt[i] = toupper(arr[ld1].lower_texture[i]);
if (txt[0]!='-') w.lower_surf = wad::loadTexture(txt);
for (int i=0;i<8;++i) txt[i] = toupper(arr[ld1].upper_texture[i]);
if (txt[0]!='-') w.upper_surf = wad::loadTexture(txt);
sectors[arr[ld1].sector].walls.push_back(w);
}
if (ld2 != -1) {
wall w;
w.v1 = v1; w.v2 = v2;
w.portal = portal ? arr[ld1].sector : -1;
char txt[9]; txt[8]=0;
for (int i=0;i<8;++i) txt[i] = toupper(arr[ld2].middle_texture[i]);
if (txt[0]!='-') w.surf = wad::loadTexture(txt);
for (int i=0;i<8;++i) txt[i] = toupper(arr[ld2].lower_texture[i]);
if (txt[0]!='-') w.lower_surf = wad::loadTexture(txt);
for (int i=0;i<8;++i) txt[i] = toupper(arr[ld2].upper_texture[i]);
if (txt[0]!='-') w.upper_surf = wad::loadTexture(txt);
sectors[arr[ld2].sector].walls.push_back(w);
}
}
free(linedefs_lump);
free(sidedefs_lump);
for (auto &s : sectors )
{
order_sector_walls_with_holes(s);
for (auto &w : s.walls )
{
const int width = w.surf ? w.surf->w : w.upper_surf ? w.upper_surf->w : w.lower_surf ? w.lower_surf->w : 64;
SDL_assert(width>=0);
w.u2 = distance(verts[w.v1], verts[w.v2]) / width;
//w.v2 = distance(s.verts[w.v1], s.verts[w.v2]) / 32.0f;
vec2 norm = { verts[w.v2].x - verts[w.v1].x, verts[w.v2].y - verts[w.v1].y};
normalize(&norm);
const float tmp = norm.x; norm.x = -norm.y; norm.y = tmp;
w.normal = norm;
}
}
}
/*
void createMap()
{
current_sector = 0;
{
sector s;
s.floor_height = 32.0f;
s.ceiling_height = 96.0f;
s.floor_surf = wad::loadFlat("FLOOR4_8");
s.ceil_surf = wad::loadFlat("CEIL3_1");
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, 1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({1,2,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({2,3,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({3,4,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({4,5,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({5,6,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({6,7,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({7,0,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
sectors.push_back(s);
}
{
sector s;
s.floor_height = 0.0f;
s.ceiling_height = 128.0f;
s.floor_surf = wad::loadFlat("FLOOR4_8");
s.ceil_surf = wad::loadFlat("CEIL3_1");
s.verts.push_back({256.0f, 0.0f});
s.verts.push_back({ 64.0f, 0.0f});
s.verts.push_back({ 64.0f,-256.0f});
s.verts.push_back({256.0f,-256.0f});
s.verts.push_back({128.0f,-128.0f});
s.verts.push_back({192.0f,-128.0f});
s.verts.push_back({192.0f,-192.0f});
s.verts.push_back({128.0f,-192.0f});
s.walls.push_back({0,1,{0,0},0.0f,0.0f, 0, wad::loadTexture("BROWNPIP")});
s.walls.push_back({1,2,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({2,3,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({3,0,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({4,5,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({5,6,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({6,7,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
s.walls.push_back({7,4,{0,0},0.0f,0.0f,-1, wad::loadTexture("BROWNPIP")});
sectors.push_back(s);
}
for (auto &s : sectors )
{
for (auto &w : s.walls )
{
w.u2 = distance(s.verts[w.v1], s.verts[w.v2]) / w.surf->w;
//w.v2 = distance(s.verts[w.v1], s.verts[w.v2]) / 32.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;
}
}
}
*/
int actual_sector = -1;
int last_sector = -1;
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 stright_dist=100000.0f;
for (auto &wall : s.walls)
{
if (dot(normal, wall.normal) >= 0) continue;
if (get_line_intersection(position, infi, verts[wall.v1], verts[wall.v2], &tmp_result))
{
const float d = distance(position, tmp_result);// * SDL_cosf(a_inc*DEG_TO_RAD);
if (d<stright_dist) {
stright_dist = d;
result = tmp_result;
w = &wall;
}
}
}
if (w)
{
//const int tex_height = gif->h; //64;
const float sector_height = s.ceiling_height - s.floor_height;
const int width = w->surf ? w->surf->w : w->upper_surf ? w->upper_surf->w : w->lower_surf ? w->lower_surf->w : 64;
draw::map::putp(result.x, result.y, 6);
float dist = stright_dist * SDL_cosf(a_inc*DEG_TO_RAD);
const vec2 AB = {verts[w->v2].x-verts[w->v1].x, verts[w->v2].y-verts[w->v1].y};
const vec2 AP = {result.x-verts[w->v1].x, result.y-verts[w->v1].y};
float v = dot(AP,AB) / dot(AB,AB); v *= w->u2; v = v*width; //w->surf->w; //(v-int(v))*gif->w;
float wall_height = (sector_height*FOV)/dist; // [64=altura sector]
float wall_cut = 0.0f;
float dpix = sector_height/wall_height; // [64=crec que altura sector]
float cpix = 0;
float wall_start = 120-(wall_height/sector_height)*(sector_height-(height-s.floor_height)); // [64=els dos crec que altura sector]
if (wall_start<start) {
wall_cut = start-wall_start;
cpix = wall_cut*dpix;
wall_height -= wall_cut;
wall_start=start;
}
// Pinta el sostre
for (int y=start; y<wall_start-1; y++) {
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 = SDL_abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) - position.x)) % s.ceil_surf->w;
int ty = SDL_abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) - position.y)) % s.ceil_surf->h;
draw::putpd(screen_column, y, s.ceil_surf->pixels[tx+ty*s.ceil_surf->w], -straight_dist);
}
if (w->portal == -1)
{
// Pinta la pared
draw::surface_t *surf = w->surf;
if (surf) {
for (int i=0; i<wall_height; ++i) {
if (wall_start+i>=end) break;
draw::putpd(screen_column, wall_start+i, surf->pixels[(int(v)%surf->w)+(int(cpix)%surf->h)*surf->w], 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*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;
draw::putpd(screen_column, wall_start+i, w->surf->pixels[(int(v)%w->surf->w)+(int(cpix)%w->surf->h)*w->surf->w], stright_dist);
cpix += dpix;
}
wall_start += upper_wall_height;
wall_height -= upper_wall_height;
}
}
float lower_height = sectors[w->portal].floor_height - s.floor_height;
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);
//SDL_assert(&s != &sectors[w->portal]);
//printf("Anem al sector: %i\n", w->portal);
//SDL_assert(w->portal != last_sector);
last_sector = actual_sector;
actual_sector = w->portal;
drawColumn(sectors[w->portal], screen_column, wall_start, wall_end, a_inc, infi);
if (lower_wall_height>0.0f)
{
cpix += (wall_height-lower_wall_height)*dpix;
// Pinta la pared
for (int i=0; i<lower_wall_height; ++i) {
if (wall_end+i>=end) break;
draw::putpd(screen_column, wall_end+i, w->surf->pixels[(int(v)%w->surf->w)+(int(cpix)%w->surf->h)*w->surf->w], stright_dist);
cpix += dpix;
}
//wall_start += upper_wall_height;
//wall_height -= upper_wall_height;
}
}
// Pinta el piso
int paint_end = wall_start+wall_height-1;
for (int y=paint_end+1; y<end-1; y++) {
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 = SDL_abs(int(actual_dist * SDL_cosf(angle*DEG_TO_RAD) + position.x)) % s.floor_surf->w;
int ty = SDL_abs(int(actual_dist * SDL_sinf(angle*DEG_TO_RAD) + position.y)) % s.floor_surf->h;
draw::putpd(screen_column, y, s.floor_surf->pixels[tx+ty*s.floor_surf->w], straight_dist);
}
//line(screen_column, 120-(wall_height), screen_column, 120+(wall_height), 5);
}
}
bool tryMove(float angle, float speed)
{
float sign = speed > 0 ? 1.0f : -1.0f;
bool moved = false;
sector &s = sectors[current_sector];
vec2 newpos = { position.x + SDL_cosf(angle*DEG_TO_RAD)*5*sign, position.y };
bool collision=false;
for (auto w : s.walls) {
if (get_line_intersection(position, newpos, verts[w.v1], verts[w.v2], NULL))
{
if (w.portal != -1) {
newpos.x = position.x + SDL_cosf(angle*DEG_TO_RAD)*dt*speed;
if (get_line_intersection(position, newpos, verts[w.v1], verts[w.v2], NULL) )
current_sector = w.portal;
} else {
collision=true;
}
break;
}
}
if (!collision)
{ moved = true; position.x += SDL_cosf(angle*DEG_TO_RAD)*dt*speed; }
newpos = { position.x, position.y + SDL_sinf(angle*DEG_TO_RAD)*5*sign };
collision=false;
for (auto w : s.walls) {
if (get_line_intersection(position, newpos, verts[w.v1], verts[w.v2], NULL))
{
if (w.portal != -1) {
newpos.y = position.y + SDL_sinf(angle*DEG_TO_RAD)*dt*speed;
if (get_line_intersection(position, newpos, verts[w.v1], verts[w.v2], NULL) )
current_sector = w.portal;
} else {
collision=true;
}
break;
}
}
if (!collision)
{ moved = true; position.y += SDL_sinf(angle*DEG_TO_RAD)*dt*speed; }
return moved;
}
int main(int argc, char *argv[])
{
wad::init("doom1.wad");
draw::init();
//gif = draw::loadgif("walls.gif");
//gif = wad::loadFlat("FLOOR4_8");
//gif = wad::loadTexture("BROWNPIP");
//gif = wad::loadPatch("LADDER16");
//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);
//createMap();
loadMap("E1M1");
SDL_Event e;
bool should_exit = false;
Uint32 millis = SDL_GetTicks();
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();
bobbing += dt*1000.0f;
height = real_height + SDL_sinf(bobbing*DEG_TO_RAD)*(speed/100.0f);
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; }
if (e.type==SDL_EVENT_MOUSE_WHEEL) {
if (e.wheel.y>0) current_sector2++; else current_sector2--;
printf("Current sector: %i\n", current_sector2);
}
}
const bool *keys = SDL_GetKeyboardState(NULL);
if (keys[SDL_SCANCODE_Q])
{
real_height += dt*100.0f;
}
if (keys[SDL_SCANCODE_A])
{
real_height -= dt*100.0f;
}
if (keys[SDL_SCANCODE_W])
{
//real_height += dt*100.0f;
sectors[0].ceiling_height -= dt*100.0f;
sectors[1].ceiling_height -= dt*100.0f;
sectors[0].floor_height -= dt*100.0f;
sectors[1].floor_height -= dt*100.0f;
}
if (keys[SDL_SCANCODE_S])
{
//real_height -= dt*100.0f;
sectors[0].ceiling_height += dt*100.0f;
sectors[1].ceiling_height += dt*100.0f;
sectors[0].floor_height += dt*100.0f;
sectors[1].floor_height += dt*100.0f;
}
if (keys[SDL_SCANCODE_RIGHT])
{
orientation += dt*rspeed;
}
else if (keys[SDL_SCANCODE_LEFT])
{
orientation -= dt*rspeed;
}
if (keys[SDL_SCANCODE_UP])
{
if (speed < max_speed) speed += dt*accel;
}
else if (keys[SDL_SCANCODE_DOWN])
{
if (speed > -max_speed) speed -= dt*accel;
}
else
{
if (speed > 0.0f) { speed -= dt*accel; if (speed < 0.0f) speed = 0.0f; }
if (speed < 0.0f) { speed += dt*accel; if (speed > 0.0f) speed = 0.0f; }
}
if (speed != 0.0f) if (!tryMove(orientation, speed)) speed = 0.0f;
draw::cls();
sector &s = sectors[current_sector];
actual_sector = current_sector;
//printf("Current sector: %i\n", current_sector);
// 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;
//printf("Column %i...\n", screen_column);
drawColumn(s, screen_column, 0, 240, a_inc, infi);
screen_column++;
}
debug::print("angle:");debug::print(orientation);debug::newline();
vec2 enemy = {256.0f, 256.0f};
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*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);
int column = int((angle_to_enemy+32.0f)/0.2f);
for (int i=0; i<wall_height;++i)
{
int tx = i * 32 / wall_height;
const int c = column - (wall_height/2)+i;
if (c>=0 && c<320) {
for (int j=0;j<wall_height;++j)
{
int ty = j * 32 / wall_height;
draw::putps(c, wall_start+j, getp(spr,tx,ty), d); //120-(wall_height/2)
}
}
}
//line(column, 0, column, 239, 0);
}
/*
float angle = SDL_atan2f(enemy.y-position.y, enemy.x-position.x)*RAD_TO_DEG;
if (SDL_abs(angle) <= 32.0f)
{
const float d = distance(position, enemy);// * SDL_cosf(a_inc*DEG_TO_RAD);
debug::print("enemy angle:");debug::print(angle);debug::newline();
debug::print("enemy dist:");debug::print(d);debug::newline();
}
*/
// Draw map walls
//draw::cls();
int sec = 0;
for (auto &s : sectors)
{
if (sec==current_sector2)
for (auto &w : s.walls) {
draw::map::line(verts[w.v1].x, verts[w.v1].y, verts[w.v2].x, verts[w.v2].y, sec==current_sector2?20:4, position.x, position.y);
}
sec++;
}
// Draw map hero
vec2 lookat;
lookat.x = SDL_cosf(orientation*DEG_TO_RAD)*20;
lookat.y = SDL_sinf(orientation*DEG_TO_RAD)*20;
draw::map::line(0, 0, lookat.x, lookat.y, 20, 0, 0);
draw::map::putp(0, 0, 20);
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);
}
draw::render();
fps_count++;
if (SDL_GetTicks()-fps_time>=1000)
{
fps = fps_count;
fps_count = 0;
fps_time = SDL_GetTicks();
}
debug::println("fps:", fps);
debug::println("sector:", current_sector);
debug::println("height:", real_height);
debug::println("ceil_height:", sectors[0].ceiling_height);
debug::println("floor_height:", sectors[0].floor_height);
debug::render();
draw::flip();
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink