home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / RAYCAST.ZIP / SPRMOVE.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-17  |  7.0 KB  |  248 lines
  1. #include "ray.h"
  2. #include "globals.h"
  3. #include "bspmove.h"
  4. #include "blockbsp.h"
  5. #include "rayspr.h"
  6. #include "blockmap.h"
  7. #include "forever.h"
  8. #include "abs.h"
  9. #include "sign.h"
  10. #include "fixed.h"
  11. #include "error.h"
  12. #include "collisio.h"
  13. #include "message.h"
  14. #include "objcol.h"
  15.  
  16. #define MIN_DIS_FROM_WALL 1500
  17. #define MAX_LINE_DIS (128<<SHIFT)
  18.  
  19. void Do_Move_Correction(pvector2 input_source_vec, pvector2 delta_vec);
  20. void Do_Block_Correction(short block_x,
  21.    short block_y, pvector2 dest_vec, plinedef closest_line, MYFIXED & min_dis);
  22.  
  23.  
  24. short Move_Object_Dir(pobject source_obj, angle_type move_angle, long distance)
  25. {
  26. vector2 delta_vec;
  27. delta_vec.x=(rcos_table[move_angle]*distance)>>SHIFT;
  28. delta_vec.y=(rsin_table[move_angle]*distance)>>SHIFT;
  29. return Move_Object_Vec(source_obj, &delta_vec);
  30. }
  31.  
  32. short Move_Object_Vec(pobject source_obj, pvector2 delta_vec)
  33. {
  34. vector2 source_vec;
  35. source_vec.x=source_obj->x;
  36. source_vec.y=source_obj->y;
  37.  
  38. wall_collision_info wal_col;
  39. wal_col.move_obj=source_obj;
  40. wal_col.delta_vec=delta_vec;
  41. checkwalls(&wal_col);
  42. if (wal_col.found_collision) {
  43.   if (Send_Specific_Message(NULL, source_obj, WALL_COLLISION, (pdata)&wal_col))
  44.     return 0;
  45. }
  46.  
  47. obj_collision obj_col;
  48. obj_col.move_obj=source_obj;
  49. obj_col.delta_x=delta_vec->x;
  50. obj_col.delta_y=delta_vec->y;
  51. Check_Obj_Collision(&obj_col);
  52. if (obj_col.found_collision) {
  53.   if (Send_Specific_Message(obj_col.move_obj, obj_col.col_obj,
  54.      HIT_BY_OBJ, (pdata)&obj_col))
  55.      return 0;
  56.   if (Send_Specific_Message(obj_col.col_obj, obj_col.move_obj,
  57.      HIT_OBJ, (pdata)&obj_col))
  58.      return 0;
  59. } 
  60.  
  61. delta_vec->x=obj_col.delta_x;
  62. delta_vec->y=obj_col.delta_y;
  63.  
  64. source_obj->x+=delta_vec->x;
  65. source_obj->y+=delta_vec->y;
  66.  
  67. USHORT new_block_x, new_block_y;
  68. new_block_x=Block_X(source_obj->x);
  69. new_block_y=Block_Y(source_obj->y);
  70. if ( (new_block_x!=source_obj->block_x) || (new_block_y!=source_obj->block_y) ) {
  71.    OL_Delete_Node(source_obj->block_node,
  72.       *Get_Block_Obj_List(source_obj->block_x, source_obj->block_y));
  73.    OL_Push_Node(source_obj->block_node,
  74.       *Get_Block_Obj_List(new_block_x, new_block_y));
  75.    source_obj->block_x=new_block_x;
  76.    source_obj->block_y=new_block_y;
  77.    }
  78.  
  79. long starting_node_index;
  80.  
  81. // Get a starting index to do bsp seaching
  82. starting_node_index=Get_Closest_Node(source_obj->x, source_obj->y);
  83.  
  84. // Get the ssector
  85.  
  86. pssector new_ss=Get_Object_SSector(source_obj, starting_node_index);
  87.  
  88. // Have we changed sub sectors?
  89.  
  90. if (new_ss!=source_obj->cur_ss) {
  91.  
  92.   // Then move object from one sub sectors draw list to another's
  93.  
  94.   OL_Delete_Node(source_obj->ss_node, source_obj->cur_ss->objects);
  95.   source_obj->cur_ss->num_objects--;
  96.   OL_Push_Node(source_obj->ss_node,new_ss->objects);
  97.   new_ss->num_objects++;
  98.  
  99.   source_obj->cur_ss=new_ss;
  100.  
  101.   // Have we changed sectors?
  102.  
  103.   psector new_sec=Get_Sec_From_SSec(new_ss);
  104.   if (new_sec!=source_obj->cur_sec) {
  105.  
  106.      // Then update object's sector z value
  107.  
  108.      source_obj->type->Update_Z(source_obj, new_sec);
  109.  
  110.      source_obj->cur_sec=new_sec;
  111.  
  112.   }
  113.  
  114. }
  115.  
  116. return 0;
  117. }
  118.  
  119. void Do_Move_Correction(pvector2 input_source_vec, pvector2 delta_vec) {
  120.  
  121. vector2 source_vec, base_vec, old_vec;
  122. short cur_block_x, cur_block_y, dest_block_x, dest_block_y, next_block_x, next_block_y;
  123. long next_x_line, next_y_line, dist_major, dist_minor;
  124.  
  125. source_vec.x=input_source_vec->x;
  126. source_vec.y=input_source_vec->y;
  127. base_vec.x=source_vec.x;
  128. base_vec.y=source_vec.y;
  129. old_vec.x=base_vec.x;
  130. old_vec.y=base_vec.y;
  131.  
  132. FOREVER {
  133.  
  134.    Do_Block_Correction(cur_block_x, cur_block_y, NULL,NULL,dist_major);
  135.  
  136.    if ( (base_vec.x!=old_vec.x) || (base_vec.y!=old_vec.y) ) {
  137.       old_vec.x=base_vec.x;
  138.       old_vec.y=base_vec.y;
  139.       source_vec.x=base_vec.x;
  140.       source_vec.y=base_vec.y;
  141.       cur_block_x=Block_X(source_vec.x);
  142.       cur_block_y=Block_Y(source_vec.y);
  143.    }
  144.  
  145.    dest_block_x=Block_X(base_vec.x+delta_vec->x);
  146.    dest_block_y=Block_Y(base_vec.y+delta_vec->y);
  147.  
  148.    if ( (cur_block_x==dest_block_x) && (cur_block_y==dest_block_y) ) { 
  149.       break;
  150.    }
  151.  
  152.    if (delta_vec->x >= 0) {
  153.       next_block_x=cur_block_x+1;
  154.       next_x_line=Block_Right_Line(source_vec.x);
  155.    } else {
  156.       next_block_x=cur_block_x-1;
  157.       next_x_line=Block_Left_Line(source_vec.x);
  158.    }
  159.  
  160.    if (delta_vec->y >= 0) {
  161.       next_block_y=cur_block_y+1;
  162.       next_y_line=Block_Top_Line(source_vec.y);
  163.    } else {
  164.       next_block_y=cur_block_y-1;
  165.       next_y_line=Block_Bottom_Line(source_vec.y);
  166.    }
  167.  
  168.    if (ABS(delta_vec->x)>ABS(delta_vec->y)) {
  169.       
  170.       dist_minor=(next_y_line-source_vec.y)<<SHIFT;
  171.       dist_major=fixedmd((next_x_line-source_vec.x)<<SHIFT, 
  172.          delta_vec->y, delta_vec->x); 
  173.       
  174.       if (ABS(dist_major)<ABS(dist_minor)) {
  175.          source_vec.x=next_x_line;
  176.          source_vec.y+=(dist_major>>SHIFT);
  177.          cur_block_x=next_block_x;
  178.       } else {
  179.          source_vec.y=next_y_line;
  180.          source_vec.x+=fixedmd(dist_minor, delta_vec->x, delta_vec->y)>>SHIFT;
  181.          cur_block_y=next_block_y;
  182.       }
  183.  
  184.    } else {
  185.    
  186.       dist_minor=(next_x_line-source_vec.x)<<SHIFT;
  187.       dist_major=fixedmd((next_y_line-source_vec.y)<<SHIFT, 
  188.          delta_vec->x, delta_vec->y); 
  189.       
  190.       if (ABS(dist_major)<ABS(dist_minor)) {
  191.          source_vec.y=next_y_line;
  192.          source_vec.x+=(dist_major>>SHIFT);
  193.          cur_block_y=next_block_y;
  194.       } else {
  195.          source_vec.x=next_x_line;
  196.          source_vec.y+=fixedmd(dist_minor, delta_vec->y, delta_vec->x)>>SHIFT;
  197.          cur_block_x=next_block_x;
  198.       }
  199.  
  200.    }
  201.  
  202. }  
  203.  
  204. // make delta's from original position
  205. delta_vec->x=(source_vec.x+delta_vec->x)-input_source_vec->x;
  206. delta_vec->y=(source_vec.y+delta_vec->y)-input_source_vec->y;
  207. }
  208.  
  209. void Do_Block_Correction(short block_x,
  210.    short block_y, pvector2 dest_vec, plinedef closest_line, MYFIXED & min_dis)
  211. {
  212.    pline_list cur_line_list;
  213.    plinedef cur_line;
  214.    short cur_line_index;
  215.    long x1,x2,y1,y2, dest_dis, line_relation, line_dis;
  216.  
  217.    cur_line_list=Get_Block_Line_List(block_x, block_y);
  218.  
  219.       closest_line=NULL;
  220.  
  221.       for (cur_line_index=0; cur_line_index< cur_line_list->line_count; cur_line_index++) {
  222.  
  223.          cur_line=cur_line_list->lines[cur_line_index];
  224.          x1=Vector_List[cur_line->v[0]].x;
  225.          y1=Vector_List[cur_line->v[0]].y;
  226.          x2=Vector_List[cur_line->v[1]].x;
  227.          y2=Vector_List[cur_line->v[1]].y;
  228.          //line_dis=cur_line->distance;
  229.  
  230.          line_relation=fixeddiv( ((y1-y2)*(y1-dest_vec->y)-(x2-x1)*(x1-dest_vec->x)) << SHIFT,
  231.                 fixedmult(line_dis,line_dis));
  232.          if (line_relation<0 || line_relation>ONE)
  233.             dest_dis=MAX_LINE_DIS;
  234.          else {
  235.             dest_dis=fixeddiv(((x2-x1)*(dest_vec->y-y2)-(y1-y2)*(dest_vec->x-x2))<<SHIFT, line_dis);
  236.          }
  237.  
  238.          // have we found a closer intersecting line?
  239.          if (dest_dis<min_dis) {
  240.             closest_line=cur_line;
  241.             min_dis=dest_dis;
  242.             }
  243.  
  244.       } /* endfor */
  245.  
  246. }
  247.   
  248.