home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / RAYCAST.ZIP / FILEDOOM.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-19  |  9.0 KB  |  345 lines
  1. #include "ray.h"
  2. #include "globals.h"
  3. #include "rayfile.h"
  4. #include "doom.h"
  5. #include "fixed.h"
  6. #include "blockbsp.h"
  7. #include "blockmap.h"
  8. #include <stdlib.h>
  9.  
  10. inline ptexture Get_Rand_Texture()
  11. {
  12. short tex_result=1;
  13. #ifdef RAND_TEX
  14. short intermediate=rand();
  15. tex_result+=((intermediate*(Number_Of_Textures-1))/32767);
  16. if (tex_result>=Number_Of_Textures)
  17.   tex_result=Number_Of_Textures-1;
  18. #endif
  19. return (ptexture)(tex_result);
  20. }
  21.  
  22. void F_Doom_Load(char * filename)
  23. {
  24. F_D_Setup(filename);
  25. base_index=0;
  26. F_D_Load_World();
  27. F_Close();
  28. }
  29.  
  30. void F_D_Setup(char * filename)
  31. {
  32. binary_mode=TRUE;
  33. fp.open(filename, ios::binary | ios::in | ios::out);
  34. F_Seek(0);
  35. fp.read(header.header, 4);
  36. F_Get_Long(header.dir_entries);
  37. F_Get_Long(header.dir_location);
  38. F_Seek(header.dir_location);
  39. directory=(dir_entry *)NewPtr(header.dir_entries * sizeof(dir_entry));
  40. short counter;
  41. dir_entry * cur_dir;
  42. for (counter=0; counter < header.dir_entries; counter++) {
  43.    cur_dir=directory+counter;
  44.    F_Get_Long(cur_dir->start);
  45.    F_Get_Long(cur_dir->length);
  46.    F_Get_String(cur_dir->name, 8);
  47. } /* endfor */
  48. }
  49.  
  50. void F_D_Load_World()
  51. {
  52. if (world_loaded)
  53.    F_Clear_World();
  54. world_loaded=TRUE;
  55. F_D_Get_Sectors();
  56. F_D_Get_Vectors();
  57. F_D_Get_SDs();
  58. F_D_Get_LDs();
  59. F_D_Get_Segs();
  60. F_D_Get_SSectors();
  61. F_D_Get_BSP();
  62. F_D_Get_Player_Loc();
  63. }
  64.  
  65. short F_D_Find_And_Setup(char * string, void * * table)
  66. {
  67.    short temp_index;
  68.    if ((temp_index=F_Find_Dir(string))==-1)
  69.       return temp_index;
  70.    (*table)=(void *)NewPtr(directory[temp_index].length);
  71.    F_Seek(directory[temp_index].start);
  72.    fp.read((char*)(*table), directory[temp_index].length);
  73.    return temp_index;
  74. }
  75.  
  76. void F_D_Get_Sectors()
  77. {
  78. dm_sector * temp_sectors;
  79. short dir_index=F_D_Find_And_Setup("SECTORS\0", (void * *)&temp_sectors);
  80. if (dir_index==-1)
  81.    return;
  82.  
  83. Number_Of_Sectors=(directory[dir_index].length/sizeof(dm_sector));
  84. Sector_List=(sector *)NewPtr(Number_Of_Sectors * sizeof(sector));
  85.  
  86. short counter;
  87. sector * cur_sec;
  88. dm_sector * cur_dm_sec;
  89.  
  90. for (counter=0; counter<Number_Of_Sectors; counter++) {
  91.    cur_sec=Sector_List+counter;
  92.    cur_dm_sec=temp_sectors+counter;
  93.    cur_sec->floor_height=cur_dm_sec->floor_ht;
  94.    cur_sec->ceil_height=cur_dm_sec->ceiling_ht;
  95.    cur_sec->tag=(USHORT)cur_dm_sec->trigger;
  96.    cur_sec->light=((UCHAR) cur_dm_sec->light >> 4) + 
  97.         ((UCHAR) cur_dm_sec->light & 0xf0);
  98.    cur_sec->floor_tex=0;
  99.    cur_sec->ceil_tex=0;
  100.    cur_sec->flags=0;
  101. }
  102.  
  103. DelPtr(temp_sectors);
  104. }
  105.  
  106. void F_D_Get_Vectors()
  107. {
  108. dm_vertex * temp_vectors;
  109. short dir_index=F_D_Find_And_Setup("VERTEXES",(void * *)&temp_vectors);
  110. if (dir_index==-1)
  111.    return;
  112.  
  113. Number_Of_Vectors=(directory[dir_index].length / sizeof(dm_vertex));
  114. Vector_List=(vector2 *)NewPtr(Number_Of_Vectors * sizeof(vector2));
  115.  
  116. short counter;
  117. vector2 * cur_vec;
  118. dm_vertex * cur_dm_vec;
  119. for (counter=0; counter < Number_Of_Vectors; counter++) {
  120.    cur_vec=Vector_List+counter;
  121.    cur_dm_vec=temp_vectors+counter;
  122.    cur_vec->x=(long)cur_dm_vec->x;
  123.    cur_vec->y=(long)cur_dm_vec->y;
  124. }
  125.  
  126. DelPtr(temp_vectors);
  127. }
  128.  
  129. void F_D_Get_SDs()
  130. {
  131. srand(rand());
  132.  
  133. dm_side * temp_sidedefs;
  134. short dir_index=F_D_Find_And_Setup("SIDEDEFS",(void * *)&temp_sidedefs);
  135. if (dir_index==-1)
  136.    return;
  137.  
  138. Number_Of_Sidedefs=(directory[dir_index].length / sizeof(dm_side));
  139. Sd_List=(sidedef *)NewPtr(Number_Of_Sidedefs * sizeof(sidedef));
  140.  
  141. short counter;
  142. sidedef * cur_sd;
  143. dm_side * cur_dm_sd;
  144. for (counter=0; counter < Number_Of_Sidedefs; counter++) {
  145.    cur_sd=Sd_List+counter;
  146.    cur_dm_sd=temp_sidedefs+counter;
  147.    cur_sd->attributes=0;
  148.    cur_sd->x_offset=cur_dm_sd->tm_xoffset;
  149.    cur_sd->y_offset=cur_dm_sd->tm_yoffset;
  150.    cur_sd->sec=Sector_List+cur_dm_sd->sector;
  151.  
  152.    if (Cmp_Str_N(cur_dm_sd->main_tx, "-", 1))
  153.       cur_sd->texture_normal=TEXTURE_NULL;
  154.    else cur_sd->texture_normal=Get_Rand_Texture();
  155.  
  156.    if (Cmp_Str_N(cur_dm_sd->upper_tx, "-", 1))
  157.       cur_sd->texture_high=TEXTURE_NULL;
  158.    else cur_sd->texture_high=Get_Rand_Texture();
  159.  
  160.    if (Cmp_Str_N(cur_dm_sd->lower_tx, "-", 1))
  161.       cur_sd->texture_low=TEXTURE_NULL;
  162.    else cur_sd->texture_low=Get_Rand_Texture();
  163.  
  164. } /* endfor */
  165.  
  166. DelPtr(temp_sidedefs);
  167. }
  168.  
  169. void F_D_Get_LDs()
  170. {
  171. dm_line * temp_linedefs;
  172. short dir_index=F_D_Find_And_Setup("LINEDEFS", (void * *)&temp_linedefs);
  173. if (dir_index==-1)
  174.    return;
  175.  
  176. Number_Of_Linedefs=(directory[dir_index].length / sizeof(dm_line));
  177. Ld_List=(linedef *)NewPtr(Number_Of_Linedefs * sizeof(linedef));
  178.  
  179. short counter;
  180. linedef * cur_ld;
  181. dm_line * cur_dm_ld;
  182. for (counter=0; counter < Number_Of_Linedefs; counter++) {
  183.    cur_ld=Ld_List+counter;
  184.    cur_dm_ld=temp_linedefs+counter;
  185.    cur_ld->v[0]=cur_dm_ld->from;
  186.    cur_ld->v[1]=cur_dm_ld->to;
  187.    cur_ld->s[0]=Sd_List+cur_dm_ld->side[0];
  188.  
  189.    // Check to see if there is a second sidedef at all
  190.    if (cur_dm_ld->side[1]!=-1)
  191.       cur_ld->s[1]=Sd_List+cur_dm_ld->side[1];
  192.    else cur_ld->s[1]=NULL;
  193.  
  194.    cur_ld->attributes=(USHORT)cur_dm_ld->flags;
  195.    cur_ld->tag_type=(USHORT)cur_dm_ld->special;
  196.    cur_ld->tag=(USHORT)cur_dm_ld->tag;
  197.  
  198. } /* endfor */
  199. DelPtr(temp_linedefs);
  200.  
  201. Generate_Block_Map();
  202.  
  203. }
  204.  
  205. void F_D_Get_Segs()
  206. {
  207. dm_seg * temp_segs;
  208. short dir_index=F_D_Find_And_Setup("SEGS\0\0\0\0", (void * *)&temp_segs);
  209. if (dir_index==-1)
  210.    return;
  211.  
  212. Number_Of_Segs=(directory[dir_index].length / sizeof(dm_seg));
  213. Seg_List=(seg *)NewPtr(Number_Of_Segs * sizeof(seg));
  214.  
  215. short counter;
  216. seg * cur_seg; dm_seg * cur_dm_seg;
  217. for (counter=0; counter < Number_Of_Segs; counter++) {
  218.    cur_seg=Seg_List+counter;
  219.    cur_dm_seg=temp_segs+counter;
  220.    cur_seg->v[0]=cur_dm_seg->from;
  221.    cur_seg->v[1]=cur_dm_seg->to;
  222.    cur_seg->angle=((long)cur_dm_seg->angle * ANGLE_360) / DM_ANGLE_360;
  223.    cur_seg->ld=Ld_List+cur_dm_seg->line;
  224.    cur_seg->left_sidedef=(BOOL)cur_dm_seg->line_side;
  225.    cur_seg->linedef_offset=(LONG)cur_dm_seg->line_offset;
  226. } /* endfor */
  227.  
  228. DelPtr(temp_segs);
  229. }
  230.  
  231. void F_D_Get_SSectors()
  232. {
  233. dm_ssector * temp_ssectors;
  234. short dir_index=F_D_Find_And_Setup("SSECTORS", (void * *)&temp_ssectors);
  235. if (dir_index==-1)
  236.    return;
  237.  
  238. Number_Of_SSectors=(directory[dir_index].length / sizeof(dm_ssector));
  239. SS_List=(ssector *)NewPtr(Number_Of_SSectors * sizeof(ssector));
  240.  
  241. short counter;
  242. ssector * cur_ss;
  243. dm_ssector * cur_dm_ss;
  244. for (counter=0; counter < Number_Of_SSectors; counter++) {
  245.    cur_ss=SS_List+counter;
  246.    cur_dm_ss=temp_ssectors+counter;
  247.    cur_ss->seg_start=cur_dm_ss->first_seg;
  248.    cur_ss->seg_end=cur_ss->seg_start+cur_dm_ss->num_segs-1;
  249.    Doom_Sort_SSector(cur_ss);
  250.    cur_ss->num_objects=0;
  251.    cur_ss->objects=NULL;
  252.    cur_ss->flags=0;
  253. } /* endfor */
  254.  
  255. DelPtr(temp_ssectors);
  256. }
  257.  
  258. void F_D_Get_BSP()
  259. {
  260. dm_node * temp_nodes;
  261. short dir_index=F_D_Find_And_Setup("NODES\0\0\0", (void * *)&temp_nodes);
  262. if (dir_index==-1)
  263.    return;
  264.  
  265. Number_Of_Nodes=(directory[dir_index].length / sizeof(dm_node));
  266. bsp_tree=(bsp_node *)NewPtr(Number_Of_Nodes * sizeof(bsp_node));
  267.  
  268. bsp_start_node=Number_Of_Nodes-1;
  269.  
  270. short counter;
  271. bsp_node * cur_node;
  272. dm_node * cur_dm_node;
  273. prectl cur_rect;
  274. for (counter=0; counter < Number_Of_Nodes; counter++) {
  275.    cur_node=bsp_tree+counter;
  276.    cur_dm_node=temp_nodes+counter;
  277.    cur_node->x1=cur_dm_node->x;
  278.    cur_node->y1=cur_dm_node->y;
  279.    cur_node->x2=cur_node->x1 + cur_dm_node->dx;
  280.    cur_node->y2=cur_node->y1 + cur_dm_node->dy;
  281.    cur_rect=&(cur_node->left_bound);
  282.    cur_rect->top=cur_dm_node->ly2;
  283.    cur_rect->left=cur_dm_node->lx1;
  284.    cur_rect->bottom=cur_dm_node->ly1;
  285.    cur_rect->right=cur_dm_node->lx2;
  286.    cur_rect=&(cur_node->right_bound);
  287.    cur_rect->top=cur_dm_node->ry2;
  288.    cur_rect->left=cur_dm_node->rx1;
  289.    cur_rect->bottom=cur_dm_node->ry1;
  290.    cur_rect->right=cur_dm_node->rx2;
  291.    cur_node->left_child=cur_dm_node->left;
  292.    cur_node->right_child=cur_dm_node->right;
  293. } /* endfor */
  294.  
  295. DelPtr(temp_nodes);
  296.  
  297. Generate_BSP_Block();
  298. }
  299.  
  300. void F_D_Get_Player_Loc()
  301. {
  302. dm_thing * temp_things;
  303. short dir_index=F_D_Find_And_Setup("THINGS\0\0", (void * *)&temp_things);
  304. if (dir_index==-1)
  305.    return;
  306.  
  307. short num_things=(directory[dir_index].length / sizeof(dm_thing));
  308.  
  309. short counter;
  310. dm_thing * cur_dm_thing;
  311. for (counter=0; counter < num_things; counter++) {
  312.    cur_dm_thing=temp_things+counter;
  313.    if (cur_dm_thing->thing_type==PLAYER_START) {
  314. /*      the_player->x=cur_dm_thing->x;
  315.       the_player->y=cur_dm_thing->y;
  316.       the_player->angle=0; */
  317.    }
  318. } /* endfor */
  319.  
  320. DelPtr(temp_things);
  321. }
  322.  
  323. void Doom_Sort_SSector(ssector * cur_ss)
  324. {
  325. pseg cur_low, cur_test, seg_base;
  326. seg_base=Seg_List+cur_ss->seg_start;
  327. USHORT num_segs=cur_ss->seg_end - cur_ss->seg_start+1;
  328. for (short i=0; i<(num_segs-1); i++) {
  329.    cur_low=seg_base+i;
  330.    for (short j=i+1; j<num_segs; j++) {
  331.       cur_test=seg_base+j;
  332.       if (cur_test->angle > cur_low->angle)
  333.          Swap_Segs(cur_test, cur_low);
  334.    } /* endfor */
  335. } /* endfor */
  336. }
  337.  
  338. void Swap_Segs(seg * base_seg, seg * swap_seg)
  339. {
  340. seg temp_seg;
  341. memcpy(&temp_seg, base_seg, sizeof(seg));
  342. memcpy(base_seg, swap_seg, sizeof(seg));
  343. memcpy(swap_seg, &temp_seg, sizeof(seg));
  344. }
  345.