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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
BmyFPS.cpp
资源名称：fps.zip　[点击查看]
上传用户：mywjrx
上传日期：2008-01-23
资源大小：703k
文件大小：119k
源码类别：

射击游戏

开发平台：

Visual C++

BmyFPS.cpp：源码内容
  1. /*
  2.  *      Windows Frame Code Was Published By Jeff Molofee 2000. 
  3.  *      The Idea of This Game Was Taken From "FPS" At GLdomain.com
  4.  * And "MD2Loader" At GameTutorials.com.
  5.  * The model "q2mdl-hueteotl" Was Taken From PlanetQuake.com.
  6.  * You Can Reach Me at: gan_kim_heng@yahoo.com.
  7.  */
  8. #include <windows.h> // Header File For Windows
  9. #include <math.h> // Math Library Header File
  10. #include <stdio.h> // Header File For Standard Input/Output
  11. #include <glgl.h> // Header File For The OpenGL32 Library
  12. #include <glglu.h> // Header File For The GLu32 Library
  13. #include <glglaux.h> // Header File For The Glaux Library
  14. #include <stdlib.h>
  15. #include <mmsystem.h>
  17. #include "main.h"
  18. #include "Md2.h"
  19. #include "resource.h"
  21. #pragma comment( lib, "opengl32.lib") // Search For OpenGL32.lib While Linking
  22. #pragma comment( lib, "glu32.lib")
  23. #pragma comment( lib, "glaux.lib")
  24. #pragma comment( lib, "winmm.lib")
  26. HDC hDC=NULL; // Private GDI Device Context
  27. HGLRC hRC=NULL; // Permanent Rendering Context
  28. HWND hWnd=NULL; // Holds Our Window Handle
  29. HINSTANCE hInstance; // Holds The Instance Of The Application
  31. GLdouble WIDTH;
  32. GLdouble HEIGHT;
  34. const CELL = 256;
  35. #define MAX_PARTICLES 45
  36. #define MAX_SHOTS_FIRED 45
  38. #define FILE_NAME  "tris.md2" // This is the 3D file we will load.
  39. #define TEXTURE_NAME "hobgoblin.bmp" // This is the image file we will load.
  40. CLoadMD2 g_LoadMd2; // This is MD2 class.  This should go in a good model class.
  41. t3DModel g_3DModel; // This holds the 3D Model info that we load in
  43. bool  gameOver = false;
  44. bool  getOut = false;
  45. int   point = 0;
  47. bool  firstTrigger  = false;
  48. bool  firstHitStatus= false;
  49. int   firstHitCount = 0;
  50. float firstTransX = CELL*4 + 20.0f;
  51. float firstTransXi  = 0.0f;
  52. float firstTransZ   = CELL*6 + 20.0f;
  53. float firstTransZi  = 0.0f;
  54. float firstRotateY  = 0.0f;
  55. float firstRotateYi = 0.0f;
  56. float firstRotateX = 0.0f;
  57. float firstRotateXi = 0.0f;
  58. float firstMult     = 0.0f;
  60. bool  secondTrigger  = false;
  61. bool  secondHitStatus= false;
  62. int   secondHitCount = 0;
  63. float secondTransX  = CELL*2 + 20.0f;
  64. float secondTransXi  = 0.0f;
  65. float secondTransZ   = CELL*5 + 20.0f;
  66. float secondTransZi  = 0.0f;
  67. float secondRotateY  = 0.0f;
  68. float secondRotateYi = 0.0f;
  69. float secondRotateX  = 0.0f;
  70. float secondRotateXi = 0.0f;
  71. float secondMult     = 0.0f;
  73. bool  thirdTrigger  = false;
  74. bool  thirdHitStatus= false;
  75. int   thirdHitCount = 0;
  76. float thirdTransX = 20.0f;
  77. float thirdTransXi  = 0.0f;
  78. float thirdTransZ   = CELL*4 + 20.0f;
  79. float thirdTransZi  = 0.0f;
  80. float thirdRotateY  = 0.0f;
  81. float thirdRotateYi = 0.0f;
  82. float thirdRotateX = 0.0f;
  83. float thirdRotateXi = 0.0f;
  84. float thirdMult     = 0.0f;
  86. bool  fourthTrigger  = false;
  87. bool  fourthHitStatus= false;
  88. int   fourthHitCount = 0;
  89. float fourthTransX  = CELL*2 + 20.0f;
  90. float fourthTransXi  = 0.0f;
  91. float fourthTransZ   = CELL*2 + 20.0f;
  92. float fourthTransZi  = 0.0f;
  93. float fourthRotateY  = 0.0f;
  94. float fourthRotateYi = 0.0f;
  95. float fourthRotateX  = 0.0f;
  96. float fourthRotateXi = 0.0f;
  97. float fourthMult     = 0.0f;
  99. bool  fifthTrigger  = false;
  100. bool  fifthHitStatus= false;
  101. int   fifthHitCount = 0;
  102. float fifthTransX = 20.0f;
  103. float fifthTransXi  = 0.0f;
  104. float fifthTransZ   = CELL*2 + 20.0f;
  105. float fifthTransZi  = 0.0f;
  106. float fifthRotateY  = 0.0f;
  107. float fifthRotateYi = 0.0f;
  108. float fifthRotateX = 0.0f;
  109. float fifthRotateXi = 0.0f;
  110. float fifthMult     = 0.0f;
  112. bool  sixthTrigger  = false;
  113. bool  sixthHitStatus= false;
  114. int   sixthHitCount = 0;
  115. float sixthTransX = CELL*2-20.0f;
  116. float sixthTransXi  = 0.0f;
  117. float sixthTransZ   = 20.0f;
  118. float sixthTransZi  = 0.0f;
  119. float sixthRotateY  = 0.0f;
  120. float sixthRotateYi = 0.0f;
  121. float sixthRotateX = 0.0f;
  122. float sixthRotateXi = 0.0f;
  123. float sixthMult     = 0.0f; 
  125. GLdouble mouse_x, mouse_y;
  126. GLdouble mouse_3d_x, mouse_3d_y;
  127. int mouse_wrap_x = 0;
  128. int mouse_wrap_y = 0;
  129. bool invert_mouse = false; // Used to invert the y-axis for the mouse
  130. GLdouble sensitivity = 32; // the higher the #, the lower mouse the sensitivity.
  132. bool  keys[256]; // Array Used For The Keyboard Routine
  133. bool  fp;
  134. bool  ip;
  135. bool  active=TRUE; // Window Active Flag Set To TRUE By Default
  136. bool  fullscreen=TRUE; // Fullscreen Flag Set To Fullscreen Mode By Default
  137.  
  138. float m16_kick = 0;
  139. float m16_kicki = 0; 
  141. bool isFire = false;
  142. bool isFireComplete = true;
  143. bool isRicochet = false;
  145. GLdouble BlankNum = 0;
  147. BOOL done=FALSE; // Bool Variable To Exit Loop
  148. bool isFPS=FALSE;
  150. GLuint texture[6];
  152. // Absolute value function(comes in handy later).
  153. inline GLdouble ABS(GLdouble A)
  154. {
  155.   if (A < 0)
  156.   A = -A; 
  157.   return A;
  158. }
  160. // Hypotenuse Function
  161. inline GLdouble Hypot(GLdouble a, GLdouble b)
  162. {
  163.   return sqrt((a*a)+(b*b));
  164. }
  166. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc
  167. GLvoid KillGLWindow(GLvoid);
  169. typedef struct // Create A Structure
  170. {
  171. GLubyte *imageData; // Image Data (Up To 32 Bits)
  172. GLuint bpp; // Image Color Depth In Bits Per Pixel.
  173. GLuint width; // Image Width
  174. GLuint height; // Image Height
  175. GLuint texID; // Texture ID Used To Select A Texture
  176. } TextureImage; // Structure Name
  178. GLuint base; // Base Display List For The Font
  179. TextureImage textures[1];
  181. bool LoadTGA(TextureImage *texture, char *filename) // Loads A TGA File Into Memory
  182. {    
  183. GLubyte TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0}; // Uncompressed TGA Header
  184. GLubyte TGAcompare[12]; // Used To Compare TGA Header
  185. GLubyte header[6]; // First 6 Useful Bytes From The Header
  186. GLuint bytesPerPixel; // Holds Number Of Bytes Per Pixel Used In The TGA File
  187. GLuint imageSize; // Used To Store The Image Size When Setting Aside Ram
  188. GLuint temp; // Temporary Variable
  189. GLuint type=GL_RGBA; // Set The Default GL Mode To RBGA (32 BPP)
  191. FILE *file = fopen(filename, "rb"); // Open The TGA File
  193. if( file==NULL || // Does File Even Exist?
  194. fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) || // Are There 12 Bytes To Read?
  195. memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 || // Does The Header Match What We Want?
  196. fread(header,1,sizeof(header),file)!=sizeof(header)) // If So Read Next 6 Header Bytes
  197. {
  198. if (file == NULL) // Did The File Even Exist? *Added Jim Strong*
  199. return false; // Return False
  200. else
  201. {
  202. fclose(file); // If Anything Failed, Close The File
  203. return false; // Return False
  204. }
  205. }
  207. texture->width  = header[1] * 256 + header[0]; // Determine The TGA Width (highbyte*256+lowbyte)
  208. texture->height = header[3] * 256 + header[2]; // Determine The TGA Height (highbyte*256+lowbyte)
  209.     
  210.   if( texture->width <=0 || // Is The Width Less Than Or Equal To Zero
  211. texture->height <=0 || // Is The Height Less Than Or Equal To Zero
  212. (header[4]!=24 && header[4]!=32)) // Is The TGA 24 or 32 Bit?
  213. {
  214. fclose(file); // If Anything Failed, Close The File
  215. return false; // Return False
  216. }
  218. texture->bpp = header[4]; // Grab The TGA's Bits Per Pixel (24 or 32)
  219. bytesPerPixel = texture->bpp/8; // Divide By 8 To Get The Bytes Per Pixel
  220. imageSize = texture->width*texture->height*bytesPerPixel; // Calculate The Memory Required For The TGA Data
  222. texture->imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data
  224. if( texture->imageData==NULL || // Does The Storage Memory Exist?
  225. fread(texture->imageData, 1, imageSize, file)!=imageSize) // Does The Image Size Match The Memory Reserved?
  226. {
  227. if(texture->imageData!=NULL) // Was Image Data Loaded
  228. free(texture->imageData); // If So, Release The Image Data
  230. fclose(file); // Close The File
  231. return false; // Return False
  232. }
  234. for(GLuint i=0; i<int(imageSize); i+=bytesPerPixel) // Loop Through The Image Data
  235. { // Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)
  236. temp=texture->imageData[i]; // Temporarily Store The Value At Image Data 'i'
  237. texture->imageData[i] = texture->imageData[i + 2]; // Set The 1st Byte To The Value Of The 3rd Byte
  238. texture->imageData[i + 2] = temp; // Set The 3rd Byte To The Value In 'temp' (1st Byte Value)
  239. }
  241. fclose (file); // Close The File
  243. // Build A Texture From The Data
  244. glGenTextures(1, &texture[0].texID); // Generate OpenGL texture IDs
  246. glBindTexture(GL_TEXTURE_2D, texture[0].texID); // Bind Our Texture
  247. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Filtered
  248. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtered
  250. if (texture[0].bpp==24) // Was The TGA 24 Bits
  251. {
  252. type=GL_RGB; // If So Set The 'type' To GL_RGB
  253. }
  255.     gluBuild2DMipmaps(GL_TEXTURE_2D, type, texture[0].width, texture[0].height, type, GL_UNSIGNED_BYTE, texture[0].imageData);           
  257. return true; // Texture Building Went Ok, Return True
  258. }
  260. GLvoid BuildFont(GLvoid) // Build Our Font Display List
  261. {
  262. base=glGenLists(256); // Creating 256 Display Lists
  263. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  264. for (int loop1=0; loop1<256; loop1++) // Loop Through All 256 Lists
  265. {
  266. float cx=float(loop1%16)/16.0f; // X Position Of Current Character
  267. float cy=float(loop1/16)/16.0f; // Y Position Of Current Character
  269. glNewList(base+loop1,GL_COMPILE); // Start Building A List
  270. glBegin(GL_QUADS); // Use A Quad For Each Character
  271. glTexCoord2f(cx,1.0f-cy-0.0625f); // Texture Coord (Bottom Left)
  272. glVertex2d(0,16); // Vertex Coord (Bottom Left)
  273. glTexCoord2f(cx+0.0625f,1.0f-cy-0.0625f); // Texture Coord (Bottom Right)
  274. glVertex2i(16,16); // Vertex Coord (Bottom Right)
  275. glTexCoord2f(cx+0.0625f,1.0f-cy-0.001f); // Texture Coord (Top Right)
  276. glVertex2i(16,0); // Vertex Coord (Top Right)
  277. glTexCoord2f(cx,1.0f-cy-0.001f); // Texture Coord (Top Left)
  278. glVertex2i(0,0); // Vertex Coord (Top Left)
  279. glEnd(); // Done Building Our Quad (Character)
  280. glTranslated(14,0,0); // Move To The Right Of The Character
  281. glEndList(); // Done Building The Display List
  282. } // Loop Until All 256 Are Built
  283. }
  285. GLvoid KillFont(GLvoid) // Delete The Font From Memory
  286. {
  287. glDeleteLists(base,256); // Delete All 256 Display Lists
  288. }
  290. GLvoid glPrint(GLint x, GLint y, int set, const char *fmt, ...) // Where The Printing Happens
  291. {
  292. char text[1024]; // Holds Our String
  293. va_list ap; // Pointer To List Of Arguments
  295. if (fmt == NULL) // If There's No Text
  296. return; // Do Nothing
  298. va_start(ap, fmt); // Parses The String For Variables
  299.     vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers
  300. va_end(ap); // Results Are Stored In Text
  302. if (set>1) // Did User Choose An Invalid Character Set?
  303. {
  304. set=1; // If So, Select Set 1 (Italic)
  305. }
  307. glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
  308. glLoadIdentity(); // Reset The Modelview Matrix
  309. glTranslated(x,y,-500); // Position The Text (0,0 - Top Left)
  310. glRotatef(180,0,0,1);
  311. glRotatef(180,0,1,0);
  312. glListBase(base-32+(128*set)); // Choose The Font Set (0 or 1)
  314. glCallLists(strlen(text),GL_UNSIGNED_BYTE, text); // Write The Text To The Screen
  315. glDisable(GL_TEXTURE_2D); // Disable Texture Mapping
  316. }
  318. AUX_RGBImageRec *LoadBMP(char *Filename) // Loads A Bitmap Image
  319. {
  320. FILE *File=NULL; // File Handle
  322. if (!Filename) // Make Sure A Filename Was Given
  323. {
  324. return NULL; // If Not Return NULL
  325. }
  327. File=fopen(Filename,"r"); // Check To See If The File Exists
  329. if (File) // Does The File Exist?
  330. {
  331. fclose(File); // Close The Handle
  332. return auxDIBImageLoad(Filename); // Load The Bitmap And Return A Pointer
  333. }
  335. return NULL; // If Load Failed Return NULL
  336. }
  338. // Create A Structure For The Timer Information
  339. struct
  340. {
  341.   __int64       frequency; // Timer Frequency
  342.   GLdouble      resolution; // Timer Resolution
  343.   unsigned long mm_timer_start;     
  344.   
  345.   // Multimedia Timer Start Value
  346.   unsigned long mm_timer_elapsed; // Multimedia Timer Elapsed Time
  347.   bool performance_timer;    
  348.   
  349.   // Using The Performance Timer?
  350.   __int64       performance_timer_start; // Performance Timer Start Value
  351.   __int64       performance_timer_elapsed; // Performance Timer Elapsed Time
  352. } timer;
  354. // Initialize Our Timer
  355. void TimerInit(void)
  356. {
  357.      memset(&timer, 0, sizeof(timer));   
  358.  // Clear Our Timer Structure
  359.      // Check To See If A Performance Counter Is Available
  360.      // If One Is Available The Timer Frequency Will Be Updated
  361.      if (!QueryPerformanceFrequency((LARGE_INTEGER *) &timer.frequency))
  362.      {
  363.           // No Performace Counter Available
  364.           timer.performance_timer = FALSE;                  // Set Performance Timer To FALSE
  365.           timer.mm_timer_start = timeGetTime();             // Use timeGetTime()
  366.           timer.resolution  = 1.0f/1000.0f;                 // Set Our Timer Resolution To .001f
  367.           timer.frequency   = 1000;                         // Set Our Timer Frequency To 1000
  368.           timer.mm_timer_elapsed = timer.mm_timer_start; // Set The Elapsed Time
  369.      }
  370.      else
  371.      {
  372.           // Performance Counter Is Available, Use It Instead Of The Multimedia Timer
  373.           // Get The Current Time And Store It In performance_timer_start
  374.           QueryPerformanceCounter((LARGE_INTEGER *) &timer.performance_timer_start);
  375.           timer.performance_timer   = TRUE;    // Set Performance Timer To TRUE
  376.           // Calculate The Timer Resolution Using The Timer Frequency
  377.           timer.resolution    = (GLdouble) (((double)1.0f)/((double)timer.frequency));
  378.           // Set The Elapsed Time To The Current Time
  379.           timer.performance_timer_elapsed = timer.performance_timer_start;
  380.      }
  381. }
  383. // Get Time In Milliseconds
  384. inline GLdouble TimerGetTime()
  385. {
  386.   __int64 time; // 'time' Will Hold A 64 Bit Integer
  387.   if (timer.performance_timer) // Are We Using The Performance Timer?
  388.   {
  389.     QueryPerformanceCounter((LARGE_INTEGER *) &time); // Current Performance Time
  390.     // Return The Time Elapsed since TimerInit was called
  391.     return ( (GLdouble) ( time - timer.performance_timer_start) * timer.resolution)*1000.0f;
  392.   }
  393.   else
  394.   {
  395.     // Return The Time Elapsed since TimerInit was called
  396.     return ( (GLdouble) ( timeGetTime() - timer.mm_timer_start) * timer.resolution)*1000.0f;
  397.   }
  398. }
  400. int LoadGLTextures() // Load Bitmap And Convert To A Texture
  401. {
  402.   int Status=FALSE; // Status Indicator
  403.   AUX_RGBImageRec *TextureImage[1]; // Create Storage Space For The Textures
  404.   memset(TextureImage,0,sizeof(void *)*1); // Set The Pointer To NULL
  406.   if (TextureImage[0]=LoadBMP("Data/walls.bmp")) // Load Wall Texture
  407.   {
  408.     Status=TRUE; // Set The Status To TRUE
  409.     glGenTextures(1, &texture[1]); // Create One Texture
  411.     // Create MipMapped Texture
  412.     glBindTexture(GL_TEXTURE_2D, texture[1]);
  413.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  414.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  415.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  416.   }
  418.   if (TextureImage[0]=LoadBMP("Data/crosshair.bmp")) // Load crossHair Texture
  419.   {
  420.     Status=TRUE; // Set The Status To TRUE
  421.     glGenTextures(1, &texture[2]); // Create One Texture
  423.     // Create MipMapped Texture
  424.     glBindTexture(GL_TEXTURE_2D, texture[2]);
  425.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  426.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  427.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  428.   }
  430.   if (TextureImage[0]=LoadBMP("Data/smoke.bmp")) // Load smoke Texture
  431.   {
  432.     Status=TRUE; // Set The Status To TRUE
  433.     glGenTextures(1, &texture[3]); // Create One Texture
  435.     // Create MipMapped Texture
  436.     glBindTexture(GL_TEXTURE_2D, texture[3]);
  437.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  438.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  439.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  440.   }
  442.   if (TextureImage[0]=LoadBMP("hobgoblin.bmp")) // Load model image Texture
  443.   {
  444.     Status=TRUE; // Set The Status To TRUE
  445.     glGenTextures(1, &texture[4]); // Create One Texture
  447.     // Create MipMapped Texture
  448.     glBindTexture(GL_TEXTURE_2D, texture[4]);
  449.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  450.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  451.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  452.   }
  454.   if (TextureImage[0]=LoadBMP("Data/exit.bmp")) // Load exit Texture
  455.   {
  456.     Status=TRUE; // Set The Status To TRUE
  457.     glGenTextures(1, &texture[5]); // Create One Texture
  459.     // Create MipMapped Texture
  460.     glBindTexture(GL_TEXTURE_2D, texture[5]);
  461.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  462.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  463.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  464.   }
  466.   if (TextureImage[0]=LoadBMP("Data/floor.bmp")) // Load Floor Texture
  467.   {
  468.     Status=TRUE; // Set The Status To TRUE
  469.     glGenTextures(1, &texture[6]); // Create One Texture
  471.     // Create MipMapped Texture
  472.     glBindTexture(GL_TEXTURE_2D, texture[6]);
  473.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  474.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  475.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  476.   }
  478.   if (TextureImage[0]) // If Texture Exists
  479. {
  480.     if (TextureImage[0]->data) // If Texture Image Exists
  481.     {
  482.       free(TextureImage[0]->data); // Free The Texture Image Memory
  483.     }
  484.     free(TextureImage[0]); // Free The Image Structure
  485.   }
  487.   return Status; // Return The Status
  488. }
  490. GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
  491. {
  492. if (height==0) // Prevent A Divide By Zero By
  493. {
  494. height=1; // Making Height Equal One
  495. }
  497. WIDTH=width;
  498. HEIGHT=height;
  499. glViewport(0,0,width,height); // Reset The Current Viewport
  501. glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
  502. glLoadIdentity(); // Reset The Projection Matrix
  504. // Calculate The Aspect Ratio Of The Window
  505. glLoadIdentity(); // Reset The Modelview Matrix
  506. gluPerspective(60.0f,(GLdouble)width/(GLdouble)height,1.0f,1250.0f);
  508. glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
  509. glLoadIdentity(); // Reset The Modelview Matrix
  510. }
  512. static GLuint ROOM[18], MODEL; // Storage For The Room Display List
  514. // Build Cube Display Lists
  515. GLvoid BuildLists()
  516. { 
  517. ROOM[0]=glGenLists(18); // IDENTITY[IJ=1 1], Generate 18 Different Lists
  518.     glNewList(ROOM[0],GL_COMPILE);
  519.     
  520. glBindTexture(GL_TEXTURE_2D, texture[6]); 
  521.    
  522. glBegin(GL_QUADS);//bottom
  523. glTexCoord2d(20,28);  glVertex3d(CELL*5,0,CELL*7);
  524. glTexCoord2d(20,0);  glVertex3d(CELL*5,0,0);
  525. glTexCoord2d(0,0);  glVertex3d(0,0,0);
  526. glTexCoord2d(0,28);  glVertex3d(0,0,CELL*7);
  527. glEnd();
  529. glBegin(GL_QUADS);//top
  530. glTexCoord2d(20,28);  glVertex3d(CELL*5,CELL/4,CELL*7);
  531. glTexCoord2d(20,0);  glVertex3d(CELL*5,CELL/4,0);
  532. glTexCoord2d(0,0);  glVertex3d(0,CELL/4,0);
  533. glTexCoord2d(0,28);  glVertex3d(0,CELL/4,CELL*7);
  534. glEnd(); 
  535. /////////////////////////Wall Start///////////////////////////////////
  536.  
  537. glBindTexture(GL_TEXTURE_2D, texture[1]); 
  538. glBegin(GL_QUADS);//front
  539. glTexCoord2d(4,1);  glVertex3d(CELL*5,CELL/4,CELL*6);
  540. glTexCoord2d(4,0);  glVertex3d(CELL*5,0,CELL*6);
  541. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*6);
  542. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*6);
  543. glEnd();
  545. glBegin(GL_QUADS);//back
  546. glTexCoord2d(4,1);  glVertex3d(CELL*5,CELL/4,CELL*7);
  547. glTexCoord2d(4,0);  glVertex3d(CELL*5,0,CELL*7);
  548. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*7);
  549. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*7);
  550. glEnd();
  552. glBegin(GL_QUADS);//right
  553. glTexCoord2d(4,1);  glVertex3d(CELL*5,CELL/4,CELL*7);
  554. glTexCoord2d(4,0);  glVertex3d(CELL*5,0,CELL*7);
  555. glTexCoord2d(0,0);  glVertex3d(CELL*5,0,CELL*6);
  556. glTexCoord2d(0,1);  glVertex3d(CELL*5,CELL/4,CELL*6);
  557. glEnd();
  558. /////////////////////////Wall End///////////////////////////////////
  559.     glEndList();
  561. ROOM[1]=ROOM[0]+1;//IDENTITY[IJ=2 1]
  562. glNewList(ROOM[1],GL_COMPILE);
  563.  
  564. glBegin(GL_QUADS);//back
  565. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*7);
  566. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*7);
  567. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*7);
  568. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*7);
  569. glEnd();
  571. glBegin(GL_QUADS);//right
  572. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*7);
  573. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*7);
  574. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*6);
  575. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*6);
  576. glEnd();
  577. /////////////////////////Wall End///////////////////////////////////
  578.     glEndList();
  580. ROOM[2]=ROOM[1]+1;//IDENTITY[IJ=2 2]
  581. glNewList(ROOM[2],GL_COMPILE);  
  582.  
  583. glBegin(GL_QUADS);//right
  584. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*6);
  585. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*6);
  586. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*5);
  587. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*5);
  588. glEnd();
  589. /////////////////////////Wall End///////////////////////////////////
  590.     glEndList();
  592. ROOM[3]=ROOM[2]+1;//IDENTITY[IJ=2 3]
  593. glNewList(ROOM[3],GL_COMPILE); 
  594.  
  595. glBegin(GL_QUADS);//left
  596. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*5);
  597. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*5);
  598. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*4);
  599. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*4);
  600. glEnd();  
  602. glBegin(GL_QUADS);//right
  603. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*5);
  604. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*5);
  605. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*4);
  606. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*4);
  607. glEnd();
  608. /////////////////////////Wall End///////////////////////////////////
  609.     glEndList();
  611. ROOM[4]=ROOM[3]+1;//IDENTITY[IJ=2 4]
  612. glNewList(ROOM[4],GL_COMPILE); 
  613.  
  614. glBegin(GL_QUADS);//front
  615. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  616. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*3);
  617. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*3);
  618. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*3);
  619. glEnd(); 
  621. glBegin(GL_QUADS);//right
  622. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*4);
  623. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*4);
  624. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*3);
  625. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  626. glEnd();
  627. /////////////////////////Wall End///////////////////////////////////
  628.     glEndList();
  630. ROOM[4]=ROOM[3]+1;//IDENTITY[IJ=2 4]
  631. glNewList(ROOM[4],GL_COMPILE); 
  632.  
  633. glBegin(GL_QUADS);//front
  634. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  635. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*3);
  636. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*3);
  637. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*3);
  638. glEnd(); 
  640. glBegin(GL_QUADS);//right
  641. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*4);
  642. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*4);
  643. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*3);
  644. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  645. glEnd();
  646. /////////////////////////Wall End///////////////////////////////////
  647.     glEndList();
  649. ROOM[5]=ROOM[4]+1;//IDENTITY[IJ=3 2]
  650. glNewList(ROOM[5],GL_COMPILE); 
  651.  
  652. glBegin(GL_QUADS);//front
  653. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*5);
  654. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*5);
  655. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*5);
  656. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*5);
  657. glEnd(); 
  659. glBegin(GL_QUADS);//back
  660. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*6);
  661. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*6);
  662. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*6);
  663. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*6);
  664. glEnd();
  665. /////////////////////////Wall End///////////////////////////////////
  666.     glEndList();
  668. ROOM[6]=ROOM[5]+1;//IDENTITY[IJ=3 4]
  669. glNewList(ROOM[6],GL_COMPILE); 
  670.  
  671. glBegin(GL_QUADS);//back
  672. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*4);
  673. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*4);
  674. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*4);
  675. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*4);
  676. glEnd();  
  677. /////////////////////////Wall End///////////////////////////////////
  678.     glEndList();
  680. ROOM[7]=ROOM[6]+1;//IDENTITY[IJ=3 5]
  681. glNewList(ROOM[7],GL_COMPILE); 
  682.  
  683. glBegin(GL_QUADS);//left
  684. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*3);
  685. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*3);
  686. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*2);
  687. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*2);
  688. glEnd(); 
  690. glBegin(GL_QUADS);//right
  691. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*3);
  692. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*3);
  693. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*2);
  694. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*2);
  695. glEnd();
  696. /////////////////////////Wall End///////////////////////////////////
  697.     glEndList();
  699. ROOM[8]=ROOM[7]+1;//IDENTITY[IJ=3 6]
  700. glNewList(ROOM[8],GL_COMPILE); 
  701.  
  702. glBegin(GL_QUADS);//front
  703. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL);
  704. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL);
  705. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL);
  706. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL);
  707. glEnd(); 
  709. glBegin(GL_QUADS);//left
  710. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*2);
  711. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*2);
  712. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL);
  713. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL);
  714. glEnd(); 
  716. glBegin(GL_QUADS);//right
  717. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*2);
  718. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*2);
  719. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL);
  720. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL);
  721. glEnd();
  722. /////////////////////////Wall End///////////////////////////////////
  723.     glEndList();
  725. ROOM[9]=ROOM[8]+1;//IDENTITY[IJ=4 2]
  726. glNewList(ROOM[9],GL_COMPILE); 
  727.  
  728. glBegin(GL_QUADS);//front
  729. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*5);
  730. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*5);
  731. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*5);
  732. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*5);
  733. glEnd(); 
  735. glBegin(GL_QUADS);//back
  736. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*6);
  737. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*6);
  738. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*6);
  739. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*6);
  740. glEnd();
  741. /////////////////////////Wall End///////////////////////////////////
  742.     glEndList();
  744. ROOM[10]=ROOM[9]+1;//IDENTITY[IJ=4 4]
  745. glNewList(ROOM[10],GL_COMPILE); 
  746.  
  747. glBegin(GL_QUADS);//front
  748. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*3);
  749. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*3);
  750. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*3);
  751. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*3);
  752. glEnd(); 
  754. glBegin(GL_QUADS);//back
  755. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*4);
  756. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*4);
  757. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*4);
  758. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*4);
  759. glEnd();
  760. /////////////////////////Wall End///////////////////////////////////
  761.     glEndList();
  763. ROOM[11]=ROOM[10]+1;//IDENTITY[IJ=4 6]
  764. glNewList(ROOM[11],GL_COMPILE); 
  765.  
  766. glBegin(GL_QUADS);//back
  767. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*2);
  768. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*2);
  769. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*2);
  770. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*2);
  771. glEnd(); 
  772. /////////////////////////Wall End///////////////////////////////////
  773.     glEndList();
  775. ROOM[12]=ROOM[11]+1;//IDENTITY[IJ=4 7]
  776. glNewList(ROOM[12],GL_COMPILE); 
  778. glBindTexture(GL_TEXTURE_2D, texture[5]); 
  779. glBegin(GL_QUADS);//front
  780. glTexCoord2d(1,1);  glVertex3d(CELL*2-CELL*3/8,CELL/4,0);
  781. glTexCoord2d(1,0);  glVertex3d(CELL*2-CELL*3/8,0,0);
  782. glTexCoord2d(0,0);  glVertex3d(CELL+CELL*3/8,0,0);
  783. glTexCoord2d(0,1);  glVertex3d(CELL+CELL*3/8,CELL/4,0);
  784. glEnd(); 
  785.  
  786. glBindTexture(GL_TEXTURE_2D, texture[1]);
  787. glBegin(GL_QUADS);//front left
  788. glTexCoord2d(1.5,1);  glVertex3d(CELL+CELL*3/8,CELL/4,0);
  789. glTexCoord2d(1.5,0);  glVertex3d(CELL+CELL*3/8,0,0);
  790. glTexCoord2d(0,0);  glVertex3d(CELL,0,0);
  791. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,0);
  792. glEnd();
  794. glBegin(GL_QUADS);//front right
  795. glTexCoord2d(1.5,1);  glVertex3d(CELL*2,CELL/4,0);
  796. glTexCoord2d(1.5,0);  glVertex3d(CELL*2,0,0);
  797. glTexCoord2d(0,0);  glVertex3d(CELL*2-CELL*3/8,0,0);
  798. glTexCoord2d(0,1);  glVertex3d(CELL*2-CELL*3/8,CELL/4,0);
  799. glEnd();
  801. glBegin(GL_QUADS);//left
  802. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL);
  803. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL);
  804. glTexCoord2d(0,0);  glVertex3d(CELL,0,0);
  805. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,0);
  806. glEnd();  
  808. glBegin(GL_QUADS);//right
  809. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL);
  810. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL);
  811. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,0);
  812. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,0);
  813. glEnd();
  815. /////////////////////////Wall End///////////////////////////////////
  816.     glEndList();
  818. ROOM[13]=ROOM[12]+1;//IDENTITY[IJ=5 2]
  819. glNewList(ROOM[13],GL_COMPILE); 
  820.  
  821. glBegin(GL_QUADS);//back
  822. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*6);
  823. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*6);
  824. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*6);
  825. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*6);
  826. glEnd(); 
  828. glBegin(GL_QUADS);//left
  829. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*6);
  830. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*6);
  831. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*5);
  832. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*5);
  833. glEnd();  
  834. /////////////////////////Wall End///////////////////////////////////
  835.     glEndList();
  837. ROOM[14]=ROOM[13]+1;//IDENTITY[IJ=5 3]
  838. glNewList(ROOM[14],GL_COMPILE); 
  839.  
  840. glBegin(GL_QUADS);//front
  841. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*4);
  842. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*4);
  843. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*4);
  844. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*4);
  845. glEnd(); 
  847. glBegin(GL_QUADS);//left
  848. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*5);
  849. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*5);
  850. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*4);
  851. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*4);
  852. glEnd(); 
  854. glBegin(GL_QUADS);//right
  855. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*5);
  856. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*5);
  857. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*4);
  858. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*4);
  859. glEnd();
  860. /////////////////////////Wall End///////////////////////////////////
  861.     glEndList();
  863. ROOM[15]=ROOM[14]+1;//IDENTITY[IJ=5 4]
  864. glNewList(ROOM[15],GL_COMPILE); 
  865.  
  866. glBegin(GL_QUADS);//left
  867. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*4);
  868. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*4);
  869. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*3);
  870. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*3);
  871. glEnd();  
  872. /////////////////////////Wall End///////////////////////////////////
  873.     glEndList();
  875. ROOM[16]=ROOM[15]+1;//IDENTITY[IJ=5 5]
  876. glNewList(ROOM[16],GL_COMPILE); 
  877.  
  878. glBegin(GL_QUADS);//left
  879. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*3);
  880. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*3);
  881. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*2);
  882. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*2);
  883. glEnd(); 
  885. glBegin(GL_QUADS);//right
  886. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*3);
  887. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*3);
  888. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*2);
  889. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*2);
  890. glEnd();
  891. /////////////////////////Wall End///////////////////////////////////
  892.     glEndList();
  894. ROOM[17]=ROOM[16]+1;//IDENTITY[IJ=5 6]
  895. glNewList(ROOM[17],GL_COMPILE); 
  896.  
  897. glBegin(GL_QUADS);//front
  898. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL);
  899. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL);
  900. glTexCoord2d(0,0);  glVertex3d(0,0,CELL);
  901. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL);
  902. glEnd(); 
  904. glBegin(GL_QUADS);//left
  905. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*2);
  906. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*2);
  907. glTexCoord2d(0,0);  glVertex3d(0,0,CELL);
  908. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL);
  909. glEnd();  
  910. /////////////////////////Wall End///////////////////////////////////
  911.     glEndList(); 
  912. }
  914. GLvoid BuildLists1()
  915. {
  916. MODEL=glGenLists(1); // Generate Model Lists
  917. glNewList(MODEL,GL_COMPILE);
  918. glDisable(GL_BLEND);
  919. //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
  920. glBindTexture(GL_TEXTURE_2D, texture[4]);
  922. if(g_3DModel.pObject.size() > 0)
  923. {
  924. // Get the current object that we are displaying
  925. t3DObject *pObject = &g_3DModel.pObject[0];
  927. // Render lines or normal triangles mode, depending on the global variable
  928. glBegin(GL_TRIANGLES);
  930. // Go through all of the faces (polygons) of the object and draw them
  931. for(int j = 0; j < pObject->numOfFaces; j++)
  932. {
  933. // Go through each corner of the triangle and draw it.
  934. for(int whichVertex = 0; whichVertex < 3; whichVertex++)
  935. {
  936. // Get the index for each point in the face
  937. int index = pObject->pFaces[j].vertIndex[whichVertex];
  939. // Get the index for each texture coord in the face
  940. int index2 = pObject->pFaces[j].coordIndex[whichVertex];
  942. // Give OpenGL the normal for this vertex.  Notice that we put a 
  943. // - sign in front.  It appears that because of the ordering of Quake2's
  944. // polygons, we need to invert the normal
  945. glNormal3f(-pObject->pNormals[ index ].x, -pObject->pNormals[ index ].y, -pObject->pNormals[ index ].z);
  947. // Make sure there was a UVW map applied to the object or else it won't have tex coords.
  948. if(pObject->pTexVerts) 
  949. {
  950. glTexCoord2f(pObject->pTexVerts[ index2 ].x, pObject->pTexVerts[ index2 ].y);
  951. }
  953. // Pass in the current vertex of the object (Corner of current face)
  954. glVertex3f(pObject->pVerts[ index ].x, pObject->pVerts[ index ].y, pObject->pVerts[ index ].z);
  955. }
  956. }
  957. glEnd();
  958. }
  959. glEnable(GL_BLEND);
  960. glEndList();
  961. }
  963. GLdouble Time1;
  964. GLdouble Time2;
  965. GLdouble DiffTime;
  966. GLdouble StartTime;
  967. LPARAM lParam;
  969. int InitGL(GLvoid) // All Setup For OpenGL Goes Here
  970. {
  971. if (!g_LoadMd2.ImportMD2(&g_3DModel, FILE_NAME, TEXTURE_NAME)) // KEY of Clashing
  972.       return false; 
  974. if (!LoadTGA(&textures[0],"Data/Font.TGA")) // Load The Font Texture
  975. {
  976. return false; // If Loading Failed, Return False
  977. }
  979. if (!LoadGLTextures()) // Jump To Texture Loading Routine
  980.       return false;  
  982. //LPARAM lParam;
  983. SetCursorPos(322,240);
  984. float temp_mouse_x = LOWORD(lParam);
  985. float temp_mouse_y = HIWORD(lParam);
  986. SetCursorPos(320,240);
  988. BuildLists();
  989. BuildLists1();
  991. glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
  992. glClearColor(0, 0, 0, 1.0f); // Black Background
  993. glEnable(GL_DEPTH_TEST);
  994. glDepthFunc(GL_LEQUAL);
  995. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
  996. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  998. TimerInit(); //initialize timer
  999. BuildFont();   
  1000. StartTime = TimerGetTime()/1000; 
  1001. return TRUE; // Initialization Went OK
  1003. }
  1006. GLdouble xtrans2 = CELL*5-40.0f;  
  1007. GLdouble ytrans2 = 7;
  1008. GLdouble ztrans2 = CELL*7-40.0f;
  1010. GLdouble xtrans = 0;
  1011. GLdouble ztrans = 0;
  1013. GLdouble yrot=0; // Y Rotation
  1015. const GLdouble piover180 = 0.0174532925f;
  1016. GLdouble XP=0;
  1017. GLdouble ZP=0;
  1019. GLdouble sceneroty;
  1020. GLdouble heading;
  1021. GLdouble _heading = 0;
  1022. GLdouble zprot;
  1024. int frames = 0;
  1026. GLdouble FPS = 0;
  1028. GLdouble fire_x = 0;
  1029. GLdouble fire_y = 10;
  1030. GLdouble fire_xp, fire_yp;
  1031. GLdouble fire_z = 0;
  1032. GLdouble fire_zp = 0;
  1033. GLdouble fire_delay = 0;
  1035. int shots_fired = 0;
  1037. typedef struct // Create A Structure For Particle
  1038. {
  1039. GLdouble life; // Particle Life
  1040. GLdouble fade; // Fade Speed
  1041. GLdouble size; // Fade Speed
  1042. GLdouble triangle_x1; // X vertex
  1043. GLdouble triangle_x2; // X vertex
  1044. GLdouble triangle_x3; // X vertex
  1045. GLdouble triangle_y1; // Y vertex
  1046. GLdouble triangle_y2; // Y vertex
  1047. GLdouble triangle_y3; // Y vertex
  1048. GLdouble triangle_z1; // Z vertex
  1049. GLdouble triangle_z2; // Z vertex
  1050. GLdouble triangle_z3; // Z vertex
  1051. GLdouble triangle_rotate_x; // X Rotate
  1052. GLdouble triangle_rotate_y; // X Rotate
  1053. GLdouble triangle_rotate_z; // X Rotate
  1054. GLdouble triangle_rotate_xi; // X Rotate
  1055. GLdouble triangle_rotate_yi; // X Rotate
  1056. GLdouble triangle_rotate_zi; // X Rotate
  1057. GLdouble x; // X Position
  1058. GLdouble y; // Y Position
  1059. GLdouble z; // Z Position
  1060. GLdouble xi; // X Direction
  1061. GLdouble yi; // Y Direction
  1062. GLdouble zi; // Z Direction
  1063. }
  1064. particles; // Particles Structure
  1066. particles particle[MAX_PARTICLES][MAX_SHOTS_FIRED];
  1068. // Detect collision and reflect movement if collision is detected
  1069. // cx = x position; cy = y position; cz = z position;
  1070. // cxi = x increment; cyi = y increment; czi = z increment;
  1071. // padding = a square border around the object.  your value will be 1/2 the length of one side of the square
  1072. // bounce = bounce coefficient -- 0 = no bounce; 1 = perfect bounce
  1073. inline bool DetectCollision(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1074. {
  1075. bool Status = false;
  1077. if(ztrans2>CELL*6 && ztrans2<CELL*7 && 
  1078. xtrans2>CELL*4 && xtrans2<CELL*5)
  1079. { 
  1080. if (cx > CELL*5-padding) //right
  1081. {
  1082. cx = CELL*5-padding; 
  1083. cxi = -cxi;
  1084. cxi *= bounce; 
  1085. Status = true;
  1086. }
  1088. if (cy > CELL/4-padding) //top
  1089. {
  1090. cy = CELL/4-padding; 
  1091. cyi = -cyi;
  1092. cyi *= bounce; 
  1093. Status = true;
  1094. }
  1095. else if (cy < 0+padding) //bottom
  1096. {
  1097. cy = 0+padding; 
  1098. cyi = -cyi;
  1099. cyi *= bounce; 
  1100. Status = true;
  1101. }
  1103. if (cz > CELL*7-padding) //back
  1104. {
  1105. cz = CELL*7-padding; 
  1106. czi = -czi;
  1107. czi *= bounce; 
  1108. Status = true;
  1109. }
  1110. else if (cz < CELL*6+padding) //front
  1111. {
  1112. cz = CELL*6+padding; 
  1113. czi = -czi;
  1114. czi *= bounce; 
  1115. Status = true;
  1116. }
  1117. }
  1118. else if(ztrans2>CELL*6 && ztrans2<CELL*7 && 
  1119. xtrans2>CELL*3 && xtrans2<CELL*4) 
  1120. {
  1121. if (cx < CELL*3+padding)//left
  1122. {
  1123. cx = CELL*3+padding; 
  1124. cxi = -cxi;
  1125. cxi *= bounce; 
  1126. Status = true;
  1127. }
  1129. if (cy > CELL/4-padding) //top
  1130. {
  1131. cy = CELL/4-padding; 
  1132. cyi = -cyi;
  1133. cyi *= bounce; 
  1134. Status = true;
  1135. }
  1136. else if (cy < 0+padding) //bottom
  1137. {
  1138. cy = 0+padding; 
  1139. cyi = -cyi;
  1140. cyi *= bounce; 
  1141. Status = true;
  1142. }
  1144. if (cz > CELL*7-padding) //back
  1145. {
  1146. cz = CELL*7-padding; 
  1147. czi = -czi;
  1148. czi *= bounce; 
  1149. Status = true;
  1150. } 
  1151. }
  1152. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  1153. xtrans2>CELL*3 && xtrans2<CELL*4) 
  1154. {
  1155. if (cx > CELL*4-padding)//right
  1156. {
  1157. cx = CELL*4-padding; 
  1158. cxi = -cxi;
  1159. cxi *= bounce; 
  1160. Status = true;
  1161. }
  1163. if (cy > CELL/4-padding) //top
  1164. {
  1165. cy = CELL/4-padding; 
  1166. cyi = -cyi;
  1167. cyi *= bounce; 
  1168. Status = true;
  1169. }
  1170. else if (cy < 0+padding) //bottom
  1171. {
  1172. cy = 0+padding; 
  1173. cyi = -cyi;
  1174. cyi *= bounce; 
  1175. Status = true;
  1176. } 
  1177. }
  1178. else if(ztrans2>CELL*4 && ztrans2<CELL*5 && 
  1179. xtrans2>CELL*3 && xtrans2<CELL*4) 
  1180. {
  1181. if (cx < CELL*3+padding)//left
  1182. {
  1183. cx = CELL*3+padding; 
  1184. cxi = -cxi;
  1185. cxi *= bounce; 
  1186. Status = true;
  1187. }
  1188. else if (cx > CELL*4-padding)//right
  1189. {
  1190. cx = CELL*4-padding; 
  1191. cxi = -cxi;
  1192. cxi *= bounce; 
  1193. Status = true;
  1194. }
  1196. if (cy > CELL/4-padding) //top
  1197. {
  1198. cy = CELL/4-padding; 
  1199. cyi = -cyi;
  1200. cyi *= bounce; 
  1201. Status = true;
  1202. }
  1203. else if (cy < 0+padding) //bottom
  1204. {
  1205. cy = 0+padding; 
  1206. cyi = -cyi;
  1207. cyi *= bounce; 
  1208. Status = true;
  1209. }
  1210. }
  1211. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  1212. xtrans2>CELL*3 && xtrans2<CELL*4)
  1213. {
  1214. if (cx > CELL*4-padding)//right
  1215. {
  1216. cx = CELL*4-padding; 
  1217. cxi = -cxi;
  1218. cxi *= bounce; 
  1219. Status = true;
  1220. }
  1222. if (cy > CELL/4-padding) //top
  1223. {
  1224. cy = CELL/4-padding; 
  1225. cyi = -cyi;
  1226. cyi *= bounce; 
  1227. Status = true;
  1228. }
  1229. else if (cy < 0+padding) //bottom
  1230. {
  1231. cy = 0+padding; 
  1232. cyi = -cyi;
  1233. cyi *= bounce; 
  1234. Status = true;
  1235. }
  1237. if (cz < CELL*3+padding) //front
  1238. {
  1239. cz = CELL*3+padding; 
  1240. czi = -czi;
  1241. czi *= bounce; 
  1242. Status = true;
  1243. }
  1244. }
  1245. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  1246. xtrans2>CELL*2 && xtrans2<CELL*3)
  1247. {
  1248. if (cy > CELL/4-padding) //top
  1249. {
  1250. cy = CELL/4-padding; 
  1251. cyi = -cyi;
  1252. cyi *= bounce; 
  1253. Status = true;
  1254. }
  1255. else if (cy < 0+padding) //bottom
  1256. {
  1257. cy = 0+padding; 
  1258. cyi = -cyi;
  1259. cyi *= bounce; 
  1260. Status = true;
  1261. }
  1263. if (cz > CELL*6-padding) //back
  1264. {
  1265. cz = CELL*6-padding; 
  1266. czi = -czi;
  1267. czi *= bounce; 
  1268. Status = true;
  1269. }
  1270. else if (cz < CELL*5+padding) //front
  1271. {
  1272. cz = CELL*5+padding; 
  1273. czi = -czi;
  1274. czi *= bounce; 
  1275. Status = true;
  1276. }
  1277. }
  1278. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  1279. xtrans2>CELL*2 && xtrans2<CELL*3)
  1280. {
  1281. if (cy > CELL/4-padding) //top
  1282. {
  1283. cy = CELL/4-padding; 
  1284. cyi = -cyi;
  1285. cyi *= bounce; 
  1286. Status = true;
  1287. }
  1288. else if (cy < 0+padding) //bottom
  1289. {
  1290. cy = 0+padding; 
  1291. cyi = -cyi;
  1292. cyi *= bounce; 
  1293. Status = true;
  1294. }
  1296. if (cz > CELL*4-padding) //back
  1297. {
  1298. cz = CELL*4-padding; 
  1299. czi = -czi;
  1300. czi *= bounce; 
  1301. Status = true;
  1302. } 
  1303. }
  1304. else if(ztrans2>CELL*2 && ztrans2<CELL*3 && 
  1305. xtrans2>CELL*2 && xtrans2<CELL*3)
  1306. {
  1307. if (cx < CELL*2+padding)//left
  1308. {
  1309. cx = CELL*2+padding; 
  1310. cxi = -cxi;
  1311. cxi *= bounce; 
  1312. Status = true;
  1313. }
  1314. else if (cx > CELL*3-padding)//right
  1315. {
  1316. cx = CELL*3-padding; 
  1317. cxi = -cxi;
  1318. cxi *= bounce; 
  1319. Status = true;
  1320. }
  1322. if (cy > CELL/4-padding) //top
  1323. {
  1324. cy = CELL/4-padding; 
  1325. cyi = -cyi;
  1326. cyi *= bounce; 
  1327. Status = true;
  1328. }
  1329. else if (cy < 0+padding) //bottom
  1330. {
  1331. cy = 0+padding; 
  1332. cyi = -cyi;
  1333. cyi *= bounce; 
  1334. Status = true;
  1335. }
  1336. }
  1337. else if(ztrans2>CELL && ztrans2<CELL*2 && 
  1338. xtrans2>CELL*2 && xtrans2<CELL*3)
  1339. {
  1340. if (cx < CELL*2+padding)//left
  1341. {
  1342. cx = CELL*2+padding; 
  1343. cxi = -cxi;
  1344. cxi *= bounce; 
  1345. Status = true;
  1346. }
  1347. else if (cx > CELL*3-padding)//right
  1348. {
  1349. cx = CELL*3-padding; 
  1350. cxi = -cxi;
  1351. cxi *= bounce; 
  1352. Status = true;
  1353. }
  1355. if (cy > CELL/4-padding) //top
  1356. {
  1357. cy = CELL/4-padding; 
  1358. cyi = -cyi;
  1359. cyi *= bounce; 
  1360. Status = true;
  1361. }
  1362. else if (cy < 0+padding) //bottom
  1363. {
  1364. cy = 0+padding; 
  1365. cyi = -cyi;
  1366. cyi *= bounce; 
  1367. Status = true;
  1368. }
  1370. if (cz < CELL+padding) //front
  1371. {
  1372. cz = CELL+padding; 
  1373. czi = -czi;
  1374. czi *= bounce; 
  1375. Status = true;
  1376. }
  1377. }
  1378. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  1379. xtrans2>CELL && xtrans2<CELL*2)
  1380. {
  1381. if (cy > CELL/4-padding) //top
  1382. {
  1383. cy = CELL/4-padding; 
  1384. cyi = -cyi;
  1385. cyi *= bounce; 
  1386. Status = true;
  1387. }
  1388. else if (cy < 0+padding) //bottom
  1389. {
  1390. cy = 0+padding; 
  1391. cyi = -cyi;
  1392. cyi *= bounce; 
  1393. Status = true;
  1394. }
  1396. if (cz > CELL*6-padding) //back
  1397. {
  1398. cz = CELL*6-padding; 
  1399. czi = -czi;
  1400. czi *= bounce; 
  1401. Status = true;
  1402. }
  1403. else if (cz < CELL*5+padding) //front
  1404. {
  1405. cz = CELL*5+padding; 
  1406. czi = -czi;
  1407. czi *= bounce; 
  1408. Status = true;
  1409. }
  1410. }
  1411. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  1412. xtrans2>CELL && xtrans2<CELL*2)
  1413. {
  1414. if (cy > CELL/4-padding) //top
  1415. {
  1416. cy = CELL/4-padding; 
  1417. cyi = -cyi;
  1418. cyi *= bounce; 
  1419. Status = true;
  1420. }
  1421. else if (cy < 0+padding) //bottom
  1422. {
  1423. cy = 0+padding; 
  1424. cyi = -cyi;
  1425. cyi *= bounce; 
  1426. Status = true;
  1427. }
  1429. if (cz > CELL*4-padding) //back
  1430. {
  1431. cz = CELL*4-padding; 
  1432. czi = -czi;
  1433. czi *= bounce; 
  1434. Status = true;
  1435. }
  1436. else if (cz < CELL*3+padding) //front
  1437. {
  1438. cz = CELL*3+padding; 
  1439. czi = -czi;
  1440. czi *= bounce; 
  1441. Status = true;
  1442. }
  1443. }
  1444. else if(ztrans2>CELL && ztrans2<CELL*2 && 
  1445. xtrans2>CELL && xtrans2<CELL*2)
  1446. {
  1447. if (cx > CELL*2-padding) //right
  1448. {
  1449. cx = CELL*2-padding; 
  1450. cxi = -cxi;
  1451. cxi *= bounce; 
  1452. Status = true;
  1453. }
  1455. if (cy > CELL/4-padding) //top
  1456. {
  1457. cy = CELL/4-padding; 
  1458. cyi = -cyi;
  1459. cyi *= bounce; 
  1460. Status = true;
  1461. }
  1462. else if (cy < 0+padding) //bottom
  1463. {
  1464. cy = 0+padding; 
  1465. cyi = -cyi;
  1466. cyi *= bounce; 
  1467. Status = true;
  1468. }
  1470. if (cz > CELL*2-padding) //back
  1471. {
  1472. cz = CELL*2-padding; 
  1473. czi = -czi;
  1474. czi *= bounce; 
  1475. Status = true;
  1476. } 
  1477. }
  1478. else if(ztrans2>0 && ztrans2<CELL && 
  1479. xtrans2>CELL && xtrans2<CELL*2)
  1480. {
  1481. if (cx < CELL+padding)//left
  1482. {
  1483. cx = CELL+padding; 
  1484. cxi = -cxi;
  1485. cxi *= bounce; 
  1486. Status = true;
  1487. }
  1488. else if (cx > CELL*2-padding)//right
  1489. {
  1490. cx = CELL*2-padding; 
  1491. cxi = -cxi;
  1492. cxi *= bounce; 
  1493. Status = true;
  1494. }
  1496. if (cy > CELL/4-padding) //top
  1497. {
  1498. cy = CELL/4-padding; 
  1499. cyi = -cyi;
  1500. cyi *= bounce; 
  1501. Status = true;
  1502. }
  1503. else if (cy < 0+padding) //bottom
  1504. {
  1505. cy = 0+padding; 
  1506. cyi = -cyi;
  1507. cyi *= bounce; 
  1508. Status = true;
  1509. } 
  1511. if (cz < 0+padding && 
  1512. (cx < CELL*1+CELL*3/8+padding || 
  1513. cx > CELL*2-CELL*3/8-padding)) //[4 7]front door
  1514. {
  1515. cz = 0+padding;
  1516. czi = -czi;
  1517. czi *= bounce; 
  1518. Status = true;
  1519. }
  1520. }
  1521. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  1522. xtrans2>0 && xtrans2<CELL)
  1523. {
  1524. if (cx < 0+padding) //left
  1525. {
  1526. cx = 0+padding; 
  1527. cxi = -cxi;
  1528. cxi *= bounce; 
  1529. Status = true;
  1530. }
  1532. if (cy > CELL/4-padding) //top
  1533. {
  1534. cy = CELL/4-padding; 
  1535. cyi = -cyi;
  1536. cyi *= bounce; 
  1537. Status = true;
  1538. }
  1539. else if (cy < 0+padding) //bottom
  1540. {
  1541. cy = 0+padding; 
  1542. cyi = -cyi;
  1543. cyi *= bounce; 
  1544. Status = true;
  1545. }
  1547. if (cz > CELL*6-padding) //back
  1548. {
  1549. cz = CELL*6-padding; 
  1550. czi = -czi;
  1551. czi *= bounce; 
  1552. Status = true;
  1553. } 
  1554. }
  1555. else if(ztrans2>CELL*4 && ztrans2<CELL*5 && 
  1556. xtrans2>0 && xtrans2<CELL)
  1557. {
  1558. if (cx < 0+padding)//left
  1559. {
  1560. cx = 0+padding; 
  1561. cxi = -cxi;
  1562. cxi *= bounce; 
  1563. Status = true;
  1564. }
  1565. else if (cx > CELL-padding)//right
  1566. {
  1567. cx = CELL-padding; 
  1568. cxi = -cxi;
  1569. cxi *= bounce; 
  1570. Status = true;
  1571. }
  1573. if (cy > CELL/4-padding) //top
  1574. {
  1575. cy = CELL/4-padding; 
  1576. cyi = -cyi;
  1577. cyi *= bounce; 
  1578. Status = true;
  1579. }
  1580. else if (cy < 0+padding) //bottom
  1581. {
  1582. cy = 0+padding; 
  1583. cyi = -cyi;
  1584. cyi *= bounce; 
  1585. Status = true;
  1586. }
  1588. if (cz < CELL*4+padding) //front
  1589. {
  1590. cz = CELL*4+padding; 
  1591. czi = -czi;
  1592. czi *= bounce; 
  1593. Status = true;
  1594. }
  1595. }
  1596. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  1597. xtrans2>0 && xtrans2<CELL)
  1598. {
  1599. if (cx < 0+padding) //left
  1600. {
  1601. cx = 0+padding; 
  1602. cxi = -cxi;
  1603. cxi *= bounce; 
  1604. Status = true;
  1605. }
  1607. if (cy > CELL/4-padding) //top
  1608. {
  1609. cy = CELL/4-padding; 
  1610. cyi = -cyi;
  1611. cyi *= bounce; 
  1612. Status = true;
  1613. }
  1614. else if (cy < 0+padding) //bottom
  1615. {
  1616. cy = 0+padding; 
  1617. cyi = -cyi;
  1618. cyi *= bounce; 
  1619. Status = true;
  1620. }
  1622. if (cz > CELL*4-padding) //back
  1623. {
  1624. cz = CELL*4-padding; 
  1625. czi = -czi;
  1626. czi *= bounce; 
  1627. Status = true;
  1628. }
  1629. }
  1630. else if(ztrans2>CELL*2 && ztrans2<CELL*3 && 
  1631. xtrans2>0 && xtrans2<CELL)
  1632. {
  1633. if (cx < 0+padding)//left
  1634. {
  1635. cx = 0+padding; 
  1636. cxi = -cxi;
  1637. cxi *= bounce; 
  1638. Status = true;
  1639. }
  1640. else if (cx > CELL-padding)//right
  1641. {
  1642. cx = CELL-padding; 
  1643. cxi = -cxi;
  1644. cxi *= bounce; 
  1645. Status = true;
  1646. }
  1648. if (cy > CELL/4-padding) //top
  1649. {
  1650. cy = CELL/4-padding; 
  1651. cyi = -cyi;
  1652. cyi *= bounce; 
  1653. Status = true;
  1654. }
  1655. else if (cy < 0+padding) //bottom
  1656. {
  1657. cy = 0+padding; 
  1658. cyi = -cyi;
  1659. cyi *= bounce; 
  1660. Status = true;
  1661. }
  1662. }
  1663. else if(ztrans2>CELL && ztrans2<CELL*2 && 
  1664. xtrans2>0 && xtrans2<CELL)
  1665. {
  1666. if (cx < 0+padding)//left
  1667. {
  1668. cx = 0+padding; 
  1669. cxi = -cxi;
  1670. cxi *= bounce; 
  1671. Status = true;
  1672. }
  1674. if (cy > CELL/4-padding) //top
  1675. {
  1676. cy = CELL/4-padding; 
  1677. cyi = -cyi;
  1678. cyi *= bounce; 
  1679. Status = true;
  1680. }
  1681. else if (cy < 0+padding) //bottom
  1682. {
  1683. cy = 0+padding; 
  1684. cyi = -cyi;
  1685. cyi *= bounce; 
  1686. Status = true;
  1687. }
  1689. if (cz < CELL+padding) //front
  1690. {
  1691. cz = CELL+padding; 
  1692. czi = -czi;
  1693. czi *= bounce; 
  1694. Status = true;
  1695. }
  1696. }
  1697. return Status;
  1698. }
  1700. inline bool DetectPartCollision(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1701. {
  1702. bool Status = false;
  1704. if( xtrans2 > CELL*3 && xtrans2 < CELL*5 &&
  1705. ztrans2 > CELL*6 && ztrans2 < CELL*7 ) //[11][21]
  1706. {
  1707. if (cx > CELL*5-padding) //right
  1708. {
  1709. cx = CELL*5-padding; 
  1710. cxi = -cxi;
  1711. cxi *= bounce; 
  1712. Status = true;
  1713. }
  1714. else if (cx < CELL*3+padding)//left
  1715. {
  1716. cx = CELL*3+padding; 
  1717. cxi = -cxi;
  1718. cxi *= bounce; 
  1719. Status = true;
  1720. }
  1722. if (cy > CELL/4-padding) //top
  1723. {
  1724. cy = CELL/4-padding; 
  1725. cyi = -cyi;
  1726. cyi *= bounce; 
  1727. Status = true;
  1728. }
  1729. else if (cy < 0+padding) //bottom
  1730. {
  1731. cy = 0+padding; 
  1732. cyi = -cyi;
  1733. cyi *= bounce; 
  1734. Status = true;
  1735. }
  1737. if (cz > CELL*7-padding) //back
  1738. {
  1739. cz = CELL*7-padding; 
  1740. czi = -czi;
  1741. czi *= bounce; 
  1742. Status = true;
  1743. }
  1744. else if (cz < CELL*6+padding) //front
  1745. {
  1746. cz = CELL*6+padding; 
  1747. czi = -czi;
  1748. czi *= bounce; 
  1749. Status = true;
  1750. }
  1751. }
  1752. else if( xtrans2 > 0 && xtrans2 < CELL*4 &&
  1753. ztrans2 > CELL*5 && ztrans2 < CELL*6 ) //[22][32][42][52]
  1754. {
  1755. if (cx > CELL*4-padding) //right
  1756. {
  1757. cx = CELL*4-padding; 
  1758. cxi = -cxi;
  1759. cxi *= bounce; 
  1760. Status = true;
  1761. }
  1762. else if (cx < 0+padding)//left
  1763. {
  1764. cx = 0+padding; 
  1765. cxi = -cxi;
  1766. cxi *= bounce; 
  1767. Status = true;
  1768. }
  1770. if (cy > CELL/4-padding) //top
  1771. {
  1772. cy = CELL/4-padding; 
  1773. cyi = -cyi;
  1774. cyi *= bounce; 
  1775. Status = true;
  1776. }
  1777. else if (cy < 0+padding) //bottom
  1778. {
  1779. cy = 0+padding; 
  1780. cyi = -cyi;
  1781. cyi *= bounce; 
  1782. Status = true;
  1783. }
  1785. if (cz > CELL*6-padding) //back
  1786. {
  1787. cz = CELL*6-padding; 
  1788. czi = -czi;
  1789. czi *= bounce; 
  1790. Status = true;
  1791. }
  1792. else if (cz < CELL*5+padding) //front
  1793. {
  1794. cz = CELL*5+padding; 
  1795. czi = -czi;
  1796. czi *= bounce; 
  1797. Status = true;
  1798. }
  1799. }
  1801. else if( xtrans2 > CELL*3 && xtrans2 < CELL*4 &&
  1802. ztrans2 > CELL*3 && ztrans2 < CELL*5 ) //[23][24]
  1803. {
  1804. if (cx > CELL*4-padding) //right
  1805. {
  1806. cx = CELL*4-padding; 
  1807. cxi = -cxi;
  1808. cxi *= bounce; 
  1809. Status = true;
  1810. }
  1811. else if (cx < CELL*3+padding)//left
  1812. {
  1813. cx = CELL*3+padding; 
  1814. cxi = -cxi;
  1815. cxi *= bounce; 
  1816. Status = true;
  1817. }
  1819. if (cy > CELL/4-padding) //top
  1820. {
  1821. cy = CELL/4-padding; 
  1822. cyi = -cyi;
  1823. cyi *= bounce; 
  1824. Status = true;
  1825. }
  1826. else if (cy < 0+padding) //bottom
  1827. {
  1828. cy = 0+padding; 
  1829. cyi = -cyi;
  1830. cyi *= bounce; 
  1831. Status = true;
  1832. }
  1834. if (cz > CELL*5-padding) //back
  1835. {
  1836. cz = CELL*5-padding; 
  1837. czi = -czi;
  1838. czi *= bounce; 
  1839. Status = true;
  1840. }
  1841. else if (cz < CELL*3+padding) //front
  1842. {
  1843. cz = CELL*3+padding; 
  1844. czi = -czi;
  1845. czi *= bounce; 
  1846. Status = true;
  1847. }
  1848. }
  1850. else if( xtrans2 > 0 && xtrans2 < CELL &&
  1851. ztrans2 > CELL*4 && ztrans2 < CELL*5 ) //[53]
  1852. {
  1853. if (cx > CELL-padding) //right
  1854. {
  1855. cx = CELL-padding; 
  1856. cxi = -cxi;
  1857. cxi *= bounce; 
  1858. Status = true;
  1859. }
  1860. else if (cx < 0+padding)//left
  1861. {
  1862. cx = 0+padding; 
  1863. cxi = -cxi;
  1864. cxi *= bounce; 
  1865. Status = true;
  1866. }
  1868. if (cy > CELL/4-padding) //top
  1869. {
  1870. cy = CELL/4-padding; 
  1871. cyi = -cyi;
  1872. cyi *= bounce; 
  1873. Status = true;
  1874. }
  1875. else if (cy < 0+padding) //bottom
  1876. {
  1877. cy = 0+padding; 
  1878. cyi = -cyi;
  1879. cyi *= bounce; 
  1880. Status = true;
  1881. }
  1883. if (cz > CELL*5-padding) //back
  1884. {
  1885. cz = CELL*5-padding; 
  1886. czi = -czi;
  1887. czi *= bounce; 
  1888. Status = true;
  1889. }
  1890. else if (cz < CELL*4+padding) //front
  1891. {
  1892. cz = CELL*4+padding; 
  1893. czi = -czi;
  1894. czi *= bounce; 
  1895. Status = true;
  1896. }
  1897. }
  1899. else if( xtrans2 > CELL*2 && xtrans2 < CELL*3 &&
  1900. ztrans2 > CELL && ztrans2 < CELL*4 ) //[34][35][36]
  1901. {
  1902. if (cx > CELL*3-padding) //right
  1903. {
  1904. cx = CELL*3-padding; 
  1905. cxi = -cxi;
  1906. cxi *= bounce; 
  1907. Status = true;
  1908. }
  1909. else if (cx < CELL*2+padding)//left
  1910. {
  1911. cx = CELL*2+padding; 
  1912. cxi = -cxi;
  1913. cxi *= bounce; 
  1914. Status = true;
  1915. }
  1917. if (cy > CELL/4-padding) //top
  1918. {
  1919. cy = CELL/4-padding; 
  1920. cyi = -cyi;
  1921. cyi *= bounce; 
  1922. Status = true;
  1923. }
  1924. else if (cy < 0+padding) //bottom
  1925. {
  1926. cy = 0+padding; 
  1927. cyi = -cyi;
  1928. cyi *= bounce; 
  1929. Status = true;
  1930. }
  1932. if (cz > CELL*4-padding) //back
  1933. {
  1934. cz = CELL*4-padding; 
  1935. czi = -czi;
  1936. czi *= bounce; 
  1937. Status = true;
  1938. }
  1939. else if (cz < CELL+padding) //front
  1940. {
  1941. cz = CELL+padding; 
  1942. czi = -czi;
  1943. czi *= bounce; 
  1944. Status = true;
  1945. }
  1946. }
  1948. else if( xtrans2 > CELL && xtrans2 < CELL*2 &&
  1949. ztrans2 > CELL*3 && ztrans2 < CELL*4 ) //[44]
  1950. {
  1951. if (cx > CELL*2-padding) //right
  1952. {
  1953. cx = CELL*2-padding; 
  1954. cxi = -cxi;
  1955. cxi *= bounce; 
  1956. Status = true;
  1957. }
  1958. else if (cx < CELL+padding)//left
  1959. {
  1960. cx = CELL+padding; 
  1961. cxi = -cxi;
  1962. cxi *= bounce; 
  1963. Status = true;
  1964. }
  1966. if (cy > CELL/4-padding) //top
  1967. {
  1968. cy = CELL/4-padding; 
  1969. cyi = -cyi;
  1970. cyi *= bounce; 
  1971. Status = true;
  1972. }
  1973. else if (cy < 0+padding) //bottom
  1974. {
  1975. cy = 0+padding; 
  1976. cyi = -cyi;
  1977. cyi *= bounce; 
  1978. Status = true;
  1979. }
  1981. if (cz > CELL*4-padding) //back
  1982. {
  1983. cz = CELL*4-padding; 
  1984. czi = -czi;
  1985. czi *= bounce; 
  1986. Status = true;
  1987. }
  1988. else if (cz < CELL*3+padding) //front
  1989. {
  1990. cz = CELL*3+padding; 
  1991. czi = -czi;
  1992. czi *= bounce; 
  1993. Status = true;
  1994. }
  1995. }
  1997. else if( xtrans2 > 0 && xtrans2 < CELL &&
  1998. ztrans2 > CELL && ztrans2 < CELL*4 ) //[54][55][56]
  1999. {
  2000. if (cx > CELL-padding) //right
  2001. {
  2002. cx = CELL-padding; 
  2003. cxi = -cxi;
  2004. cxi *= bounce; 
  2005. Status = true;
  2006. }
  2007. else if (cx < 0+padding)//left
  2008. {
  2009. cx = 0+padding; 
  2010. cxi = -cxi;
  2011. cxi *= bounce; 
  2012. Status = true;
  2013. }
  2015. if (cy > CELL/4-padding) //top
  2016. {
  2017. cy = CELL/4-padding; 
  2018. cyi = -cyi;
  2019. cyi *= bounce; 
  2020. Status = true;
  2021. }
  2022. else if (cy < 0+padding) //bottom
  2023. {
  2024. cy = 0+padding; 
  2025. cyi = -cyi;
  2026. cyi *= bounce; 
  2027. Status = true;
  2028. }
  2030. if (cz > CELL*4-padding) //back
  2031. {
  2032. cz = CELL*4-padding; 
  2033. czi = -czi;
  2034. czi *= bounce; 
  2035. Status = true;
  2036. }
  2037. else if (cz < CELL+padding) //front
  2038. {
  2039. cz = CELL+padding; 
  2040. czi = -czi;
  2041. czi *= bounce; 
  2042. Status = true;
  2043. }
  2044. }
  2046. else if( xtrans2 > CELL && xtrans2 < CELL*2 &&
  2047. ztrans2 > 0 && ztrans2 < CELL*2 ) //[46][47]
  2048. {
  2049. if (cx > CELL*2-padding) //right
  2050. {
  2051. cx = CELL*2-padding; 
  2052. cxi = -cxi;
  2053. cxi *= bounce; 
  2054. Status = true;
  2055. }
  2056. else if (cx < CELL+padding)//left
  2057. {
  2058. cx = CELL+padding; 
  2059. cxi = -cxi;
  2060. cxi *= bounce; 
  2061. Status = true;
  2062. }
  2064. if (cy > CELL/4-padding) //top
  2065. {
  2066. cy = CELL/4-padding; 
  2067. cyi = -cyi;
  2068. cyi *= bounce; 
  2069. Status = true;
  2070. }
  2071. else if (cy < 0+padding) //bottom
  2072. {
  2073. cy = 0+padding; 
  2074. cyi = -cyi;
  2075. cyi *= bounce; 
  2076. Status = true;
  2077. }
  2079. if (cz > CELL*2-padding) //back
  2080. {
  2081. cz = CELL*2-padding; 
  2082. czi = -czi;
  2083. czi *= bounce; 
  2084. Status = true;
  2085. }
  2086. else if (cz < 0+padding) //front
  2087. {
  2088. cz = 0+padding; 
  2089. czi = -czi;
  2090. czi *= bounce; 
  2091. Status = true;
  2092. }
  2093. }
  2095.   return Status;
  2096. }
  2098. inline void Ricochet()
  2099. {
  2100.   int i;
  2101.   
  2102.   for (i = 0; i < MAX_PARTICLES; i++)
  2103.   {
  2104.     if (i == 0)
  2105.       particle[i][shots_fired].size = 2;
  2106.     else
  2107.       particle[i][shots_fired].size = GLdouble((rand()%25)+25)/50;
  2108.     
  2109.     particle[i][shots_fired].triangle_x1 = GLdouble((rand()%50)-25)/75.f;
  2110.     particle[i][shots_fired].triangle_x2 = GLdouble((rand()%50)-25)/75.f;
  2111.     particle[i][shots_fired].triangle_x3 = GLdouble((rand()%50)-25)/75.f;
  2113.     particle[i][shots_fired].triangle_y1 = GLdouble((rand()%50)-25)/75.f;
  2114.     particle[i][shots_fired].triangle_y2 = GLdouble((rand()%50)-25)/75.f;
  2115.     particle[i][shots_fired].triangle_y3 = GLdouble((rand()%50)-25)/75.f;
  2116.     
  2117.     particle[i][shots_fired].triangle_z1 = GLdouble((rand()%50)-25)/75.f;
  2118.     particle[i][shots_fired].triangle_z2 = GLdouble((rand()%50)-25)/75.f;
  2119.     particle[i][shots_fired].triangle_z3 = GLdouble((rand()%50)-25)/75.f;
  2121.     particle[i][shots_fired].triangle_rotate_x = rand()%360;
  2122.     particle[i][shots_fired].triangle_rotate_y = rand()%360;
  2123.     particle[i][shots_fired].triangle_rotate_z = rand()%360;
  2125.     particle[i][shots_fired].triangle_rotate_xi = GLdouble((rand()%50)-25)/5;
  2126.     particle[i][shots_fired].triangle_rotate_yi = GLdouble((rand()%50)-25)/5;
  2127.     particle[i][shots_fired].triangle_rotate_zi = GLdouble((rand()%50)-25)/5;
  2129.     particle[i][shots_fired].life = 1;
  2130.     particle[i][shots_fired].fade = GLdouble(rand()%100)/5000 + .02f;
  2131.     particle[i][shots_fired].x = fire_x;
  2132.     particle[i][shots_fired].y = fire_y;
  2133.     particle[i][shots_fired].z = fire_z;
  2134.     GLdouble angle = rand()%360;
  2135.     GLdouble angle2 = rand()%360;
  2136.     GLdouble speed = GLdouble(rand()%100) / 500;
  2137.     GLdouble Hyp = Hypot(angle,angle2);
  2139.     particle[i][shots_fired].xi = sin(Hypot(angle,Hyp))*speed + fire_xp;
  2140.     particle[i][shots_fired].yi = cos(Hypot(angle,Hyp))*speed + fire_yp;
  2141.     particle[i][shots_fired].zi = cos(Hypot(angle2,Hyp))*speed + fire_zp;
  2142.   }
  2143. }
  2146. int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
  2147. {
  2148.   glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); // Clear The Screen And The Depth Buffer
  2150.   if(getOut == false && gameOver == false)
  2151.   {
  2152. XP *= 0.8f; 
  2153. ZP *= 0.8f; 
  2154. xtrans2 += XP/10;
  2155. ztrans2 += ZP/10;
  2157. xtrans = -xtrans2;
  2158. ztrans = -ztrans2;
  2159.  
  2160. DetectCollision(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2162. zprot*=.9f;
  2163. _heading += zprot;
  2164. heading = mouse_3d_x + _heading;
  2165.     
  2166. yrot = heading;
  2168. sceneroty = 360.0f - yrot;
  2170. glLoadIdentity();
  2171. m16_kicki += -m16_kick/50;
  2172. m16_kick += m16_kicki/10;
  2173. m16_kicki *= .8f;
  2174. m16_kick *= .9f;
  2175. if (m16_kick != 0)
  2176. {
  2177. glRotated(-m16_kick,1,0,0);
  2178. glTranslatef(0,0,-m16_kick);
  2179. }
  2181. glLoadIdentity();
  2182. glRotated(mouse_3d_y,1.f,0,0);
  2183. glRotated(sceneroty,0,1.f,0); 
  2184. glTranslated(xtrans, -25 ,ztrans); // Player position
  2186. glDisable(GL_BLEND);
  2187. for(int i=0; i<18; i++)
  2188. {
  2189. glCallList(ROOM[i]);
  2190. }
  2191. glEnable(GL_BLEND);
  2192. //******************************* first ***************************************************
  2193.   if(xtrans2 > CELL*3 && xtrans2 < CELL*5 &&
  2194.   ztrans2 > CELL*6 && ztrans2 < CELL*7 )
  2195.   {   
  2196.   firstTrigger = true;
  2197.   }else
  2198.   {
  2199.   firstTrigger = false;
  2200.   if(firstHitStatus == false)//re-init
  2201.   {
  2202.   firstHitCount = 0; 
  2203.   firstTransX   = CELL*4+20.0f;
  2204.   firstTransZ   = CELL*6+20.0f;
  2205.   }
  2206.   }
  2208. if(firstTrigger == true )
  2209. {   
  2210. if(firstHitStatus == false)
  2211. {
  2212. glPushMatrix();
  2213. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2214.   
  2215. if((xtrans2 - firstTransX) > 15) //if on the left, move towards right
  2216. {
  2217. firstTransXi += 0.001f; 
  2218. }else if((firstTransX - xtrans2) > 15) //if on the right, move towards left
  2219. {
  2220. firstTransXi -= 0.001f; 
  2221. }else
  2222. {
  2223. firstTransXi = 0.0f; 
  2224. }
  2225. firstTransX += firstTransXi;
  2226. glTranslatef(firstTransX, 0, 0);
  2228. if((ztrans2 - firstTransZ) > 15) //if on the front, move forwards 
  2229. {
  2230. firstTransZi += 0.001f; 
  2231. }else if((firstTransZ - ztrans2) > 15) //if on the back, move backwards
  2232. {
  2233. firstTransZi -= 0.001f; 
  2234. }else
  2235. {
  2236. firstTransZi = 0.0f; 
  2237. } 
  2238. firstTransZ += firstTransZi;
  2239. glTranslatef( 0, 0, firstTransZ);
  2241. // If the monster approach to player
  2242. if( ABS(xtrans2-firstTransX) < 15 
  2243. && ABS(ztrans2-firstTransZ) < 15 )
  2244. gameOver = true;
  2245. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** //////////////////// 
  2246. firstRotateX = atan ( (ztrans2 - firstTransZ) / (xtrans2 - firstTransX + 0.5f) ) / piover180;
  2247.   
  2248. //if degree is in 3rd quadrant
  2249. if( (ztrans2 - firstTransZ) < 0.0f && (xtrans2 - firstTransX) < 0.0f ) 
  2250. {
  2251. if(firstRotateX < 15.0f)
  2252. firstMult = 135.0f;
  2253. else if(firstRotateX > 15.0f && firstRotateX < 30.0f)
  2254. firstMult = 110.0f;
  2255. else if(firstRotateX > 30.0f && firstRotateX < 45.0f)
  2256. firstMult = 85.0f;
  2257. else if(firstRotateX > 45.0f && firstRotateX < 60.0f)
  2258. firstMult = 60.0f;
  2259. else if(firstRotateX > 60.0f && firstRotateX < 75.0f)
  2260. firstMult = 35.0f;
  2261. else
  2262. firstMult = 10.0f;
  2263. }
  2264. //if degree is in 2nd quadrant(z=+;x=-)
  2265. else if( (xtrans2 - firstTransX) < 0.0f &&  (ztrans2 - firstTransZ) > 0.0f) 
  2266. {
  2267. if(firstRotateX > -15.0f)
  2268. firstMult = -165.0f;
  2269. else if(firstRotateX > -30.0f && firstRotateX < -15.0f)
  2270. firstMult = -140.0f;
  2271. else if(firstRotateX > -45.0f && firstRotateX < -30.0f)
  2272. firstMult = -115.0f;
  2273. else if(firstRotateX > -60.0f && firstRotateX < -45.0f)
  2274. firstMult = -90.0f;
  2275. else if(firstRotateX > -75.0f && firstRotateX < -60.0f)
  2276. firstMult = -65.0f;
  2277. else
  2278. firstMult = -40.0f;
  2279. //firstMult = -135.0f * firstRotateX/90.0f -150.0f;
  2280. }
  2281. //if degree is in 4th quadrant(z=-;x=+)
  2282. else if( (xtrans2 - firstTransX) > 0.0f &&  (ztrans2 - firstTransZ) < 0.0f) 
  2283. {
  2284. if(firstRotateX > -15.0f)
  2285. firstMult = 20.0f;
  2286. else if(firstRotateX > -30.0f && firstRotateX < -15.0f)
  2287. firstMult = 40.0f;
  2288. else if(firstRotateX > -45.0f && firstRotateX < -30.0f)
  2289. firstMult = 60.0f;
  2290. else if(firstRotateX > -60.0f && firstRotateX < -45.0f)
  2291. firstMult = 80.0f;
  2292. else if(firstRotateX > -75.0f && firstRotateX < -60.0f)
  2293. firstMult = 100.0f;
  2294. else
  2295. firstMult = 140.0f;
  2296. //firstMult =   -45.0f * firstRotateX/90.0f + 15.0f;
  2297. }
  2298. //if degree is in 1st quadrant
  2299. else
  2300. {
  2301. firstMult = -165.0f * firstRotateX/90.0f - 15.0f; 
  2302. }
  2304. glRotatef(firstMult + firstRotateX, 0.0f, 1.0f, 0.0f); // Face the player around the Y-Axis
  2305. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2306. if( ( ( atan((firstTransZ - fire_z)/(firstTransX - fire_x + 0.5f)) 
  2307. - atan((ztrans2 -firstTransZ)/(xtrans2 - firstTransX + 0.5f)) < 0.0873*2 
  2308. && //10 degrees in radian
  2309. atan((firstTransZ - fire_z)/(firstTransX - fire_x + 0.5f))
  2310. - atan((ztrans2 -firstTransZ)/(xtrans2 - firstTransX + 0.5f)) > -0.0873*2 
  2311.   ) &&
  2312. isFire == true 
  2313. &&
  2314.   ( (ztrans2 > firstTransZ && firstTransZ > fire_z) ||
  2315. (ztrans2 < firstTransZ && firstTransZ < fire_z) 
  2316.   ) &&
  2317.   ( (xtrans2 > firstTransX && firstTransX > fire_x) ||
  2318. (xtrans2 < firstTransX && firstTransX < fire_x) 
  2319.   )
  2320. ) 
  2321. || //second condition
  2322. ( ( atan((firstTransZ - fire_z)/(firstTransX - fire_x + 0.5f)) 
  2323. - atan((ztrans2 -firstTransZ)/(xtrans2 - firstTransX + 0.5f)) > 0.0873*33 
  2324. || //165 degrees in radian
  2325. atan((firstTransZ - fire_z)/(firstTransX - fire_x + 0.5f))
  2326. - atan((ztrans2 -firstTransZ)/(xtrans2 - firstTransX + 0.5f)) < -0.0873*33 
  2327.    ) && //-165 degrees in radian
  2328.  isFire == true 
  2329. )
  2330.   )
  2331. {
  2332. firstHitCount += 1;
  2333. if( firstHitCount == 3)
  2334. { 
  2335. firstHitStatus = true;
  2336. point += 10;
  2337. }
  2338. }
  2340. glTranslatef( 0, 25.0f, 0); //move the model upwards
  2341. glCallList(MODEL);
  2342. glPopMatrix();
  2343. }
  2344. else
  2345. { 
  2346. glTranslatef( firstTransX, 15.0f, firstTransZ);
  2347. glRotatef(firstMult + firstRotateX, 0.0f, 1.0f, 0.0f);
  2348.   
  2349. if(ABS(firstRotateY) < 89.0f)
  2350. {
  2351. firstRotateYi += 0.1f;
  2352. }else
  2353. {
  2354. firstRotateYi = 0.0f;
  2355. }  
  2356. firstRotateY += firstRotateYi;  
  2357. glRotatef(firstRotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  2359. glCallList(MODEL);
  2360. }
  2361. }
  2362. //******************************* second ***************************************************
  2363. if(xtrans2 > 0 && xtrans2 < CELL*4 &&
  2364. ztrans2 > CELL*5 && ztrans2 < CELL*6 )
  2365. {   
  2366.   secondTrigger = true;
  2367. }else
  2368. {
  2369.   secondTrigger = false;
  2370.   if(secondHitStatus == false)//re-init
  2371.   {
  2372.   secondHitCount = 0; 
  2373.   secondTransX   = CELL*2+20.0f;
  2374.   secondTransZ   = CELL*5+20.0f;
  2375.   }
  2376. }
  2378. if(secondTrigger == true )
  2379. {   
  2380. if(secondHitStatus == false)
  2381. {
  2382. glPushMatrix();
  2383. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2384.   
  2385. if((xtrans2 - secondTransX) > 15) //if on the left, move towards right
  2386. {
  2387. secondTransXi += 0.001f; 
  2388. }else if((secondTransX - xtrans2) > 15) //if on the right, move towards left
  2389. {
  2390. secondTransXi -= 0.001f; 
  2391. }else
  2392. {
  2393. secondTransXi = 0.0f; 
  2394. }
  2395. secondTransX += secondTransXi;
  2396. glTranslatef(secondTransX, 0, 0);
  2398. if((ztrans2 - secondTransZ) > 15) //if on the front, move forwards 
  2399. {
  2400. secondTransZi += 0.001f; 
  2401. }else if((secondTransZ - ztrans2) > 15) //if on the back, move backwards
  2402. {
  2403. secondTransZi -= 0.001f; 
  2404. }else
  2405. {
  2406. secondTransZi = 0.0f; 
  2407. } 
  2408. secondTransZ += secondTransZi;
  2409. glTranslatef( 0, 0, secondTransZ);
  2411. // If the monster approach to player
  2412. if( ABS(xtrans2-secondTransX) < 15 
  2413. && ABS(ztrans2-secondTransZ) < 15 )
  2414. gameOver = true;
  2415. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** //////////////////// 
  2416. secondRotateX = atan ( (ztrans2 - secondTransZ) / (xtrans2 - secondTransX + 0.5f) ) / piover180;
  2417.   
  2418. //if degree is in 3rd quadrant
  2419. if( (ztrans2 - secondTransZ) < 0.0f && (xtrans2 - secondTransX) < 0.0f ) 
  2420. {
  2421. if(secondRotateX < 15.0f)
  2422. secondMult = 135.0f;
  2423. else if(secondRotateX > 15.0f && secondRotateX < 30.0f)
  2424. secondMult = 110.0f;
  2425. else if(secondRotateX > 30.0f && secondRotateX < 45.0f)
  2426. secondMult = 85.0f;
  2427. else if(secondRotateX > 45.0f && secondRotateX < 60.0f)
  2428. secondMult = 60.0f;
  2429. else if(secondRotateX > 60.0f && secondRotateX < 75.0f)
  2430. secondMult = 35.0f;
  2431. else
  2432. secondMult = 10.0f;
  2433. }
  2434. //if degree is in 2nd quadrant(z=+;x=-)
  2435. else if( (xtrans2 - secondTransX) < 0.0f &&  (ztrans2 - secondTransZ) > 0.0f) 
  2436. {
  2437. if(secondRotateX > -15.0f)
  2438. secondMult = -165.0f;
  2439. else if(secondRotateX > -30.0f && secondRotateX < -15.0f)
  2440. secondMult = -140.0f;
  2441. else if(secondRotateX > -45.0f && secondRotateX < -30.0f)
  2442. secondMult = -115.0f;
  2443. else if(secondRotateX > -60.0f && secondRotateX < -45.0f)
  2444. secondMult = -90.0f;
  2445. else if(secondRotateX > -75.0f && secondRotateX < -60.0f)
  2446. secondMult = -65.0f;
  2447. else
  2448. secondMult = -40.0f;
  2449. //secondMult = -135.0f * secondRotateX/90.0f -150.0f;
  2450. }
  2451. //if degree is in 4th quadrant(z=-;x=+)
  2452. else if( (xtrans2 - secondTransX) > 0.0f &&  (ztrans2 - secondTransZ) < 0.0f) 
  2453. {
  2454. if(secondRotateX > -15.0f)
  2455. secondMult = 20.0f;
  2456. else if(secondRotateX > -30.0f && secondRotateX < -15.0f)
  2457. secondMult = 40.0f;
  2458. else if(secondRotateX > -45.0f && secondRotateX < -30.0f)
  2459. secondMult = 60.0f;
  2460. else if(secondRotateX > -60.0f && secondRotateX < -45.0f)
  2461. secondMult = 80.0f;
  2462. else if(secondRotateX > -75.0f && secondRotateX < -60.0f)
  2463. secondMult = 100.0f;
  2464. else
  2465. secondMult = 140.0f;
  2466. //secondMult =   -45.0f * secondRotateX/90.0f + 15.0f;
  2467. }
  2468. //if degree is in 1st quadrant
  2469. else
  2470. {
  2471. secondMult = -165.0f * secondRotateX/90.0f - 15.0f; 
  2472. }
  2473.   
  2474. glRotatef(secondMult + secondRotateX, 0.0f, 1.0f, 0.0f); // Face the player around the Y-Axis
  2475. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2476. if( ( ( atan((secondTransZ - fire_z)/(secondTransX - fire_x + 0.5f)) 
  2477. - atan((ztrans2 -secondTransZ)/(xtrans2 - secondTransX + 0.5f)) < 0.0873*2 
  2478. && //10 degrees in radian
  2479. atan((secondTransZ - fire_z)/(secondTransX - fire_x + 0.5f))
  2480. - atan((ztrans2 -secondTransZ)/(xtrans2 - secondTransX + 0.5f)) > -0.0873*2 
  2481.   ) &&
  2482. isFire == true 
  2483. &&
  2484.   ( (ztrans2 > secondTransZ && secondTransZ > fire_z) ||
  2485. (ztrans2 < secondTransZ && secondTransZ < fire_z) 
  2486.   ) &&
  2487.   ( (xtrans2 > secondTransX && secondTransX > fire_x) ||
  2488. (xtrans2 < secondTransX && secondTransX < fire_x) 
  2489.   )
  2490. ) 
  2491. || //second condition
  2492. ( ( atan((secondTransZ - fire_z)/(secondTransX - fire_x + 0.5f)) 
  2493. - atan((ztrans2 -secondTransZ)/(xtrans2 - secondTransX + 0.5f)) > 0.0873*33 
  2494. || //165 degrees in radian
  2495. atan((secondTransZ - fire_z)/(secondTransX - fire_x + 0.5f))
  2496. - atan((ztrans2 -secondTransZ)/(xtrans2 - secondTransX + 0.5f)) < -0.0873*33 
  2497.    ) && //-165 degrees in radian
  2498.  isFire == true 
  2499. )
  2500.   )
  2501. {
  2502. secondHitCount += 1;
  2503. if( secondHitCount == 3)
  2504. { 
  2505. secondHitStatus = true;
  2506. point += 10;
  2507. }
  2508. }
  2510. glTranslatef( 0, 25.0f, 0); //move the model upwards
  2511. glCallList(MODEL);
  2512. glPopMatrix();
  2513. }
  2514. else
  2515. { 
  2516. glTranslatef( secondTransX, 15.0f, secondTransZ);
  2517. glRotatef(secondMult + secondRotateX, 0.0f, 1.0f, 0.0f);
  2518.   
  2519. if(ABS(secondRotateY) < 89.0f)
  2520. {
  2521. secondRotateYi += 0.1f;
  2522. }else
  2523. {
  2524. secondRotateYi = 0.0f;
  2525. }  
  2526. secondRotateY += secondRotateYi;  
  2527. glRotatef(secondRotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  2528.  
  2529. glCallList(MODEL);
  2530. }
  2531. }
  2533. //******************************* third ***************************************************
  2534. if(xtrans2 > 0 && xtrans2 < CELL &&
  2535. ztrans2 > CELL*4 && ztrans2 < CELL*5 )
  2536. {   
  2537.   thirdTrigger = true;
  2538. }else
  2539. {
  2540.   thirdTrigger = false;
  2541.   if(thirdHitStatus == false)//re-init
  2542.   {
  2543.   thirdHitCount = 0; 
  2544.   thirdTransX   = 20.0f;
  2545.   thirdTransZ   = CELL*4+20.0f;
  2546.   }
  2547. }
  2549. if(thirdTrigger == true )
  2550. {   
  2551. if(thirdHitStatus == false)
  2552. {
  2553. glPushMatrix();
  2554. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2555.   
  2556. if((xtrans2 - thirdTransX) > 15) //if on the left, move towards right
  2557. {
  2558. thirdTransXi += 0.001f; 
  2559. }else if((thirdTransX - xtrans2) > 15) //if on the right, move towards left
  2560. {
  2561. thirdTransXi -= 0.001f; 
  2562. }else
  2563. {
  2564. thirdTransXi = 0.0f; 
  2565. }
  2566. thirdTransX += thirdTransXi;
  2567. glTranslatef(thirdTransX, 0, 0);
  2569. if((ztrans2 - thirdTransZ) > 15) //if on the front, move forwards 
  2570. {
  2571. thirdTransZi += 0.001f; 
  2572. }else if((thirdTransZ - ztrans2) > 15) //if on the back, move backwards
  2573. {
  2574. thirdTransZi -= 0.001f; 
  2575. }else
  2576. {
  2577. thirdTransZi = 0.0f; 
  2578. } 
  2579. thirdTransZ += thirdTransZi;
  2580. glTranslatef( 0, 0, thirdTransZ);
  2582. // If the monster approach to player
  2583. if( ABS(xtrans2-thirdTransX) < 15 
  2584. && ABS(ztrans2-thirdTransZ) < 15 )
  2585. gameOver = true;
  2586. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** //////////////////// 
  2587. thirdRotateX = atan ( (ztrans2 - thirdTransZ) / (xtrans2 - thirdTransX + 0.5f) ) / piover180;
  2588.   
  2589. //if degree is in 3rd quadrant
  2590. if( (ztrans2 - thirdTransZ) < 0.0f && (xtrans2 - thirdTransX) < 0.0f ) 
  2591. {
  2592. if(thirdRotateX < 15.0f)
  2593. thirdMult = 135.0f;
  2594. else if(thirdRotateX > 15.0f && thirdRotateX < 30.0f)
  2595. thirdMult = 110.0f;
  2596. else if(thirdRotateX > 30.0f && thirdRotateX < 45.0f)
  2597. thirdMult = 85.0f;
  2598. else if(thirdRotateX > 45.0f && thirdRotateX < 60.0f)
  2599. thirdMult = 60.0f;
  2600. else if(thirdRotateX > 60.0f && thirdRotateX < 75.0f)
  2601. thirdMult = 35.0f;
  2602. else
  2603. thirdMult = 10.0f;
  2604. }
  2605. //if degree is in 2nd quadrant(z=+;x=-)
  2606. else if( (xtrans2 - thirdTransX) < 0.0f &&  (ztrans2 - thirdTransZ) > 0.0f) 
  2607. {
  2608. if(thirdRotateX > -15.0f)
  2609. thirdMult = -165.0f;
  2610. else if(thirdRotateX > -30.0f && thirdRotateX < -15.0f)
  2611. thirdMult = -140.0f;
  2612. else if(thirdRotateX > -45.0f && thirdRotateX < -30.0f)
  2613. thirdMult = -115.0f;
  2614. else if(thirdRotateX > -60.0f && thirdRotateX < -45.0f)
  2615. thirdMult = -90.0f;
  2616. else if(thirdRotateX > -75.0f && thirdRotateX < -60.0f)
  2617. thirdMult = -65.0f;
  2618. else
  2619. thirdMult = -40.0f;
  2620. //thirdMult = -135.0f * thirdRotateX/90.0f -150.0f;
  2621. }
  2622. //if degree is in 4th quadrant(z=-;x=+)
  2623. else if( (xtrans2 - thirdTransX) > 0.0f &&  (ztrans2 - thirdTransZ) < 0.0f) 
  2624. {
  2625. if(thirdRotateX > -15.0f)
  2626. thirdMult = 20.0f;
  2627. else if(thirdRotateX > -30.0f && thirdRotateX < -15.0f)
  2628. thirdMult = 40.0f;
  2629. else if(thirdRotateX > -45.0f && thirdRotateX < -30.0f)
  2630. thirdMult = 60.0f;
  2631. else if(thirdRotateX > -60.0f && thirdRotateX < -45.0f)
  2632. thirdMult = 80.0f;
  2633. else if(thirdRotateX > -75.0f && thirdRotateX < -60.0f)
  2634. thirdMult = 100.0f;
  2635. else
  2636. thirdMult = 140.0f;
  2637. //thirdMult =   -45.0f * thirdRotateX/90.0f + 15.0f;
  2638. }
  2639. //if degree is in 1st quadrant
  2640. else
  2641. {
  2642. thirdMult = -165.0f * thirdRotateX/90.0f - 15.0f; 
  2643. }
  2644.   
  2645. glRotatef(thirdMult + thirdRotateX, 0.0f, 1.0f, 0.0f); // Face the player around the Y-Axis
  2646. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2647. if( ( ( atan((thirdTransZ - fire_z)/(thirdTransX - fire_x + 0.5f)) 
  2648. - atan((ztrans2 -thirdTransZ)/(xtrans2 - thirdTransX + 0.5f)) < 0.0873*2 
  2649. && //10 degrees in radian
  2650. atan((thirdTransZ - fire_z)/(thirdTransX - fire_x + 0.5f))
  2651. - atan((ztrans2 -thirdTransZ)/(xtrans2 - thirdTransX + 0.5f)) > -0.0873*2 
  2652.   ) &&
  2653. isFire == true 
  2654. &&
  2655.   ( (ztrans2 > thirdTransZ && thirdTransZ > fire_z) ||
  2656. (ztrans2 < thirdTransZ && thirdTransZ < fire_z) 
  2657.   ) &&
  2658.   ( (xtrans2 > thirdTransX && thirdTransX > fire_x) ||
  2659. (xtrans2 < thirdTransX && thirdTransX < fire_x) 
  2660.   )
  2661. ) 
  2662. || //second condition
  2663. ( ( atan((thirdTransZ - fire_z)/(thirdTransX - fire_x + 0.5f)) 
  2664. - atan((ztrans2 -thirdTransZ)/(xtrans2 - thirdTransX + 0.5f)) > 0.0873*33 
  2665. || //165 degrees in radian
  2666. atan((thirdTransZ - fire_z)/(thirdTransX - fire_x + 0.5f))
  2667. - atan((ztrans2 -thirdTransZ)/(xtrans2 - thirdTransX + 0.5f)) < -0.0873*33 
  2668.    ) && //-165 degrees in radian
  2669.  isFire == true 
  2670. )
  2671.   )
  2672. {
  2673. thirdHitCount += 1;
  2674. if( thirdHitCount == 3)
  2675. { 
  2676. thirdHitStatus = true;
  2677. point += 10;
  2678. }
  2679. }
  2681. glTranslatef( 0, 25.0f, 0); //move the model upwards
  2682. glCallList(MODEL);
  2683. glPopMatrix();
  2684. }
  2685. else
  2686. { 
  2687. glTranslatef( thirdTransX, 15.0f, thirdTransZ);
  2688. glRotatef(thirdMult + thirdRotateX, 0.0f, 1.0f, 0.0f);
  2689.   
  2690. if(ABS(thirdRotateY) < 89.0f)
  2691. {
  2692. thirdRotateYi += 0.1f;
  2693. }else
  2694. {
  2695. thirdRotateYi = 0.0f;
  2696. }  
  2697. thirdRotateY += thirdRotateYi;  
  2698. glRotatef(thirdRotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  2699.  
  2700. glCallList(MODEL);
  2701. }
  2702. }
  2704. //******************************* fourth ***************************************************
  2705. if(xtrans2 > CELL*2 && xtrans2 < CELL*3 &&
  2706. ztrans2 > CELL && ztrans2 < CELL*4 )
  2707. {   
  2708.   fourthTrigger = true;
  2709. }else
  2710. {
  2711.   fourthTrigger = false;
  2712.   if(fourthHitStatus == false)//re-init
  2713.   {
  2714.   fourthHitCount = 0; 
  2715.   fourthTransX   = CELL*2+20.0f;
  2716.   fourthTransZ   = CELL*2+20.0f;
  2717.   }
  2718. }
  2720. if(fourthTrigger == true )
  2721. {   
  2722. if(fourthHitStatus == false)
  2723. {
  2724. glPushMatrix();
  2725. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2726.   
  2727. if((xtrans2 - fourthTransX) > 15) //if on the left, move towards right
  2728. {
  2729. fourthTransXi += 0.001f; 
  2730. }else if((fourthTransX - xtrans2) > 15) //if on the right, move towards left
  2731. {
  2732. fourthTransXi -= 0.001f; 
  2733. }else
  2734. {
  2735. fourthTransXi = 0.0f; 
  2736. }
  2737. fourthTransX += fourthTransXi;
  2738. glTranslatef(fourthTransX, 0, 0);
  2740. if((ztrans2 - fourthTransZ) > 15) //if on the front, move forwards 
  2741. {
  2742. fourthTransZi += 0.001f; 
  2743. }else if((fourthTransZ - ztrans2) > 15) //if on the back, move backwards
  2744. {
  2745. fourthTransZi -= 0.001f; 
  2746. }else
  2747. {
  2748. fourthTransZi = 0.0f; 
  2749. } 
  2750. fourthTransZ += fourthTransZi;
  2751. glTranslatef( 0, 0, fourthTransZ);
  2753. // If the monster approach to player
  2754. if( ABS(xtrans2-fourthTransX) < 15 
  2755. && ABS(ztrans2-fourthTransZ) < 15 )
  2756. gameOver = true;
  2757. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** //////////////////// 
  2758. fourthRotateX = atan ( (ztrans2 - fourthTransZ) / (xtrans2 - fourthTransX + 0.5f) ) / piover180;
  2759.   
  2760. //if degree is in 3rd quadrant
  2761. if( (ztrans2 - fourthTransZ) < 0.0f && (xtrans2 - fourthTransX) < 0.0f ) 
  2762. {
  2763. if(fourthRotateX < 15.0f)
  2764. fourthMult = 135.0f;
  2765. else if(fourthRotateX > 15.0f && fourthRotateX < 30.0f)
  2766. fourthMult = 110.0f;
  2767. else if(fourthRotateX > 30.0f && fourthRotateX < 45.0f)
  2768. fourthMult = 85.0f;
  2769. else if(fourthRotateX > 45.0f && fourthRotateX < 60.0f)
  2770. fourthMult = 60.0f;
  2771. else if(fourthRotateX > 60.0f && fourthRotateX < 75.0f)
  2772. fourthMult = 35.0f;
  2773. else
  2774. fourthMult = 10.0f;
  2775. }
  2776. //if degree is in 2nd quadrant(z=+;x=-)
  2777. else if( (xtrans2 - fourthTransX) < 0.0f &&  (ztrans2 - fourthTransZ) > 0.0f) 
  2778. {
  2779. if(fourthRotateX > -15.0f)
  2780. fourthMult = -165.0f;
  2781. else if(fourthRotateX > -30.0f && fourthRotateX < -15.0f)
  2782. fourthMult = -140.0f;
  2783. else if(fourthRotateX > -45.0f && fourthRotateX < -30.0f)
  2784. fourthMult = -115.0f;
  2785. else if(fourthRotateX > -60.0f && fourthRotateX < -45.0f)
  2786. fourthMult = -90.0f;
  2787. else if(fourthRotateX > -75.0f && fourthRotateX < -60.0f)
  2788. fourthMult = -65.0f;
  2789. else
  2790. fourthMult = -40.0f;
  2791. //fourthMult = -135.0f * fourthRotateX/90.0f -150.0f;
  2792. }
  2793. //if degree is in 4th quadrant(z=-;x=+)
  2794. else if( (xtrans2 - fourthTransX) > 0.0f &&  (ztrans2 - fourthTransZ) < 0.0f) 
  2795. {
  2796. if(fourthRotateX > -15.0f)
  2797. fourthMult = 20.0f;
  2798. else if(fourthRotateX > -30.0f && fourthRotateX < -15.0f)
  2799. fourthMult = 40.0f;
  2800. else if(fourthRotateX > -45.0f && fourthRotateX < -30.0f)
  2801. fourthMult = 60.0f;
  2802. else if(fourthRotateX > -60.0f && fourthRotateX < -45.0f)
  2803. fourthMult = 80.0f;
  2804. else if(fourthRotateX > -75.0f && fourthRotateX < -60.0f)
  2805. fourthMult = 100.0f;
  2806. else
  2807. fourthMult = 140.0f;
  2808. //fourthMult =   -45.0f * fourthRotateX/90.0f + 15.0f;
  2809. }
  2810. //if degree is in 1st quadrant
  2811. else
  2812. {
  2813. fourthMult = -165.0f * fourthRotateX/90.0f - 15.0f; 
  2814. }
  2815.   
  2816. glRotatef(fourthMult + fourthRotateX, 0.0f, 1.0f, 0.0f); // Face the player around the Y-Axis
  2817. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2818. if( ( ( atan((fourthTransZ - fire_z)/(fourthTransX - fire_x + 0.5f)) 
  2819. - atan((ztrans2 -fourthTransZ)/(xtrans2 - fourthTransX + 0.5f)) < 0.0873*2 
  2820. && //10 degrees in radian
  2821. atan((fourthTransZ - fire_z)/(fourthTransX - fire_x + 0.5f))
  2822. - atan((ztrans2 -fourthTransZ)/(xtrans2 - fourthTransX + 0.5f)) > -0.0873*2 
  2823.   ) &&
  2824. isFire == true 
  2825. &&
  2826.   ( (ztrans2 > fourthTransZ && fourthTransZ > fire_z) ||
  2827. (ztrans2 < fourthTransZ && fourthTransZ < fire_z) 
  2828.   ) &&
  2829.   ( (xtrans2 > fourthTransX && fourthTransX > fire_x) ||
  2830. (xtrans2 < fourthTransX && fourthTransX < fire_x) 
  2831.   )
  2832. ) 
  2833. || //second condition
  2834. ( ( atan((fourthTransZ - fire_z)/(fourthTransX - fire_x + 0.5f)) 
  2835. - atan((ztrans2 -fourthTransZ)/(xtrans2 - fourthTransX + 0.5f)) > 0.0873*33 
  2836. || //165 degrees in radian
  2837. atan((fourthTransZ - fire_z)/(fourthTransX - fire_x + 0.5f))
  2838. - atan((ztrans2 -fourthTransZ)/(xtrans2 - fourthTransX + 0.5f)) < -0.0873*33
  2839.    ) && //-165 degrees in radian
  2840.  isFire == true 
  2841. )
  2842.   )
  2843. {
  2844. fourthHitCount += 1;
  2845. if( fourthHitCount == 3)
  2846. { 
  2847. fourthHitStatus = true;
  2848. point += 10;
  2849. }
  2850. }
  2852. glTranslatef( 0, 25.0f, 0); //move the model upwards
  2853. glCallList(MODEL);
  2854. glPopMatrix();
  2855. }
  2856. else
  2857. { 
  2858. glTranslatef( fourthTransX, 15.0f, fourthTransZ);
  2859. glRotatef(fourthMult + fourthRotateX, 0.0f, 1.0f, 0.0f);
  2860.   
  2861. if(ABS(fourthRotateY) < 89.0f)
  2862. {
  2863. fourthRotateYi += 0.1f;
  2864. }else
  2865. {
  2866. fourthRotateYi = 0.0f;
  2867. }  
  2868. fourthRotateY += fourthRotateYi;  
  2869. glRotatef(fourthRotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  2870.  
  2871. glCallList(MODEL);
  2872. }
  2873. }
  2875. //******************************* fifth ***************************************************
  2876. if(xtrans2 > 0 && xtrans2 < CELL &&
  2877. ztrans2 > CELL && ztrans2 < CELL*4 )
  2878. {   
  2879.   fifthTrigger = true;
  2880. }else
  2881. {
  2882.   fifthTrigger = false;
  2883.   if(fifthHitStatus == false)//re-init
  2884.   {
  2885.   fifthHitCount = 0; 
  2886.   fifthTransX   = 20.0f;
  2887.   fifthTransZ   = CELL*2+20.0f;
  2888.   }
  2889. }
  2891. if(fifthTrigger == true )
  2892. {   
  2893. if(fifthHitStatus == false)
  2894. {
  2895. glPushMatrix();
  2896. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2897.   
  2898. if((xtrans2 - fifthTransX) > 15) //if on the left, move towards right
  2899. {
  2900. fifthTransXi += 0.001f; 
  2901. }else if((fifthTransX - xtrans2) > 15) //if on the right, move towards left
  2902. {
  2903. fifthTransXi -= 0.001f; 
  2904. }else
  2905. {
  2906. fifthTransXi = 0.0f; 
  2907. }
  2908. fifthTransX += fifthTransXi;
  2909. glTranslatef(fifthTransX, 0, 0);
  2911. if((ztrans2 - fifthTransZ) > 15) //if on the front, move forwards 
  2912. {
  2913. fifthTransZi += 0.001f; 
  2914. }else if((fifthTransZ - ztrans2) > 15) //if on the back, move backwards
  2915. {
  2916. fifthTransZi -= 0.001f; 
  2917. }else
  2918. {
  2919. fifthTransZi = 0.0f; 
  2920. } 
  2921. fifthTransZ += fifthTransZi;
  2922. glTranslatef( 0, 0, fifthTransZ);
  2924. // If the monster approach to player
  2925. if( ABS(xtrans2-fifthTransX) < 15 
  2926. && ABS(ztrans2-fifthTransZ) < 15 )
  2927. gameOver = true;
  2928. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** //////////////////// 
  2929. fifthRotateX = atan ( (ztrans2 - fifthTransZ) / (xtrans2 - fifthTransX + 0.5f) ) / piover180;
  2930.   
  2931. //if degree is in 3rd quadrant
  2932. if( (ztrans2 - fifthTransZ) < 0.0f && (xtrans2 - fifthTransX) < 0.0f ) 
  2933. {
  2934. if(fifthRotateX < 15.0f)
  2935. fifthMult = 135.0f;
  2936. else if(fifthRotateX > 15.0f && fifthRotateX < 30.0f)
  2937. fifthMult = 110.0f;
  2938. else if(fifthRotateX > 30.0f && fifthRotateX < 45.0f)
  2939. fifthMult = 85.0f;
  2940. else if(fifthRotateX > 45.0f && fifthRotateX < 60.0f)
  2941. fifthMult = 60.0f;
  2942. else if(fifthRotateX > 60.0f && fifthRotateX < 75.0f)
  2943. fifthMult = 35.0f;
  2944. else
  2945. fifthMult = 10.0f;
  2946. }
  2947. //if degree is in 2nd quadrant(z=+;x=-)
  2948. else if( (xtrans2 - fifthTransX) < 0.0f &&  (ztrans2 - fifthTransZ) > 0.0f) 
  2949. {
  2950. if(fifthRotateX > -15.0f)
  2951. fifthMult = -165.0f;
  2952. else if(fifthRotateX > -30.0f && fifthRotateX < -15.0f)
  2953. fifthMult = -140.0f;
  2954. else if(fifthRotateX > -45.0f && fifthRotateX < -30.0f)
  2955. fifthMult = -115.0f;
  2956. else if(fifthRotateX > -60.0f && fifthRotateX < -45.0f)
  2957. fifthMult = -90.0f;
  2958. else if(fifthRotateX > -75.0f && fifthRotateX < -60.0f)
  2959. fifthMult = -65.0f;
  2960. else
  2961. fifthMult = -40.0f;
  2962. //fifthMult = -135.0f * fifthRotateX/90.0f -150.0f;
  2963. }
  2964. //if degree is in 4th quadrant(z=-;x=+)
  2965. else if( (xtrans2 - fifthTransX) > 0.0f &&  (ztrans2 - fifthTransZ) < 0.0f) 
  2966. {
  2967. if(fifthRotateX > -15.0f)
  2968. fifthMult = 20.0f;
  2969. else if(fifthRotateX > -30.0f && fifthRotateX < -15.0f)
  2970. fifthMult = 40.0f;
  2971. else if(fifthRotateX > -45.0f && fifthRotateX < -30.0f)
  2972. fifthMult = 60.0f;
  2973. else if(fifthRotateX > -60.0f && fifthRotateX < -45.0f)
  2974. fifthMult = 80.0f;
  2975. else if(fifthRotateX > -75.0f && fifthRotateX < -60.0f)
  2976. fifthMult = 100.0f;
  2977. else
  2978. fifthMult = 140.0f;
  2979. //fifthMult =   -45.0f * fifthRotateX/90.0f + 15.0f;
  2980. }
  2981. //if degree is in 1st quadrant
  2982. else
  2983. {
  2984. fifthMult = -165.0f * fifthRotateX/90.0f - 15.0f; 
  2985. }
  2986.   
  2987. glRotatef(fifthMult + fifthRotateX, 0.0f, 1.0f, 0.0f); // Face the player around the Y-Axis
  2988. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2989. if( ( ( atan((fifthTransZ - fire_z)/(fifthTransX - fire_x + 0.5f)) 
  2990. - atan((ztrans2 -fifthTransZ)/(xtrans2 - fifthTransX + 0.5f)) < 0.0873*2 
  2991. && //10 degrees in radian
  2992. atan((fifthTransZ - fire_z)/(fifthTransX - fire_x + 0.5f))
  2993. - atan((ztrans2 -fifthTransZ)/(xtrans2 - fifthTransX + 0.5f)) > -0.0873*2 
  2994.   ) &&
  2995. isFire == true 
  2996. &&
  2997.   ( (ztrans2 > fifthTransZ && fifthTransZ > fire_z) ||
  2998. (ztrans2 < fifthTransZ && fifthTransZ < fire_z) 
  2999.   ) &&
  3000.   ( (xtrans2 > fifthTransX && fifthTransX > fire_x) ||
  3001. (xtrans2 < fifthTransX && fifthTransX < fire_x) 
  3002.   )
  3003. ) 
  3004. || //second condition
  3005. ( ( atan((fifthTransZ - fire_z)/(fifthTransX - fire_x + 0.5f)) 
  3006. - atan((ztrans2 -fifthTransZ)/(xtrans2 - fifthTransX + 0.5f)) > 0.0873*33 
  3007. || //165 degrees in radian
  3008. atan((fifthTransZ - fire_z)/(fifthTransX - fire_x + 0.5f))
  3009. - atan((ztrans2 -fifthTransZ)/(xtrans2 - fifthTransX + 0.5f)) < -0.0873*33 
  3010.    ) && //-165 degrees in radian
  3011.  isFire == true 
  3012. )
  3013.   )
  3014. {
  3015. fifthHitCount += 1;
  3016. if( fifthHitCount == 3)
  3017. { 
  3018. fifthHitStatus = true;
  3019. point += 10;
  3020. }
  3021. }
  3023. glTranslatef( 0, 25.0f, 0); //move the model upwards
  3024. glCallList(MODEL);
  3025. glPopMatrix();
  3026. }
  3027. else
  3028. { 
  3029. glTranslatef( fifthTransX, 15.0f, fifthTransZ);
  3030. glRotatef(fifthMult + fifthRotateX, 0.0f, 1.0f, 0.0f);
  3031.   
  3032. if(ABS(fifthRotateY) < 89.0f)
  3033. {
  3034. fifthRotateYi += 0.1f;
  3035. }else
  3036. {
  3037. fifthRotateYi = 0.0f;
  3038. }  
  3039. fifthRotateY += fifthRotateYi;  
  3040. glRotatef(fifthRotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  3041.  
  3042. glCallList(MODEL);
  3043. }
  3044. }
  3046. //******************************* sixth ***************************************************
  3047. if(xtrans2 > CELL && xtrans2 < CELL*2 &&
  3048. ztrans2 > 0 && ztrans2 < CELL*3 )
  3049. {   
  3050.   sixthTrigger = true;
  3051. }else
  3052. {
  3053.   sixthTrigger = false;
  3054.   if(sixthHitStatus == false)//re-init
  3055.   {
  3056.   sixthHitCount = 0; 
  3057.   sixthTransX   = CELL*2-20.0f;
  3058.   sixthTransZ   = 20.0f;
  3059.   }
  3060. }
  3062. if(sixthTrigger == true )
  3063. {   
  3064. if(sixthHitStatus == false)
  3065. {
  3066. glPushMatrix();
  3067. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  3068.   
  3069. if((xtrans2 - sixthTransX) > 15) //if on the left, move towards right
  3070. {
  3071. sixthTransXi += 0.001f; 
  3072. }else if((sixthTransX - xtrans2) > 15) //if on the right, move towards left
  3073. {
  3074. sixthTransXi -= 0.001f; 
  3075. }else
  3076. {
  3077. sixthTransXi = 0.0f; 
  3078. }
  3079. sixthTransX += sixthTransXi;
  3080. glTranslatef(sixthTransX, 0, 0);
  3082. if((ztrans2 - sixthTransZ) > 15) //if on the front, move forwards 
  3083. {
  3084. sixthTransZi += 0.001f; 
  3085. }else if((sixthTransZ - ztrans2) > 15) //if on the back, move backwards
  3086. {
  3087. sixthTransZi -= 0.001f; 
  3088. }else
  3089. {
  3090. sixthTransZi = 0.0f; 
  3091. } 
  3092. sixthTransZ += sixthTransZi;
  3093. glTranslatef( 0, 0, sixthTransZ);
  3095. // If the monster approach to player
  3096. if( ABS(xtrans2-sixthTransX) < 15 
  3097. && ABS(ztrans2-sixthTransZ) < 15 )
  3098. gameOver = true;
  3099. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** //////////////////// 
  3100. sixthRotateX = atan ( (ztrans2 - sixthTransZ) / (xtrans2 - sixthTransX + 0.5f) ) / piover180;
  3101.   
  3102. //if degree is in 3rd quadrant
  3103. if( (ztrans2 - sixthTransZ) < 0.0f && (xtrans2 - sixthTransX) < 0.0f ) 
  3104. {
  3105. if(sixthRotateX < 15.0f)
  3106. sixthMult = 135.0f;
  3107. else if(sixthRotateX > 15.0f && sixthRotateX < 30.0f)
  3108. sixthMult = 110.0f;
  3109. else if(sixthRotateX > 30.0f && sixthRotateX < 45.0f)
  3110. sixthMult = 85.0f;
  3111. else if(sixthRotateX > 45.0f && sixthRotateX < 60.0f)
  3112. sixthMult = 60.0f;
  3113. else if(sixthRotateX > 60.0f && sixthRotateX < 75.0f)
  3114. sixthMult = 35.0f;
  3115. else
  3116. sixthMult = 10.0f;
  3117. }
  3118. //if degree is in 2nd quadrant(z=+;x=-)
  3119. else if( (xtrans2 - sixthTransX) < 0.0f &&  (ztrans2 - sixthTransZ) > 0.0f) 
  3120. {
  3121. if(sixthRotateX > -15.0f)
  3122. sixthMult = -165.0f;
  3123. else if(sixthRotateX > -30.0f && sixthRotateX < -15.0f)
  3124. sixthMult = -140.0f;
  3125. else if(sixthRotateX > -45.0f && sixthRotateX < -30.0f)
  3126. sixthMult = -115.0f;
  3127. else if(sixthRotateX > -60.0f && sixthRotateX < -45.0f)
  3128. sixthMult = -90.0f;
  3129. else if(sixthRotateX > -75.0f && sixthRotateX < -60.0f)
  3130. sixthMult = -65.0f;
  3131. else
  3132. sixthMult = -40.0f;
  3133. //sixthMult = -135.0f * sixthRotateX/90.0f -150.0f;
  3134. }
  3135. //if degree is in 4th quadrant(z=-;x=+)
  3136. else if( (xtrans2 - sixthTransX) > 0.0f &&  (ztrans2 - sixthTransZ) < 0.0f) 
  3137. {
  3138. if(sixthRotateX > -15.0f)
  3139. sixthMult = 20.0f;
  3140. else if(sixthRotateX > -30.0f && sixthRotateX < -15.0f)
  3141. sixthMult = 40.0f;
  3142. else if(sixthRotateX > -45.0f && sixthRotateX < -30.0f)
  3143. sixthMult = 60.0f;
  3144. else if(sixthRotateX > -60.0f && sixthRotateX < -45.0f)
  3145. sixthMult = 80.0f;
  3146. else if(sixthRotateX > -75.0f && sixthRotateX < -60.0f)
  3147. sixthMult = 100.0f;
  3148. else
  3149. sixthMult = 140.0f;
  3150. //sixthMult =   -45.0f * sixthRotateX/90.0f + 15.0f;
  3151. }
  3152. //if degree is in 1st quadrant
  3153. else
  3154. {
  3155. sixthMult = -165.0f * sixthRotateX/90.0f - 15.0f; 
  3156. }
  3157.   
  3158. glRotatef(sixthMult + sixthRotateX, 0.0f, 1.0f, 0.0f); // Face the player around the Y-Axis
  3159. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  3160. if( ( ( atan((sixthTransZ - fire_z)/(sixthTransX - fire_x + 0.5f)) 
  3161. - atan((ztrans2 -sixthTransZ)/(xtrans2 - sixthTransX + 0.5f)) < 0.0873*2 
  3162. && //10 degrees in radian
  3163. atan((sixthTransZ - fire_z)/(sixthTransX - fire_x + 0.5f))
  3164. - atan((ztrans2 -sixthTransZ)/(xtrans2 - sixthTransX + 0.5f)) > -0.0873*2 
  3165.   ) &&
  3166. isFire == true 
  3167. &&
  3168.   ( (ztrans2 > sixthTransZ && sixthTransZ > fire_z) ||
  3169. (ztrans2 < sixthTransZ && sixthTransZ < fire_z) 
  3170.   ) &&
  3171.   ( (xtrans2 > sixthTransX && sixthTransX > fire_x) ||
  3172. (xtrans2 < sixthTransX && sixthTransX < fire_x) 
  3173.   )
  3174. ) 
  3175. || //second condition
  3176. ( ( atan((sixthTransZ - fire_z)/(sixthTransX - fire_x + 0.5f)) 
  3177. - atan((ztrans2 -sixthTransZ)/(xtrans2 - sixthTransX + 0.5f)) > 0.0873*33 
  3178. || //165 degrees in radian
  3179. atan((sixthTransZ - fire_z)/(sixthTransX - fire_x + 0.5f))
  3180. - atan((ztrans2 -sixthTransZ)/(xtrans2 - sixthTransX + 0.5f)) < -0.0873*33 
  3181.    ) && //-165 degrees in radian
  3182.  isFire == true 
  3183. )
  3184.   )
  3185. {
  3186. sixthHitCount += 1;
  3187. if( sixthHitCount == 3)
  3188. { 
  3189. sixthHitStatus = true;
  3190. point += 10;
  3191. }
  3192. }
  3194. glTranslatef( 0, 25.0f, 0); //move the model upwards
  3195. glCallList(MODEL);
  3196. glPopMatrix();
  3197. }
  3198. else
  3199. { 
  3200. glTranslatef( sixthTransX, 15.0f, sixthTransZ);
  3201. glRotatef(sixthMult + sixthRotateX, 0.0f, 1.0f, 0.0f);
  3202.   
  3203. if(ABS(sixthRotateY) < 89.0f)
  3204. {
  3205. sixthRotateYi += 0.1f;
  3206. }else
  3207. {
  3208. sixthRotateYi = 0.0f;
  3209. }  
  3210. sixthRotateY += sixthRotateYi;  
  3211. glRotatef(sixthRotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  3212.  
  3213. glCallList(MODEL);
  3214. }
  3215. }
  3216. //******************************* End ***************************************************
  3218. // Determine if you have fired a weapon
  3219. if (isFire)
  3220. {
  3221. PlaySound("Data/rifle.WAV", NULL, SND_ASYNC);
  3222. m16_kicki = 1;
  3223.     
  3224. shots_fired++;
  3225. if (shots_fired > MAX_SHOTS_FIRED-1) 
  3226. shots_fired = 0;
  3228. isFireComplete = false;
  3229. isFire = false;
  3231. fire_x = -xtrans;
  3232. fire_y = 10;
  3233. fire_z = -ztrans;
  3235. fire_xp = -(GLdouble)sin(heading*piover180) / 5;
  3236. fire_yp = -(GLdouble)tan(mouse_3d_y*piover180) / 5;
  3237. fire_zp = -(GLdouble)cos(heading*piover180) / 5;
  3238. }
  3239. int fire_counter = 0;
  3241. // Begin calculations for the projectile
  3242. while (!isFireComplete)
  3243. {     
  3244. fire_counter++;
  3245. fire_x += fire_xp;
  3246. fire_y += fire_yp;
  3247. fire_z += fire_zp;
  3248.       
  3249. if (DetectPartCollision(fire_x,  fire_y,  fire_z, BlankNum, BlankNum, BlankNum, 0, 0))
  3250. {
  3251. isFireComplete = true;
  3252. Ricochet();
  3253. isRicochet = true; 
  3254. }
  3255. else if (fire_counter > 10000)
  3256. {
  3257. isFireComplete = true;
  3258. } 
  3259. } 
  3261. // Determine if it was the M16 that was fired.
  3262. if (isRicochet)
  3263. {   
  3264. int i;
  3265. bool isRicochetComplete = true;
  3266.     
  3267. glDisable(GL_TEXTURE_2D);
  3268. glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  3270. for (int j = 0; j < MAX_SHOTS_FIRED; j++)
  3271. {
  3272. for (i = 8; i < MAX_PARTICLES; i++)
  3273. {
  3274. if (particle[i][j].life > 0)
  3275. {
  3276. isRicochetComplete = false;
  3278. particle[i][j].x += particle[i][j].xi;
  3279. particle[i][j].y += particle[i][j].yi;
  3280. particle[i][j].z += particle[i][j].zi;
  3282. DetectPartCollision(particle[i][j].x,  particle[i][j].y,  particle[i][j].z,
  3283. particle[i][j].xi, particle[i][j].yi, particle[i][j].zi, 0, .75f);
  3285. particle[i][j].yi -= .01f;  // cheap simulated gravity
  3286. particle[i][j].xi *= .99;
  3287. particle[i][j].yi *= .99;
  3288. particle[i][j].zi *= .99;
  3289. particle[i][j].life -= particle[i][j].fade;
  3290.         
  3291. glLoadIdentity();
  3292. glRotated(mouse_3d_y,1.f,0,0);
  3293. glRotated(sceneroty,0,1.f,0);
  3294. glTranslated(xtrans,-10,ztrans);  
  3295. glTranslated(particle[i][j].x,particle[i][j].y,particle[i][j].z);
  3296. glRotated(-sceneroty,0,1.f,0);
  3297. glRotated(-mouse_3d_y,1.f,0,0);
  3299. particle[i][j].triangle_rotate_x += particle[i][j].triangle_rotate_xi;
  3300. particle[i][j].triangle_rotate_y += particle[i][j].triangle_rotate_yi;
  3301. particle[i][j].triangle_rotate_z += particle[i][j].triangle_rotate_zi;
  3302. particle[i][j].triangle_rotate_xi -= particle[i][j].fade;
  3303. particle[i][j].triangle_rotate_yi -= particle[i][j].fade;
  3304. particle[i][j].triangle_rotate_zi -= particle[i][j].fade;
  3305. glRotated(particle[i][j].triangle_rotate_x,1,0,0);
  3306. glRotated(particle[i][j].triangle_rotate_y,0,1,0);
  3307. glRotated(particle[i][j].triangle_rotate_z,0,0,1);
  3309. glColor4d(0,0,0,particle[i][j].life);
  3311. glBegin(GL_TRIANGLES);
  3312. glVertex3d(particle[i][j].triangle_x1, particle[i][j].triangle_y1, particle[i][j].triangle_z1);
  3313. glVertex3d(particle[i][j].triangle_x2, particle[i][j].triangle_y2, particle[i][j].triangle_z2);
  3314. glVertex3d(particle[i][j].triangle_x3, particle[i][j].triangle_y3, particle[i][j].triangle_z3);
  3315. glEnd();
  3316. }
  3317. }
  3318. }
  3319. glEnable(GL_TEXTURE_2D);
  3320. glDisable(GL_DEPTH_TEST);
  3321. glBlendFunc(GL_SRC_ALPHA,GL_ONE);
  3323. glBindTexture(GL_TEXTURE_2D, texture[3]);
  3325. // Display particles of the ricochet from the M16
  3326. for (j = 0; j < MAX_SHOTS_FIRED; j++)
  3327. {
  3328. for (i = 0; i < 8; i++)
  3329. {     
  3330. if (particle[i][j].life > 0)
  3331. {
  3332. isRicochetComplete = false;
  3334. particle[i][j].x += particle[i][j].xi/2;
  3335. particle[i][j].y += particle[i][j].yi/2;
  3336. particle[i][j].z += particle[i][j].zi/2;
  3338. particle[i][j].yi += .01f;
  3340. particle[i][j].xi *= .9f;
  3341. particle[i][j].yi *= .9f;
  3342. particle[i][j].zi *= .9f;
  3343.         
  3344. particle[i][j].life -= particle[i][j].fade/2;
  3346. glLoadIdentity();
  3347. glRotated(mouse_3d_y,1.f,0,0);
  3348. glRotated(sceneroty,0,1.f,0);
  3349. glTranslated(xtrans,-10,ztrans);       
  3350. glTranslated(particle[i][j].x,particle[i][j].y,particle[i][j].z);
  3351. glRotated(-sceneroty,0,1.f,0);
  3352. glRotated(-mouse_3d_y,1.f,0,0);
  3354. glColor4d(.18f,.17f,.15f,particle[i][j].life);
  3355. glBegin(GL_QUADS);
  3356. glTexCoord2d(1,1); glVertex3d( particle[i][j].size, particle[i][j].size,0);
  3357. glTexCoord2d(1,0); glVertex3d( particle[i][j].size,-particle[i][j].size,0);
  3358. glTexCoord2d(0,0); glVertex3d(-particle[i][j].size,-particle[i][j].size,0);
  3359. glTexCoord2d(0,1); glVertex3d(-particle[i][j].size, particle[i][j].size,0);
  3360. glEnd();
  3361. }  
  3362. }
  3363. }
  3364. glEnable(GL_DEPTH_TEST);
  3366. if (isRicochetComplete)
  3367. isRicochet = false;
  3368. }
  3369.  
  3370. // Crosshair  
  3371. glDisable(GL_DEPTH_TEST);
  3372. glLoadIdentity();
  3373. glTranslated(0.0f,0.0f,-35.0f);   
  3375. glBlendFunc(GL_SRC_ALPHA,GL_ONE);
  3377. glColor4f(1,1,1,1);
  3378. glBindTexture(GL_TEXTURE_2D,texture[2]);
  3379. glBegin(GL_QUADS);
  3380. glTexCoord2d(1,1); glVertex2f(1,1);
  3381. glTexCoord2d(1,0); glVertex2f(1,-1);
  3382. glTexCoord2d(0,0); glVertex2f(-1,-1);
  3383. glTexCoord2d(0,1); glVertex2f(-1,1);
  3384. glEnd(); 
  3385.   
  3386. glDisable(GL_DEPTH_TEST);   
  3387. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  3388. glColor4d(1,1,1,1);
  3389. glPrint(150,250,1,"Distance: %4.0f", Hypot( (xtrans2-CELL*3/2.0), (ztrans2-5.0) ) / 10.0 );
  3390. //////////// *** NEW *** ////////// EXIT ///////////// *** NEW *** ////////////////////
  3391. // If player get out
  3392. if( Hypot( (xtrans2-CELL*3/2.0), (ztrans2-5.0) ) / 10.0 < 5.0 )
  3393. getOut = true; 
  3394. //////////// *** NEW *** ////////// EXIT ///////////// *** NEW *** ////////////////////
  3395. if( firstTrigger == true && firstHitCount < 3)
  3396. {
  3397. glColor4d(1,0,0,1);
  3398. glPrint(150,230,1,"ALERT!");
  3399. }else if( secondTrigger == true && secondHitCount < 3)
  3400. {
  3401. glColor4d(1,0,0,1);
  3402. glPrint(150,230,1,"ALERT!");
  3403. }else if( thirdTrigger == true && thirdHitCount < 3)
  3404. {
  3405. glColor4d(1,0,0,1);
  3406. glPrint(150,230,1,"ALERT!");
  3407. }else if( fourthTrigger == true && fourthHitCount < 3)
  3408. {
  3409. glColor4d(1,0,0,1);
  3410. glPrint(150,230,1,"ALERT!");
  3411. }else if( fifthTrigger == true && fifthHitCount < 3)
  3412. {
  3413. glColor4d(1,0,0,1);
  3414. glPrint(150,230,1,"ALERT!");
  3415. }else if( sixthTrigger == true && sixthHitCount < 3)
  3416. {
  3417. glColor4d(1,0,0,1);
  3418. glPrint(150,230,1,"ALERT!");
  3419. }
  3420. glColor4d(0,0,1,1);
  3421. glPrint(150,210,1,"point: %4.0d", point);
  3422. glColor4d(1,1,1,1);
  3423. glEnable(GL_DEPTH_TEST);
  3424. glDisable(GL_TEXTURE_2D);
  3425.     glEnable(GL_TEXTURE_2D);
  3427. //  ESTABLISH A FPS FRAMERATE COUNTER
  3428. if (isFPS)
  3429. { 
  3430. glDisable(GL_DEPTH_TEST);
  3431. frames++;    
  3432. if (frames%10 == 0) 
  3433. {
  3434. Time2 = TimerGetTime()/1000;
  3435. DiffTime = ABS(Time2-Time1);      
  3436. Time1 = TimerGetTime()/1000;     
  3437. if (DiffTime != 0)
  3438. FPS = 10/(DiffTime);
  3439. }             
  3440.     
  3441. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  3442. glColor4d(1,1,1,1);
  3443. glPrint(-350,250,1,"FPS: %4.0f", FPS);
  3444.   
  3445. glPrint(-350,230,1,"firstTransX: %4.2f", firstTransX);
  3446. glPrint(-350,210,1,"firstTransZ: %4.2f", firstTransZ);
  3447. glPrint(-350,190,1,"(xtrans2-firstTransX): %4.2f", (xtrans2-firstTransX) );
  3448. glPrint(-350,170,1,"xtrans2: %4.2f", xtrans2);
  3449. glPrint(-350,150,1,"ztrans2: %4.2f", ztrans2);
  3450. glPrint(-350,130,1,"(ztrans2-firstTransZ): %4.2f", (ztrans2-firstTransZ) );
  3451. glPrint(-350,110,1,"firstRotateX@atan: %4.2f", firstRotateX );
  3452. glPrint(-350,90,1,"multiplier+atan: %4.2f", firstMult+firstRotateX);
  3453. glPrint(-350,70,1,"fire_x: %4.2f", fire_x );
  3454. glPrint(-350,50,1,"fire_y: %4.2f", fire_y );
  3455. glPrint(-350,30,1,"fire_z: %4.2f", fire_z );
  3456. glPrint(-350,10,1,"deg(M-H): %4.2f", atan((firstTransZ - fire_z)/(firstTransX - fire_x + 0.5f))/ piover180 );
  3457. glPrint(-350,-10,1,"deg(P-M): %4.2f", atan((ztrans2 -firstTransZ)/(xtrans2 - firstTransX + 0.5f))/ piover180);
  3458. glPrint(-350,-30,1,"condition: %4.2f", atan((firstTransZ - fire_z)/(firstTransX - fire_x + 0.5f))/ piover180
  3459. - atan((ztrans2 -firstTransZ)/(xtrans2 - firstTransX + 0.5f))/ piover180);
  3460. glPrint(-350,-50,1,"[0]hit %2.0d", firstHitCount);
  3461. if( firstHitStatus == true )
  3462. {
  3463. glPrint(-350,-70,1,"[0]dead");
  3464. }
  3465. //second
  3466. glPrint(-350,-90,1,"secondTransX: %4.2f", secondTransX);
  3467. glPrint(-350,-110,1,"secondTransZ: %4.2f", secondTransZ); 
  3468. glPrint(-350,-150,1,"condition: %4.2f", atan((secondTransZ - fire_z)/(secondTransX - fire_x + 0.5f))/ piover180
  3469. - atan((ztrans2 -secondTransZ)/(xtrans2 - secondTransX + 0.5f))/ piover180);
  3470. glPrint(-350,-170,1,"[1]hit %2.0d", secondHitCount);
  3471. if( secondHitStatus == true )
  3472. {
  3473. glPrint(-350,-190,1,"[1]dead");
  3474. }
  3475. //third
  3476. glPrint(80,170,1,"thirdTransX: %4.2f", thirdTransX);
  3477. glPrint(80,150,1,"thirdTransZ: %4.2f", thirdTransZ); 
  3478. glPrint(80,130,1,"condition: %4.2f", atan((thirdTransZ - fire_z)/(thirdTransX - fire_x + 0.5f))/ piover180
  3479. - atan((ztrans2 -thirdTransZ)/(xtrans2 - thirdTransX + 0.5f))/ piover180);
  3480. glPrint(80,110,1,"[2]hit %2.0d", thirdHitCount);
  3481. if( thirdHitStatus == true )
  3482. {
  3483. glPrint(80,90,1,"[2]dead");
  3484. }
  3485. //fourth
  3486. glPrint(80,70,1,"fourthTransX: %4.2f", fourthTransX);
  3487. glPrint(80,50,1,"fourthTransZ: %4.2f", fourthTransZ); 
  3488. glPrint(80,30,1,"condition: %4.2f", atan((fourthTransZ - fire_z)/(fourthTransX - fire_x + 0.5f))/ piover180
  3489. - atan((ztrans2 -fourthTransZ)/(xtrans2 - fourthTransX + 0.5f))/ piover180);
  3490. glPrint(80,10,1,"[3]hit %2.0d", fourthHitCount);
  3491. if( fourthHitStatus == true )
  3492. {
  3493. glPrint(80,-10,1,"[3]dead");
  3494. }
  3495. //fifth
  3496. glPrint(80,-30,1,"fifthTransX: %4.2f", fifthTransX);
  3497. glPrint(80,-50,1,"fifthTransZ: %4.2f", fifthTransZ); 
  3498. glPrint(80,-70,1,"condition: %4.2f", atan((fifthTransZ - fire_z)/(fifthTransX - fire_x + 0.5f))/ piover180
  3499. - atan((ztrans2 -fifthTransZ)/(xtrans2 - fifthTransX + 0.5f))/ piover180);
  3500. glPrint(80,-90,1,"[4]hit %2.0d", fifthHitCount);
  3501. if( fifthHitStatus == true )
  3502. {
  3503. glPrint(80,-110,1,"[4]dead");
  3504. }
  3505. //sixth
  3506. glPrint(80,-130,1,"sixthTransX: %4.2f", sixthTransX);
  3507. glPrint(80,-150,1,"sixthTransZ: %4.2f", sixthTransZ); 
  3508. glPrint(80,-170,1,"condition: %4.2f", atan((sixthTransZ - fire_z)/(sixthTransX - fire_x + 0.5f))/ piover180
  3509. - atan((ztrans2 -sixthTransZ)/(xtrans2 - sixthTransX + 0.5f))/ piover180);
  3510. glPrint(80,-190,1,"[5]hit %2.0d", sixthHitCount);
  3511. if( sixthHitStatus == true )
  3512. {
  3513. glPrint(80,-210,1,"[5]dead");
  3514. }
  3516. glEnable(GL_DEPTH_TEST);           
  3517. glDisable(GL_TEXTURE_2D);
  3518. glEnable(GL_TEXTURE_2D);
  3519. }
  3520.   }else if(gameOver == true) // If game over
  3521.   {
  3522. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  3524. glColor4d(0,0,1,1);
  3525. glPrint(0,210,1,"point: %4.0d", point);
  3526. glColor4d(1,1,1,1);
  3527. glPrint(0,190,1,"GAME OVER!");
  3528. glPrint(0,170,1,"Press ESC to exit...");
  3529. glEnable(GL_DEPTH_TEST);           
  3530.     glDisable(GL_TEXTURE_2D);
  3531.     glEnable(GL_TEXTURE_2D);
  3532.   }else // If palyer get out 
  3533.   {
  3534. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  3536. glColor4d(0,0,1,1);
  3537. glPrint(0,210,1,"point: %4.0d", point);
  3538. glColor4d(1,1,1,1);
  3539. glPrint(0,190,1,"You win!");
  3540. glPrint(0,170,1,"Press ESC to exit...");
  3541. glEnable(GL_DEPTH_TEST);           
  3542.     glDisable(GL_TEXTURE_2D);
  3543.     glEnable(GL_TEXTURE_2D);
  3544.   }
  3545.   return TRUE; // Keep Going
  3546. }
  3548. GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
  3549. {
  3550. // When we are done, we need to free all the model data
  3551. // We do this by walking through all the objects and freeing their information
  3553. // Go through all the objects in the scene
  3554. for(int i = 0; i < g_3DModel.numOfObjects; i++)
  3555. {
  3556. // Free the faces, normals, vertices, and texture coordinates.
  3557. if(g_3DModel.pObject[i].pFaces) delete [] g_3DModel.pObject[i].pFaces;
  3558. if(g_3DModel.pObject[i].pNormals) delete [] g_3DModel.pObject[i].pNormals;
  3559. if(g_3DModel.pObject[i].pVerts) delete [] g_3DModel.pObject[i].pVerts;
  3560. if(g_3DModel.pObject[i].pTexVerts) delete [] g_3DModel.pObject[i].pTexVerts;
  3561. }
  3563. KillFont();
  3564. if (hRC) // Do We Have A Rendering Context?
  3565. {
  3566. if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
  3567. {
  3568. MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  3569. }
  3571. if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
  3572. {
  3573. MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  3574. }
  3575. hRC=NULL; // Set RC To NULL
  3576. }
  3578. if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
  3579. {
  3580. MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  3581. hDC=NULL; // Set DC To NULL
  3582. }
  3584. if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
  3585. {
  3586. MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  3587. hWnd=NULL; // Set hWnd To NULL
  3588. }
  3590. if (fullscreen) // Are We In Fullscreen Mode?
  3591. {
  3592. ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
  3593. ShowCursor(TRUE); // Show Mouse Pointer
  3594. }
  3595. }
  3597. /* This Code Creates Our OpenGL Window.  Parameters Are: *
  3598.  * title - Title To Appear At The Top Of The Window *
  3599.  * width - Width Of The GL Window Or Fullscreen Mode *
  3600.  * height - Height Of The GL Window Or Fullscreen Mode *
  3601.  * bits - Number Of Bits To Use For Color (8/16/24/32) *
  3602.  * fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */
  3603.  
  3604. BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
  3605. {
  3606. GLuint PixelFormat; // Holds The Results After Searching For A Match
  3607. WNDCLASS wc; // Windows Class Structure
  3608. DWORD dwExStyle; // Window Extended Style
  3609. DWORD dwStyle; // Window Style
  3610. RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
  3611. WindowRect.left=(long)0; // Set Left Value To 0
  3612. WindowRect.right=(long)width; // Set Right Value To Requested Width
  3613. WindowRect.top=(long)0; // Set Top Value To 0
  3614. WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
  3616. fullscreen=fullscreenflag; // Set The Global Fullscreen Flag
  3618. hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
  3619. wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
  3620. wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
  3621. wc.cbClsExtra = 0; // No Extra Window Data
  3622. wc.cbWndExtra = 0; // No Extra Window Data
  3623. wc.hInstance = hInstance; // Set The Instance
  3624. wc.hIcon = LoadIcon( hInstance, MAKEINTRESOURCE( IDI_ICON1 ) );
  3625. wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
  3626. wc.hbrBackground = NULL; // No Background Required For GL
  3627. wc.lpszMenuName = NULL; // We Don't Want A Menu
  3628. wc.lpszClassName = "OpenGL"; // Set The Class Name
  3630. if (!RegisterClass(&wc)) // Attempt To Register The Window Class
  3631. {
  3632. MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3633. return FALSE; // Return FALSE
  3634. }
  3636. if (fullscreen) // Attempt Fullscreen Mode?
  3637. {
  3638. DEVMODE dmScreenSettings; // Device Mode
  3639. memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
  3640. dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
  3641. dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
  3642. dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
  3643. dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
  3644. dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
  3646. // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
  3647. if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
  3648. {
  3649. // If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
  3650. if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported BynYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
  3651. {
  3652. fullscreen=FALSE; // Windowed Mode Selected.  Fullscreen = FALSE
  3653. }
  3654. else
  3655. {
  3656. // Pop Up A Message Box Letting User Know The Program Is Closing.
  3657. MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
  3658. return FALSE; // Return FALSE
  3659. }
  3660. }
  3661. }
  3663. if (fullscreen) // Are We Still In Fullscreen Mode?
  3664. {
  3665. dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
  3666. dwStyle=WS_POPUP; // Windows Style
  3667. ShowCursor(FALSE); // Hide Mouse Pointer
  3668. }
  3669. else
  3670. {
  3671. dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
  3672. dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
  3673. }
  3675. AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
  3677. // Create The Window
  3678. if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
  3679. "OpenGL", // Class Name
  3680. title, // Window Title
  3681. dwStyle | // Defined Window Style
  3682. WS_CLIPSIBLINGS | // Required Window Style
  3683. WS_CLIPCHILDREN, // Required Window Style
  3684. 0, 0, // Window Position
  3685. WindowRect.right-WindowRect.left,// Calculate Window Width
  3686. WindowRect.bottom-WindowRect.top,// Calculate Window Height
  3687. NULL, // No Parent Window
  3688. NULL, // No Menu
  3689. hInstance, // Instance
  3690. NULL))) // Dont Pass Anything To WM_CREATE
  3691. {
  3692. KillGLWindow(); // Reset The Display
  3693. MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3694. return FALSE; // Return FALSE
  3695. }
  3697. static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
  3698. {
  3699. sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
  3700. 1, // Version Number
  3701. PFD_DRAW_TO_WINDOW | // Format Must Support Window
  3702. PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
  3703. PFD_DOUBLEBUFFER, // Must Support Double Buffering
  3704. PFD_TYPE_RGBA, // Request An RGBA Format
  3705. bits, // Select Our Color Depth
  3706. 0, 0, 0, 0, 0, 0, // Color Bits Ignored
  3707. 0, // No Alpha Buffer
  3708. 0, // Shift Bit Ignored
  3709. 0, // No Accumulation Buffer
  3710. 0, 0, 0, 0, // Accumulation Bits Ignored
  3711. 16, // 16Bit Z-Buffer (Depth Buffer)  
  3712. 0, // No Stencil Buffer
  3713. 0, // No Auxiliary Buffer
  3714. PFD_MAIN_PLANE, // Main Drawing Layer
  3715. 0, // Reserved
  3716. 0, 0, 0 // Layer Masks Ignored
  3717. };
  3719. if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
  3720. {
  3721. KillGLWindow(); // Reset The Display
  3722. MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3723. return FALSE; // Return FALSE
  3724. }
  3726. if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
  3727. {
  3728. KillGLWindow(); // Reset The Display
  3729. MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3730. return FALSE; // Return FALSE
  3731. }
  3733. if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
  3734. {
  3735. KillGLWindow(); // Reset The Display
  3736. MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3737. return FALSE; // Return FALSE
  3738. }
  3740. if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
  3741. {
  3742. KillGLWindow(); // Reset The Display
  3743. MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3744. return FALSE; // Return FALSE
  3745. }
  3747. if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
  3748. {
  3749. KillGLWindow(); // Reset The Display
  3750. MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3751. return FALSE; // Return FALSE
  3752. }
  3754. ShowWindow(hWnd,SW_SHOW); // Show The Window
  3755. SetForegroundWindow(hWnd); // Slightly Higher Priority
  3756. SetFocus(hWnd); // Sets Keyboard Focus To The Window
  3757. ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
  3759. if (!InitGL()) // Initialize Our Newly Created GL Window
  3760. {
  3761. KillGLWindow(); // Reset The Display
  3762. MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  3763. return FALSE; // Return FALSE
  3764. }
  3766. return TRUE; // Success
  3767. }
  3769. LRESULT CALLBACK WndProc( HWND hWnd, // Handle For This Window
  3770. UINT uMsg, // Message For This Window
  3771. WPARAM wParam, // Additional Message Information
  3772. LPARAM lParam) // Additional Message Information
  3773. {
  3774. if (uMsg == WM_MOUSEMOVE)
  3775. {
  3776. if (LOWORD(lParam) > 370) SetCursorPos(10,(int)mouse_y), mouse_wrap_x--;
  3777. else if (LOWORD(lParam) < 10) SetCursorPos(370,(int)mouse_y), mouse_wrap_x++;
  3779. if (HIWORD(lParam) > 370) SetCursorPos((int)mouse_x,10), mouse_wrap_x--;
  3780. else if (HIWORD(lParam) < 10) SetCursorPos((int)mouse_x,370), mouse_wrap_x++;
  3782. if (ABS(mouse_x-LOWORD(lParam)) > 300)
  3783. {
  3784. if (mouse_x > 360/2)
  3785. mouse_3d_x += ((mouse_x-360)-LOWORD(lParam))/sensitivity;
  3786. else if (LOWORD(lParam) > 360/2)
  3787. mouse_3d_x += (mouse_x-(LOWORD(lParam)-360))/sensitivity;
  3788. }
  3789. else
  3790. { 
  3791. mouse_3d_x += (mouse_x-LOWORD(lParam))/sensitivity;
  3792. } 
  3794. if (mouse_3d_x > 360) mouse_3d_x = 0;
  3795. else if (mouse_3d_x < 0) mouse_3d_x = 360;
  3797. if (invert_mouse)
  3798. {
  3799. if (ABS(mouse_y-HIWORD(lParam)) > 300)
  3800. { 
  3801. if (mouse_y > 360/2)
  3802. mouse_3d_y -= (HIWORD(lParam)-(mouse_y-360))/sensitivity;
  3803. else if (LOWORD(lParam) > 360/2)
  3804. mouse_3d_y -= ((HIWORD(lParam)-360)-mouse_y)/sensitivity;
  3805. }
  3806. else
  3807. { 
  3808. mouse_3d_y -= (HIWORD(lParam)-mouse_y)/sensitivity;
  3809. } 
  3810. }
  3811. else
  3812. {
  3813. if (ABS(mouse_y-HIWORD(lParam)) > 300)
  3814. { 
  3815. if (mouse_y > 360/2)
  3816. mouse_3d_y -= ((mouse_y-360)-HIWORD(lParam))/sensitivity;
  3817. else if (LOWORD(lParam) > 360/2)
  3818. mouse_3d_y -= (mouse_y-(HIWORD(lParam)-360))/sensitivity;
  3819. }
  3820. else
  3821. { 
  3822. mouse_3d_y -= (mouse_y-HIWORD(lParam))/sensitivity;
  3823. } 
  3824. }
  3826. if (mouse_3d_x > 360) mouse_3d_x = 0;
  3827. else if (mouse_3d_x < 0) mouse_3d_x = 360;
  3829. if (mouse_3d_y > 85) mouse_3d_y = 85;
  3830. else if (mouse_3d_y < -85) mouse_3d_y = -85;
  3832. mouse_x = LOWORD(lParam);          
  3833. mouse_y = HIWORD(lParam);
  3834. }
  3836. else if (uMsg == WM_LBUTTONDOWN)
  3837. {     
  3838. isFire = true;
  3839. }
  3841. else if (uMsg == WM_ACTIVATE) // Watch For Window Activate Message
  3842. {
  3843. if (!HIWORD(wParam)) // Check Minimization State
  3844. {
  3845. active=TRUE; // Program Is Active
  3846. }
  3847. else
  3848. {
  3849. active=FALSE; // Program Is No Longer Active
  3850. }
  3852. }
  3853.         
  3854. else if (uMsg == WM_SYSCOMMAND) // Intercept System Commands
  3855. {
  3856. switch (wParam) // Check System Calls
  3857. {
  3858. case SC_SCREENSAVE: // Screensaver Trying To Start?
  3859. case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?
  3861. return 0; // Prevent From Happening
  3862. }
  3863. }
  3864.         
  3865. else if (uMsg == WM_CLOSE) // Did We Receive A Close Message?
  3866. {
  3867.  PostQuitMessage(0); // Send A Quit Message
  3868. }
  3869.         
  3870. else if (uMsg == WM_KEYDOWN) // Is A Key Being Held Down?
  3871. {
  3872. keys[wParam] = TRUE; // If So, Mark It As TRUE
  3873. }
  3874.         
  3875. else if (uMsg == WM_KEYUP) // Has A Key Been Released?
  3876. {
  3877. keys[wParam] = FALSE; // If So, Mark It As FALSE
  3878. }
  3879.         
  3880. else if (uMsg == WM_SIZE) // Resize The OpenGL Window
  3881. {
  3882. ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height
  3883. }        
  3885. // Pass All Unhandled Messages To DefWindowProc
  3886. return DefWindowProc(hWnd,uMsg,wParam,lParam);
  3887. }
  3889. int is_Fired = 0; 
  3891. int WINAPI WinMain( HINSTANCE hInstance, // Instance
  3892. HINSTANCE hPrevInstance, // Previous Instance
  3893. LPSTR lpCmdLine, // Command Line Parameters
  3894. int nCmdShow) // Window Show State
  3895. {
  3896. MSG msg; // Windows Message Structure
  3897. BOOL done=FALSE; // Bool Variable To Exit Loop
  3899. // Ask The User Which Screen Mode They Prefer
  3900. if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode(Support Mouse Movement)?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
  3901. {
  3902. fullscreen=FALSE; // Windowed Mode
  3903. }
  3905. // Create Our OpenGL Window
  3906. if (!CreateGLWindow("First Person Shooter",640,480,16,fullscreen))
  3907. {
  3908. return 0; // Quit If Window Was Not Created
  3909. }
  3911. while(!done) // Loop That Runs While done=FALSE
  3912. {
  3913. if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
  3914. {
  3915. if (msg.message==WM_QUIT) // Have We Received A Quit Message?
  3916. {
  3917. done=TRUE; // If So done=TRUE
  3918. }
  3919. else // If Not, Deal With Window Messages
  3920. {
  3921. TranslateMessage(&msg); // Translate The Message
  3922. DispatchMessage(&msg); // Dispatch The Message
  3923. }
  3924. }
  3925. else // If There Are No Messages
  3926. {
  3927. // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
  3928. if ((active && !DrawGLScene()) || keys[VK_ESCAPE]) // Active?  Was There A Quit Received?
  3929. {
  3930. done=TRUE; // ESC or DrawGLScene Signalled A Quit
  3931. }
  3932. else // Not Time To Quit, Update Screen
  3933. {
  3934. SwapBuffers(hDC); // Swap Buffers (Double Buffering)
  3936. is_Fired--;
  3937. if (is_Fired < 0) is_Fired = 0;
  3939. if (keys[VK_UP])  // Move forwards
  3940. {
  3941. XP -= (GLdouble)sin(heading*piover180) * 10.0f;
  3942. ZP -= (GLdouble)cos(heading*piover180) * 10.0f;
  3943. }
  3944. else if (keys['W'])  // Move forwards
  3945. {
  3946. XP -= (GLdouble)sin(heading*piover180) * 10.0f;
  3947. ZP -= (GLdouble)cos(heading*piover180) * 10.0f;
  3948. }
  3950. if (keys[VK_DOWN]) // Move backwards
  3951. {
  3952. XP += (GLdouble)sin(heading*piover180) * 10.0f;
  3953. ZP += (GLdouble)cos(heading*piover180) * 10.0f;
  3954. }                
  3955. else if (keys['S']) // Move backwards
  3956. {
  3957. XP += (GLdouble)sin(heading*piover180) * 10.0f;
  3958. ZP += (GLdouble)cos(heading*piover180) * 10.0f;
  3959. }
  3961. if (keys['A'])  // strafe left
  3962. {
  3963. XP += (GLdouble)sin((heading-90)*piover180) * 10.0f;
  3964. ZP += (GLdouble)cos((heading-90)*piover180) * 10.0f;
  3965. }
  3967. if (keys['D']) // strafe right
  3968. {
  3969. XP += (GLdouble)sin((heading+90)*piover180) * 10.0f;
  3970. ZP += (GLdouble)cos((heading+90)*piover180) * 10.0f;
  3971. }                
  3973. if (keys[VK_LEFT]) // Turn left
  3974. {
  3975. zprot += .5f;
  3976. }
  3977. else if (keys[VK_RIGHT]) // Turn right
  3978. {
  3979. zprot -= .5f;
  3980. }
  3982. if (keys['F'] && !fp) // Toggle Frame Per Second Counter
  3983. {
  3984. isFPS = !isFPS;
  3985. fp = true;
  3986. }
  3987. else if (!keys['F'])
  3988. {
  3989. fp = false;
  3990. }        
  3992. if (keys['I'] && !ip) // Invert y-axis for the mouse
  3993. {
  3994. invert_mouse = !invert_mouse;
  3995. ip = true;
  3996. }
  3997. else if (!keys['I'])
  3998. {
  3999. ip = false;
  4000. }
  4001. }
  4002. }
  4003. }
  4005. // Shutdown
  4006. KillGLWindow(); // Kill The Window
  4007. return (msg.wParam); // Exit The Program
  4008. }