开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
Start.cpp
资源名称：3dgame开发《一》.rar　[点击查看]
上传用户：cncdtg88
上传日期：2013-03-14
资源大小：10474k
文件大小：20k
源码类别：

射击游戏

开发平台：

Visual C++

Start.cpp：源码内容
  1. // start.cpp : Defines the class behaviors for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "start.h"
  6. #include <stdio.h>
  7. #include <math.h>
  9. #include "MainFrm.h"
  10. #include "license.h"
  12. #ifdef _DEBUG
  13. #define new DEBUG_NEW
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  20. typedef struct player_data {
  21. RECT window_rect; //The size of the window used for rendering
  22. HPEN  crosshair_pen; //The pen used for drawing the crosshair (WIN32 stuff. Nothing to do with STATE ...)
  23. DWORD weapon; //A handle to the weapon object 
  24. DWORD fire_animation; //A handle to the animation used for shooting
  25. DWORD fire_effect_polygon; // When shooting we enable this polygon to be used by the shooting-fire-animation
  26. DWORD weapon_idle_sequence; //The sequence that is used with the weapon 3D animation when not shooting
  27. DWORD weapon_shooting_sequence; //A handle to the 3d animation sequance that is used while shooting
  28. DWORD weapon_shooting_mark_bitmap; //A handle to the the bitmap we use for marking shooting holes
  30. DWORD shooting_shred; //A object handle. This is the master splinter. When we shoot we duplicate this object 
  31.   //for creating the broken pieces falling down from where the bullets hit
  32. int   is_shooting;
  33. } player_data;
  37. player_data gl_player;
  39. #define STEP 60 
  41. #define GRAVITY 100.0  
  42. #define HEIGHT_ABOVE_GROUND (50.0*WORLD_FACTOR) 
  44. #define VIEWER_SIZE  (50*WORLD_FACTOR) 
  46. #define SIZE_OF_WALKING_EFFECT 32 
  47. #define WALKING_EFFECT_HEIGHT (HEIGHT_ABOVE_GROUND*0.125) 
  48. #define MOUSE_SENSITIVITY 0.2 
  49. #define MAX_TILT 85 
  50. #define GUN_MOVING_SPEED 0.05  
  52. #define SHOOTING_MARK_RADIUS 20 
  54. #define SHRED_SPEED 20 
  55. #define SHRED_SIZE 10 
  56. #define WORLD_FACTOR 6 
  59. #define STANDING 1 
  60. #define WALKING  2
  61. #define FALLING  3
  63. #define SOUND_STEP1 0
  64. #define SOUND_STEP2 1
  65. #define SOUND_STEP3 2
  66. #define SOUND_STEP4 3
  67. #define SOUND_FALL  4
  68. #define SOUND_HIT_WALL 5
  69. #define SOUND_SHOOT 6
  70. #define NUMBER_OF_SOUNDS 7
  72. //Opponent stage constant
  73. #define OPPONENT_IDLE 1
  74. #define OPPONENT_ATTACK 2
  76. #define OPPONENT_ATTACK_DISTANCE 1000
  78. DWORD g_skyArray[100];
  89. /////////////////////////////////////////////////////////////////////////////
  90. // CMy3DSTATE_AppWizardApp
  95. BEGIN_MESSAGE_MAP(CMy3DSTATE_AppWizardApp, CWinApp)
  96. //{{AFX_MSG_MAP(CMy3DSTATE_AppWizardApp)
  98. // NOTE - the ClassWizard will add and remove mapping macros here.
  99. //    DO NOT EDIT what you see in these blocks of generated code!
  100. //}}AFX_MSG_MAP
  101. END_MESSAGE_MAP()
  103. /////////////////////////////////////////////////////////////////////////////
  104. // CMy3DSTATE_AppWizardApp construction
  106. CMy3DSTATE_AppWizardApp::CMy3DSTATE_AppWizardApp()
  107. {
  108. // TODO: add construction code here,
  109. // Place all significant initialization in InitInstance
  110. }
  112. /////////////////////////////////////////////////////////////////////////////
  113. // The one and only CMy3DSTATE_AppWizardApp object
  115. CMy3DSTATE_AppWizardApp theApp;
  117. /////////////////////////////////////////////////////////////////////////////
  118. /////////////////////////////////////////////////////////////////////////////
  120. BOOL CMy3DSTATE_AppWizardApp::InitInstance()
  121. {
  127. return TRUE;
  128. }
  132. BOOL CMy3DSTATE_AppWizardApp::OnIdle(LONG lCount) 
  133. {
  141. return true; 
  142. }
  144. int CMy3DSTATE_AppWizardApp::ExitInstance() 
  145. {
  146. int res = CWinApp::ExitInstance();
  150. STATE_engine_close();
  153. return res;
  154. }
  161. void copy_vector(double dst[3], double src[3])
  162. {
  163. dst[0]=src[0];
  164. dst[1]=src[1];
  165. dst[2]=src[2];
  166. }
  168. void set_vector(double dst[3], double x, double y, double z)
  169. {
  170. dst[0]=x;
  171. dst[1]=y;
  172. dst[2]=z;
  173. }
  176. void add_vector(double dst[3], double src[3])
  177. {
  178. dst[0]+=src[0];
  179. dst[1]+=src[1];
  180. dst[2]+=src[2];
  181. }
  183. void sub_vector(double dst[3], double src[3])
  184. {
  185. dst[0]-=src[0];
  186. dst[1]-=src[1];
  187. dst[2]-=src[2];
  188. }
  191. void mul_vector(double vec[3], double factor)
  192. {
  193. vec[0]*=factor;
  194. vec[1]*=factor;
  195. vec[2]*=factor;
  196. }
  198. void camera_manage_free_falling(DWORD camera, double walking_height_effect[], int *player_stage, int *player_stage_progress, DWORD sounds[])
  199. {
  202. double location[3], bellow[3], intersection[3];
  203. STATE_camera_get_location(camera, &location[0], &location[1], &location[2]);
  204. copy_vector(bellow, location);
  205. bellow[2]=-1e10; 
  206. DWORD poly,obj;
  208. int rc=STATE_engine_is_movement_possible(location, bellow, &poly, intersection, &obj);
  209. if(rc==YES) {
  211. }
  212. else {
  214. double walking_effect=0;
  215. if( *player_stage==WALKING) 
  216. walking_effect=walking_height_effect[*player_stage_progress];
  217. double height=location[2]-intersection[2];
  218. double wanted_height_above_ground=HEIGHT_ABOVE_GROUND+walking_effect;
  220. if(height>wanted_height_above_ground+GRAVITY) {
  221. *player_stage=FALLING;
  222. location[2]-=GRAVITY;
  223. height-=GRAVITY;
  224. }
  225. else {
  226. location[2]=intersection[2]+wanted_height_above_ground;
  227. if(*player_stage==FALLING) {
  228. *player_stage=STANDING;
  229. STATE_sound_play(sounds[SOUND_FALL], SOUND_NO_LOOP);
  230. }
  231. }
  235. STATE_camera_set_location(camera, location[0], location[1], location[2]);
  237. }
  239. }
  241. void camera_move_according_to_keyboard_input(DWORD camera, int *player_stage, int *player_stage_progress, DWORD sounds[])
  242. {
  244. if(GetAsyncKeyState(VK_LEFT)<0) STATE_camera_rotate_z(camera, 5,WORLD_SPACE);
  245. if(GetAsyncKeyState(VK_RIGHT )<0) STATE_camera_rotate_z(camera, -5,WORLD_SPACE);
  247. double direction[3];
  248. STATE_camera_get_direction(camera, &direction[0], &direction[1], &direction[2]);
  249. direction[2]=0; 
  250. if(STATE_math_normalize_vector(direction)==VR_ERROR){
  252. set_vector(direction, 1,0,0);
  253. }
  256. if((*player_stage!=FALLING) && (GetAsyncKeyState(VK_UP)<0)) {
  257. *player_stage=WALKING; 
  258. mul_vector(direction,STEP);
  260. (*player_stage_progress)++;
  261. if(*player_stage_progress>=SIZE_OF_WALKING_EFFECT) {
  262. *player_stage_progress=0;
  263. }
  265. if( ((*player_stage_progress) % (SIZE_OF_WALKING_EFFECT/4))==0) {
  266. int sound_num=(*player_stage_progress)/(SIZE_OF_WALKING_EFFECT/4);
  267. STATE_sound_play(sounds[sound_num], SOUND_NO_LOOP);
  268. }
  270. }
  271. else
  272. if((*player_stage!=FALLING) && (GetAsyncKeyState(VK_DOWN)<0)) {
  273. mul_vector(direction,-STEP);
  274. *player_stage=WALKING;
  276. (*player_stage_progress)--;
  277. if((*player_stage_progress)<0) *player_stage_progress=SIZE_OF_WALKING_EFFECT-1;
  279. if( ((*player_stage_progress) % (SIZE_OF_WALKING_EFFECT/4))==0) {
  280. int sound_num=(*player_stage_progress)/(SIZE_OF_WALKING_EFFECT/4);
  281. STATE_sound_play(sounds[sound_num], SOUND_NO_LOOP);
  282. }
  285. }
  286. else {
  287. if(*player_stage!=FALLING)
  288. *player_stage=STANDING;
  289. return;
  290. }
  294. double wanted_location[3];
  295. STATE_camera_get_location(camera, &wanted_location[0], &wanted_location[1], &wanted_location[2]);
  296. add_vector(wanted_location, direction);
  299. int did_camera_move=STATE_camera_move_with_collision_detection(camera, wanted_location, VIEWER_SIZE);
  300. if(did_camera_move==NO) {
  301. if(*player_stage_progress==0) 
  302. STATE_sound_play(sounds[SOUND_HIT_WALL], SOUND_NO_LOOP);
  303. }
  306. }
  308. void camera_move_according_to_mouse_input(DWORD camera)
  309. {
  310. DWORD static first_time_flag=YES;
  311. static POINT point;
  313. if(GetCursorPos( &point)==0) 
  314. return; 
  315. int center_x=(gl_player.window_rect.right-gl_player.window_rect.left)/2;
  316. int center_y=(gl_player.window_rect.bottom-gl_player.window_rect.top)/2;
  319. SetCursorPos(center_x, center_y);
  321. if(first_time_flag==YES) {
  322. first_time_flag=NO; 
  323. return;
  324. }
  326. int diff_x=point.x-center_x;
  327. int diff_y=point.y-center_y;
  328. if(diff_x!=0)
  329. STATE_camera_rotate_z(camera, (double)-diff_x*MOUSE_SENSITIVITY,WORLD_SPACE);
  331. if(diff_y==0) return;
  332. double tilt=STATE_camera_get_tilt(camera);
  333. tilt-= (double)diff_y*MOUSE_SENSITIVITY;
  334. if(tilt>MAX_TILT) tilt=MAX_TILT;
  335. if(tilt<-MAX_TILT) tilt=-MAX_TILT;
  336. STATE_camera_set_tilt(camera, tilt);
  339. }
  342. void camera_update_location(DWORD camera, double walking_height_effect[], int *player_stage, int *player_stage_progress, DWORD sounds[])
  343. {
  344. camera_manage_free_falling(camera, walking_height_effect, player_stage, player_stage_progress, sounds);
  346. camera_move_according_to_keyboard_input(camera, player_stage, player_stage_progress, sounds);
  348. camera_move_according_to_mouse_input(camera);
  350. }
  353. void intitialize_walking_height_effect_array(double walking_height_effect[])
  354. {
  355. double step=2*M_PI/SIZE_OF_WALKING_EFFECT;
  356. double angle=0;
  357. for(int i=0; i<SIZE_OF_WALKING_EFFECT; i++) {
  358. walking_height_effect[i]=sin(angle)*WALKING_EFFECT_HEIGHT;
  359. angle+=step;
  360. }
  362. }
  365. void load_sounds(DWORD sounds[])
  366. {
  367. for(int i=0; i<4; i++) {
  368. char file_name[1000];
  369. sprintf(file_name,"sound\step%d.wav",i+1);
  370. sounds[i]=STATE_sound_load(file_name, NULL, SOUND_DISTANCE_DEFAULT);
  371. }
  373. sounds[SOUND_FALL]=STATE_sound_load("sound\fall1.wav", NULL, SOUND_DISTANCE_DEFAULT);
  374. sounds[SOUND_HIT_WALL]=STATE_sound_load("sound\hit_wall.wav", NULL, SOUND_DISTANCE_DEFAULT);
  375. sounds[SOUND_SHOOT]=STATE_sound_load("sound\shoot.wav", NULL, SOUND_DISTANCE_DEFAULT);
  377. }
  378. void create_the_weapon_fire_effect(void)
  379. {
  381. gl_player.fire_effect_polygon=STATE_polygon_create();
  384. int num_of_polygons=STATE_object_get_number_of_polygons(gl_player.weapon);
  385. DWORD *all_polygons=(DWORD *)GlobalAlloc(GPTR, num_of_polygons*sizeof(DWORD));
  386. STATE_object_get_all_polygons(gl_player.weapon, all_polygons);
  387. double edge_point[3];
  388. // find_a_point_at_the_end_of_the_weapon(all_polygons, num_of_polygons, edge_point);
  389. GlobalFree((HGLOBAL)all_polygons);
  391. double point1[6]={0,0,0, 0,0,  100};
  392. double point2[6]={0,0,0, 1,0,  100};
  393. double point3[6]={0,0,0, 1,1,  100};
  394. double point4[6]={0,0,0, 0,1,  100};
  395. double size=VIEWER_SIZE/10;
  396. set_vector(point1, edge_point[0], edge_point[1]-size, edge_point[2]+size);
  397. set_vector(point2, edge_point[0], edge_point[1]+size, edge_point[2]+size);
  398. set_vector(point3, edge_point[0], edge_point[1]+size, edge_point[2]-size);
  399. set_vector(point4, edge_point[0], edge_point[1]-size, edge_point[2]-size);
  402. STATE_polygon_add_point(gl_player.fire_effect_polygon, point1);
  403. STATE_polygon_add_point(gl_player.fire_effect_polygon, point2);
  404. STATE_polygon_add_point(gl_player.fire_effect_polygon, point3);
  405. STATE_polygon_add_point(gl_player.fire_effect_polygon, point4);
  407. STATE_object_add_polygon(gl_player.weapon, gl_player.fire_effect_polygon);
  409. STATE_polygon_set_animation(gl_player.fire_effect_polygon, gl_player.fire_animation);
  410. STATE_polygon_set_translucent(gl_player.fire_effect_polygon,LIGHT_SOURCE_GLASS);
  412. STATE_polygon_disable(gl_player.fire_effect_polygon);
  413. }
  414. DWORD create_master_shred(void)
  415. {
  416. DWORD obj=STATE_object_create("shred");
  418. DWORD poly=STATE_polygon_create();
  420. double point1[6]={0,0,0, 0,0,  100};
  421. double point2[6]={0,0,0, 1,0,  100};
  422. double point3[6]={0,0,0, 1,1,  100};
  423. double point4[6]={0,0,0, 0,1,  100};
  424. double size=SHRED_SIZE;
  425. set_vector(point1, 0, -size, size);
  426. set_vector(point2, 0, size, size);
  427. set_vector(point3, 0, size, -size);
  428. set_vector(point4, 0, -size, -size);
  429. STATE_polygon_add_point(poly, point1);
  430. STATE_polygon_add_point(poly, point2);
  431. STATE_polygon_add_point(poly, point3);
  432. STATE_polygon_add_point(poly, point4);
  434. STATE_object_add_polygon(obj, poly);
  436. STATE_polygon_set_rotated(poly, YES);
  438. DWORD mask_bitmap=STATE_bitmap_load("weapon\mask.bmp",-1);
  439. STATE_polygon_set_second_bitmap(poly, mask_bitmap);
  440. STATE_polygon_set_translucent(poly, LIGHT_SOURCE_GLASS );
  442. STATE_object_disable(obj);
  444. return(obj);
  446. }
  447. int load_weapon(void)
  448. {
  450. gl_player.weapon = STATE_object_create_from_file("weapon\weapon2.md2");
  451. if(gl_player.weapon == NULL) 
  452. return(VR_ERROR);
  455. DWORD skin = STATE_bitmap_load("weapon\weapon2.bmp",-1);
  456. STATE_object_set_bitmap(gl_player.weapon, skin);
  458. double box[2][3];
  459. STATE_object_get_bounding_box(gl_player.weapon, box);
  460. double weapon_size=box[1][0]-box[0][0];
  461. if(weapon_size==0) return(VR_ERROR); 
  462. double factor=VIEWER_SIZE/(2*weapon_size);
  463. double scale[3] = {factor,factor,factor};
  464. STATE_object_set_scale(gl_player.weapon, scale);
  467. DWORD anim3d = STATE_object_get_3D_animation(gl_player.weapon);
  468. if(anim3d != NULL) {
  469. gl_player.weapon_idle_sequence = STATE_3D_sequence_get_using_name(anim3d, "idle");
  470. STATE_object_set_3D_sequence(gl_player.weapon, gl_player.weapon_idle_sequence, 0);
  471. gl_player.weapon_shooting_sequence=STATE_3D_sequence_get_using_name(anim3d, "shot");
  472. }
  474. gl_player.fire_animation=STATE_animation_create("shoot");
  475. DWORD frame1=STATE_bitmap_load("weapon\Mflash2.bmp",-1);
  476. DWORD frame2=STATE_bitmap_load("weapon\Mflash3.bmp",-1);
  477. DWORD frame3=STATE_bitmap_load("weapon\Mflash4.bmp",-1);
  479. STATE_animation_add_bitmap(gl_player.fire_animation, BITMAP_LIST_FRONT, frame1, -1);
  480. STATE_animation_add_bitmap(gl_player.fire_animation, BITMAP_LIST_FRONT, frame2, -1);
  481. STATE_animation_add_bitmap(gl_player.fire_animation, BITMAP_LIST_FRONT, frame3, -1);
  483. DWORD times[3]={1,1,1};
  484. STATE_animation_set_times(gl_player.fire_animation, times, 3);
  486. create_the_weapon_fire_effect();
  487. gl_player.is_shooting=NO;
  489. gl_player.weapon_shooting_mark_bitmap=STATE_bitmap_load("weapon\smark.bmp",-1);
  491. gl_player.shooting_shred=create_master_shred();
  493. return(OK);
  495. }
  497. int initialize(double walking_height_effect[], DWORD sounds[])
  498. {
  503. int rc=STATE_engine_load_world("arena.STATE","", "bitmaps", USER_DEFINED_BEHAVIOR | MIPMAP_STABLE);
  504. if(rc==VR_ERROR) 
  505. return(VR_ERROR);
  509. ShowCursor(FALSE);
  511. STATE_engine_maximize_default_rendering_window();
  513. intitialize_walking_height_effect_array(walking_height_effect);
  515. DWORD camera=STATE_camera_get_default_camera();
  520. STATE_camera_set_chase_type(camera,NO_CHASE);
  521. if(load_weapon()==VR_ERROR) return(VR_ERROR);
  524. load_sounds(sounds);
  525. for (int i=0;i<100;i++)
  526. g_skyArray[i]=NULL;
  527. int sky_poly_count=0;
  528. for (DWORD poly=STATE_polygon_get_first_polygon();poly!=NULL;poly=STATE_polygon_get_next(poly))
  529. {
  530. if (!strcmp(STATE_polygon_get_name(poly),"Sky")){
  532. g_skyArray[sky_poly_count]=poly;
  533. sky_poly_count++;
  535. }
  537. }
  543. STATE_3D_card_set_full_screen_mode(800,600);
  545. GetClipCursor(&gl_player.window_rect);
  547. return(OK);
  549. }
  555. void draw_crosshair(HDC dc_handle, DWORD camera) 
  556. {
  557. int width=STATE_camera_get_width(camera);
  558. int height=STATE_camera_get_height(camera);
  560. int center_x=width/2;
  561. int center_y=height/2;
  563. SelectObject(dc_handle, GetStockObject(GRAY_BRUSH)); 
  564. SelectObject(dc_handle, gl_player.crosshair_pen); 
  565. Ellipse(dc_handle, center_x-3, center_y-3, center_x+3, center_y+3);
  566. Arc(dc_handle, center_x-12, center_y-12, center_x+12, center_y+12, center_x+12, center_y, center_x+12, center_y);
  569. MoveToEx(dc_handle, center_x-60, center_y, NULL);
  570. LineTo(dc_handle, center_x+60, center_y);
  571. MoveToEx(dc_handle, center_x, center_y-60, NULL);
  572. LineTo(dc_handle, center_x, center_y+60);
  574. }
  578. void move_sky()
  579. {
  580. int i=0;
  581. DWORD poly;
  582. while(1){
  583. poly=g_skyArray[i];
  584. if(poly==NULL)
  585. break;
  586. for (DWORD point=STATE_polygon_get_first_point(poly);point!=NULL;point=STATE_point_get_next_point(point))
  587. {
  588. double xy[2];
  589. STATE_point_get_bitmap_xy(point,xy);
  590. xy[0]+=0.005;
  591. STATE_point_set_bitmap_xy(point,poly,xy);
  592. }
  593. STATE_polygon_is_valid(poly);
  594. i++;
  595. }
  600. }
  602. void create_a_shooting_shred(double target[3], DWORD target_polygon, DWORD target_object)
  603. {
  604. if(target_object!=NULL) 
  605. return; 
  608. DWORD shred=STATE_object_duplicate(gl_player.shooting_shred, YES); 
  610. DWORD bmp=STATE_polygon_get_bitmap_handle(target_polygon);
  611. if(bmp!=NULL) {
  612. DWORD all_polys[1000]; 
  613. STATE_object_get_all_polygons(shred, all_polys); 
  614. STATE_polygon_set_bitmap_fill(all_polys[0], bmp);
  615. }
  617. double normal[4];
  618. STATE_polygon_get_plane(target_polygon, normal);
  619. mul_vector(normal, 5);
  620. add_vector(target, normal);
  621. STATE_object_set_location(shred, target[0], target[1], target[2]);
  623. STATE_object_set_chase_type(shred,CHASE_PHYSICS);
  625. STATE_object_set_max_speed(shred, SHRED_SPEED*10); 
  627. double speed[3]={rand()-RAND_MAX/2,rand()-RAND_MAX/2,rand()};
  629. STATE_object_set_speed(shred,speed);
  631. STATE_object_set_absolute_speed(shred,SHRED_SPEED);
  633. STATE_object_set_friction(shred, 0);
  635. STATE_object_set_elasticity(shred,0.4);
  637. double force[3]={0,0,-1};
  638. STATE_object_set_force(shred,force);
  640. STATE_object_set_event(shred, 5000, STATE_DELETE);
  642. }
  643. void set_weapon_direction(DWORD camera, double intersection[3], DWORD *blocking_polygon, DWORD *blocking_object)
  644. {
  645. double location[3], weapon_location[3];
  647. set_vector(location, -VIEWER_SIZE/2, VIEWER_SIZE/4, -VIEWER_SIZE/4);
  648. STATE_camera_convert_point_to_world_space(camera, location, weapon_location);
  650. STATE_object_set_location(gl_player.weapon, weapon_location[0], weapon_location[1], weapon_location[2]);
  652. double camera_location[3]={0,0,0}; 
  653. double far_ahead[3]={-10000000, 0,0}; 
  654. *blocking_polygon=NULL;
  655. *blocking_object=NULL;
  656. double direction[3];
  657. int rc=STATE_engine_is_movement_possible_camera_space(camera_location, far_ahead, blocking_polygon, intersection, blocking_object);
  658. if(rc==NO) {
  659. copy_vector(direction, intersection);
  660. sub_vector(direction, weapon_location);
  661. }
  662. else {
  663. STATE_camera_get_direction(camera, &direction[0], &direction[1], &direction[2]);
  664. }
  666. double old_direction[3];
  667. STATE_object_get_direction(gl_player.weapon, &old_direction[0], &old_direction[1], &old_direction[2]);
  669. mul_vector(direction, GUN_MOVING_SPEED);
  670. mul_vector(old_direction, (1-GUN_MOVING_SPEED));
  672. add_vector(direction, old_direction);
  674. STATE_object_set_direction(gl_player.weapon, direction[0], direction[1], direction[2]);
  678. }
  681. void manage_shooting(DWORD sounds[], double target[3], DWORD target_polygon, DWORD target_object)
  682. {
  684. int mouse_left_button= (GetAsyncKeyState(VK_LBUTTON)<0);
  685. if( (gl_player.is_shooting==NO) && mouse_left_button) {
  686. gl_player.is_shooting=YES;
  687. STATE_sound_play(sounds[SOUND_SHOOT], SOUND_NO_LOOP);
  688. STATE_polygon_enable(gl_player.fire_effect_polygon);
  689. STATE_object_set_3D_sequence(gl_player.weapon, gl_player.weapon_shooting_sequence, 0);
  690. return;
  692. }
  695. if( (gl_player.is_shooting==YES) && (mouse_left_button==0)) {
  696. gl_player.is_shooting=NO;
  697. STATE_sound_stop(sounds[SOUND_SHOOT]);
  698. STATE_polygon_disable(gl_player.fire_effect_polygon);
  699. STATE_object_set_3D_sequence(gl_player.weapon, gl_player.weapon_idle_sequence, 0);
  700. return;
  701. }
  704. if( gl_player.is_shooting==YES) {
  705. if(STATE_sound_is_sound_playing(sounds[SOUND_SHOOT])==NO) {
  706. gl_player.is_shooting=NO;
  707. STATE_polygon_disable(gl_player.fire_effect_polygon);
  708. STATE_object_set_3D_sequence(gl_player.weapon, gl_player.weapon_idle_sequence, 0);
  709. return;
  710. }
  712. // add_shooting_patch(target, target_polygon, target_object);
  713. create_a_shooting_shred(target, target_polygon, target_object);
  715. // if(target_object==gl_opponent.handle) {
  716. // gl_opponent.got_hit_flag=YES;
  717. // }
  720. }
  722. }
  725. void weapon_update(DWORD camera, DWORD sounds[])
  726. {
  727. double target[3]; 
  728. DWORD  target_polygon, target_object;
  730. if(gl_player.weapon==NULL) return;
  732. set_weapon_direction(camera, target, &target_polygon, &target_object);
  733. manage_shooting(sounds, target, target_polygon, target_object);
  737. }
  740. int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR     lpCmdLine,  int nCmdShow)
  741. {
  743. int initialize(double walking_height_effect[], DWORD sounds[]);
  744. void camera_update_location(DWORD camera, double walking_height_effect[], int *player_stage, int *player_stage_progress, DWORD sounds[]);
  745. void weapon_update(DWORD camera, DWORD sounds[]);
  749. DWORD sounds[NUMBER_OF_SOUNDS];
  751. double walking_height_effect[SIZE_OF_WALKING_EFFECT];
  752. int player_stage=STANDING;
  753. int player_stage_progress=0;
  757. if(initialize(walking_height_effect, sounds)==VR_ERROR) return(VR_ERROR);
  758. DWORD camera=STATE_camera_get_default_camera();
  761. while( (GetAsyncKeyState(VK_ESCAPE)&1) ==0 ) {
  763. HDC dc_handle=STATE_engine_render_on_dc(NULL,camera);
  764. draw_crosshair(dc_handle, camera);
  765. STATE_engine_copy_image_from_dc_to_screen();
  768. camera_update_location(camera, walking_height_effect, &player_stage, &player_stage_progress, sounds);
  770. weapon_update(camera, sounds);
  774. move_sky();
  775. }
  777. STATE_engine_close();
  779. return(OK);
  780. }