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

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

射击游戏

开发平台：

Visual C++

BackUp_03.txt：源码内容
  1. //Game AI, all walls+ All Detect Collision on Walls + Separate Function + 6 Monsters + 99.1%
  2. #include <windows.h> // Header File For Windows
  3. #include <math.h> // Math Library Header File
  4. #include <stdio.h> // Header File For Standard Input/Output
  5. #include <glgl.h> // Header File For The OpenGL32 Library
  6. #include <glglu.h> // Header File For The GLu32 Library
  7. #include <glglaux.h> // Header File For The Glaux Library
  8. #include <stdlib.h>
  9. #include <mmsystem.h>
  11. #include "main.h"
  12. #include "Md2.h"
  14. #pragma comment( lib, "opengl32.lib") // Search For OpenGL32.lib While Linking
  15. #pragma comment( lib, "glu32.lib")
  16. #pragma comment( lib, "glaux.lib")
  17. #pragma comment( lib, "winmm.lib")
  19. HDC hDC=NULL; // Private GDI Device Context
  20. HGLRC hRC=NULL; // Permanent Rendering Context
  21. HWND hWnd=NULL; // Holds Our Window Handle
  22. HINSTANCE hInstance; // Holds The Instance Of The Application
  24. GLdouble WIDTH;
  25. GLdouble HEIGHT;
  27. bool  keys[256]; // Array Used For The Keyboard Routine
  28. bool  fp;
  29. bool  ip;
  30. bool active=TRUE; // Window Active Flag Set To TRUE By Default
  31. bool fullscreen=TRUE; // Fullscreen Flag Set To Fullscreen Mode By Default
  32. bool gameOver;
  33. bool gameOverOnX;
  34. bool gameOverOnZ;
  36. GLdouble mouse_x, mouse_y;
  37. GLdouble mouse_3d_x, mouse_3d_y;
  38. int mouse_wrap_x = 0;
  39. int mouse_wrap_y = 0;
  40. bool invert_mouse = false;  // Used to invert the y-axis for the mouse
  41. GLdouble sensitivity = 64;  // the higher the #, the lower mouse the sensitivity.
  43. const CELL = 256;
  44. #define MAX_PARTICLES 45
  45. #define MAX_SHOTS_FIRED 45
  47. #define FILE_NAME  "tris.md2" // This is the 3D file we will load.
  48. #define TEXTURE_NAME "hobgoblin.bmp"
  49. CLoadMD2 g_LoadMd2; // This is MD2 class.  This should go in a good model class.
  50. t3DModel g_3DModel; // This holds the 3D Model info that we load in
  51. typedef struct
  52. { 
  53. bool  trigger;
  54. bool  hitStatus;
  55. int   hitCount;
  56. float transX;
  57. float transXSpeed;
  58. float transXSpare;
  59. float transY; 
  60. float transZ;
  61. float transZSpeed;
  62. float transZSpare;
  63. float rotateY;
  64. float rotateYSpeed;
  65. float fall;
  66. float rotateX;
  67. float rotateXSpeed;
  68. float XMultiplier ;  
  69. }
  70. Monsters;
  71. Monsters Monster[6];
  73. GLdouble yrot=0; // Y Rotation
  75. const GLdouble piover180 = 0.0174532925f;
  76. GLdouble XP=0;
  77. GLdouble ZP=0;
  79. GLdouble sceneroty;
  80. GLdouble heading;
  81. GLdouble _heading = 0;
  82. GLdouble zprot;
  84. int frames = 0;
  86. GLdouble FPS = 0;
  88. GLdouble fire_x = 0;
  89. GLdouble fire_y = 10;
  90. GLdouble fire_xp, fire_yp;
  91. GLdouble fire_z = 0;
  92. GLdouble fire_zp = 0;
  93. GLdouble fire_delay = 0;
  95. int shots_fired = 0;
  97. typedef struct // Create A Structure For Particle
  98. {
  99. GLdouble life; // Particle Life
  100. GLdouble fade; // Fade Speed
  101. GLdouble size; // Fade Speed
  102. GLdouble triangle_x1; // X vertex
  103. GLdouble triangle_x2; // X vertex
  104. GLdouble triangle_x3; // X vertex
  105. GLdouble triangle_y1; // Y vertex
  106. GLdouble triangle_y2; // Y vertex
  107. GLdouble triangle_y3; // Y vertex
  108. GLdouble triangle_z1; // Z vertex
  109. GLdouble triangle_z2; // Z vertex
  110. GLdouble triangle_z3; // Z vertex
  111. GLdouble triangle_rotate_x; // X Rotate
  112. GLdouble triangle_rotate_y; // X Rotate
  113. GLdouble triangle_rotate_z; // X Rotate
  114. GLdouble triangle_rotate_xi; // X Rotate
  115. GLdouble triangle_rotate_yi; // X Rotate
  116. GLdouble triangle_rotate_zi; // X Rotate
  117. GLdouble x; // X Position
  118. GLdouble y; // Y Position
  119. GLdouble z; // Z Position
  120. GLdouble xi; // X Direction
  121. GLdouble yi; // Y Direction
  122. GLdouble zi; // Z Direction
  123. }
  124. particles; // Particles Structure
  126. particles particle[MAX_PARTICLES][MAX_SHOTS_FIRED];
  128. float m16_kick = 0;
  129. float m16_kicki = 0; 
  131. bool isFire = false;
  132. bool isFireComplete = true;
  133. bool isRicochet = false;
  135. GLdouble BlankNum = 0;
  137. BOOL done=FALSE; // Bool Variable To Exit Loop
  138. bool isFPS=FALSE;
  140. GLuint texture[6];
  142. // Absolute value function(comes in handy later).
  143. inline GLdouble ABS(GLdouble A)
  144. {
  145.   if (A < 0)
  146.   A = -A; 
  147.   return A;
  148. }
  150. // Hypotenuse Function
  151. inline GLdouble Hypot(GLdouble a, GLdouble b)
  152. {
  153.   return sqrt((a*a)+(b*b));
  154. }
  156. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc
  157. GLvoid KillGLWindow(GLvoid);
  159. typedef struct // Create A Structure
  160. {
  161. GLubyte *imageData; // Image Data (Up To 32 Bits)
  162. GLuint bpp; // Image Color Depth In Bits Per Pixel.
  163. GLuint width; // Image Width
  164. GLuint height; // Image Height
  165. GLuint texID; // Texture ID Used To Select A Texture
  166. } TextureImage; // Structure Name
  168. GLuint base; // Base Display List For The Font
  169. TextureImage textures[1];
  171. bool LoadTGA(TextureImage *texture, char *filename) // Loads A TGA File Into Memory
  172. {    
  173. GLubyte TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0}; // Uncompressed TGA Header
  174. GLubyte TGAcompare[12]; // Used To Compare TGA Header
  175. GLubyte header[6]; // First 6 Useful Bytes From The Header
  176. GLuint bytesPerPixel; // Holds Number Of Bytes Per Pixel Used In The TGA File
  177. GLuint imageSize; // Used To Store The Image Size When Setting Aside Ram
  178. GLuint temp; // Temporary Variable
  179. GLuint type=GL_RGBA; // Set The Default GL Mode To RBGA (32 BPP)
  181. FILE *file = fopen(filename, "rb"); // Open The TGA File
  183. if( file==NULL || // Does File Even Exist?
  184. fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) || // Are There 12 Bytes To Read?
  185. memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 || // Does The Header Match What We Want?
  186. fread(header,1,sizeof(header),file)!=sizeof(header)) // If So Read Next 6 Header Bytes
  187. {
  188. if (file == NULL) // Did The File Even Exist? *Added Jim Strong*
  189. return false; // Return False
  190. else
  191. {
  192. fclose(file); // If Anything Failed, Close The File
  193. return false; // Return False
  194. }
  195. }
  197. texture->width  = header[1] * 256 + header[0]; // Determine The TGA Width (highbyte*256+lowbyte)
  198. texture->height = header[3] * 256 + header[2]; // Determine The TGA Height (highbyte*256+lowbyte)
  199.     
  200.   if( texture->width <=0 || // Is The Width Less Than Or Equal To Zero
  201. texture->height <=0 || // Is The Height Less Than Or Equal To Zero
  202. (header[4]!=24 && header[4]!=32)) // Is The TGA 24 or 32 Bit?
  203. {
  204. fclose(file); // If Anything Failed, Close The File
  205. return false; // Return False
  206. }
  208. texture->bpp = header[4]; // Grab The TGA's Bits Per Pixel (24 or 32)
  209. bytesPerPixel = texture->bpp/8; // Divide By 8 To Get The Bytes Per Pixel
  210. imageSize = texture->width*texture->height*bytesPerPixel; // Calculate The Memory Required For The TGA Data
  212. texture->imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data
  214. if( texture->imageData==NULL || // Does The Storage Memory Exist?
  215. fread(texture->imageData, 1, imageSize, file)!=imageSize) // Does The Image Size Match The Memory Reserved?
  216. {
  217. if(texture->imageData!=NULL) // Was Image Data Loaded
  218. free(texture->imageData); // If So, Release The Image Data
  220. fclose(file); // Close The File
  221. return false; // Return False
  222. }
  224. for(GLuint i=0; i<int(imageSize); i+=bytesPerPixel) // Loop Through The Image Data
  225. { // Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)
  226. temp=texture->imageData[i]; // Temporarily Store The Value At Image Data 'i'
  227. texture->imageData[i] = texture->imageData[i + 2]; // Set The 1st Byte To The Value Of The 3rd Byte
  228. texture->imageData[i + 2] = temp; // Set The 3rd Byte To The Value In 'temp' (1st Byte Value)
  229. }
  231. fclose (file); // Close The File
  233. // Build A Texture From The Data
  234. glGenTextures(1, &texture[0].texID); // Generate OpenGL texture IDs
  236. glBindTexture(GL_TEXTURE_2D, texture[0].texID); // Bind Our Texture
  237. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Filtered
  238. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtered
  240. if (texture[0].bpp==24) // Was The TGA 24 Bits
  241. {
  242. type=GL_RGB; // If So Set The 'type' To GL_RGB
  243. }
  245.     gluBuild2DMipmaps(GL_TEXTURE_2D, type, texture[0].width, texture[0].height, type, GL_UNSIGNED_BYTE, texture[0].imageData);           
  247. return true; // Texture Building Went Ok, Return True
  248. }
  250. GLvoid BuildFont(GLvoid) // Build Our Font Display List
  251. {
  252. base=glGenLists(256); // Creating 256 Display Lists
  253. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  254. for (int loop1=0; loop1<256; loop1++) // Loop Through All 256 Lists
  255. {
  256. float cx=float(loop1%16)/16.0f; // X Position Of Current Character
  257. float cy=float(loop1/16)/16.0f; // Y Position Of Current Character
  259. glNewList(base+loop1,GL_COMPILE); // Start Building A List
  260. glBegin(GL_QUADS); // Use A Quad For Each Character
  261. glTexCoord2f(cx,1.0f-cy-0.0625f); // Texture Coord (Bottom Left)
  262. glVertex2d(0,16); // Vertex Coord (Bottom Left)
  263. glTexCoord2f(cx+0.0625f,1.0f-cy-0.0625f); // Texture Coord (Bottom Right)
  264. glVertex2i(16,16); // Vertex Coord (Bottom Right)
  265. glTexCoord2f(cx+0.0625f,1.0f-cy-0.001f); // Texture Coord (Top Right)
  266. glVertex2i(16,0); // Vertex Coord (Top Right)
  267. glTexCoord2f(cx,1.0f-cy-0.001f); // Texture Coord (Top Left)
  268. glVertex2i(0,0); // Vertex Coord (Top Left)
  269. glEnd(); // Done Building Our Quad (Character)
  270. glTranslated(14,0,0); // Move To The Right Of The Character
  271. glEndList(); // Done Building The Display List
  272. } // Loop Until All 256 Are Built
  273. }
  275. GLvoid KillFont(GLvoid) // Delete The Font From Memory
  276. {
  277. glDeleteLists(base,256); // Delete All 256 Display Lists
  278. }
  280. GLvoid glPrint(GLint x, GLint y, int set, const char *fmt, ...) // Where The Printing Happens
  281. {
  282. char text[1024]; // Holds Our String
  283. va_list ap; // Pointer To List Of Arguments
  285. if (fmt == NULL) // If There's No Text
  286. return; // Do Nothing
  288. va_start(ap, fmt); // Parses The String For Variables
  289.     vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers
  290. va_end(ap); // Results Are Stored In Text
  292. if (set>1) // Did User Choose An Invalid Character Set?
  293. {
  294. set=1; // If So, Select Set 1 (Italic)
  295. }
  297. glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
  298. glLoadIdentity(); // Reset The Modelview Matrix
  299. glTranslated(x,y,-500); // Position The Text (0,0 - Top Left)
  300. glRotatef(180,0,0,1);
  301. glRotatef(180,0,1,0);
  302. glListBase(base-32+(128*set)); // Choose The Font Set (0 or 1)
  304. glCallLists(strlen(text),GL_UNSIGNED_BYTE, text); // Write The Text To The Screen
  305. glDisable(GL_TEXTURE_2D); // Disable Texture Mapping
  306. }
  308. AUX_RGBImageRec *LoadBMP(char *Filename) // Loads A Bitmap Image
  309. {
  310. FILE *File=NULL; // File Handle
  312. if (!Filename) // Make Sure A Filename Was Given
  313. {
  314. return NULL; // If Not Return NULL
  315. }
  317. File=fopen(Filename,"r"); // Check To See If The File Exists
  319. if (File) // Does The File Exist?
  320. {
  321. fclose(File); // Close The Handle
  322. return auxDIBImageLoad(Filename); // Load The Bitmap And Return A Pointer
  323. }
  325. return NULL; // If Load Failed Return NULL
  326. }
  328. // Create A Structure For The Timer Information
  329. struct
  330. {
  331.   __int64       frequency;          // Timer Frequency
  332.   GLdouble            resolution;          // Timer Resolution
  333.   unsigned long mm_timer_start;     
  334.   
  335.   // Multimedia Timer Start Value
  336.   unsigned long mm_timer_elapsed;      // Multimedia Timer Elapsed Time
  337.   bool   performance_timer;    
  338.   
  339.   // Using The Performance Timer?
  340.   __int64       performance_timer_start;      // Performance Timer Start Value
  341.   __int64       performance_timer_elapsed; // Performance Timer Elapsed Time
  342. } timer;
  344. // Initialize Our Timer
  345. void TimerInit(void)
  346. {
  347.      memset(&timer, 0, sizeof(timer));   
  348.  // Clear Our Timer Structure
  349.      // Check To See If A Performance Counter Is Available
  350.      // If One Is Available The Timer Frequency Will Be Updated
  351.      if (!QueryPerformanceFrequency((LARGE_INTEGER *) &timer.frequency))
  352.      {
  353.           // No Performace Counter Available
  354.           timer.performance_timer = FALSE;                      // Set Performance Timer To FALSE
  355.           timer.mm_timer_start = timeGetTime();                 // Use timeGetTime()
  356.           timer.resolution  = 1.0f/1000.0f;                           // Set Our Timer Resolution To .001f
  357.           timer.frequency   = 1000;                                     // Set Our Timer Frequency To 1000
  358.           timer.mm_timer_elapsed = timer.mm_timer_start; // Set The Elapsed Time
  359.      }
  360.      else
  361.      {
  362.           // Performance Counter Is Available, Use It Instead Of The Multimedia Timer
  363.           // Get The Current Time And Store It In performance_timer_start
  364.           QueryPerformanceCounter((LARGE_INTEGER *) &timer.performance_timer_start);
  365.           timer.performance_timer   = TRUE;    // Set Performance Timer To TRUE
  366.           // Calculate The Timer Resolution Using The Timer Frequency
  367.           timer.resolution    = (GLdouble) (((double)1.0f)/((double)timer.frequency));
  368.           // Set The Elapsed Time To The Current Time
  369.           timer.performance_timer_elapsed = timer.performance_timer_start;
  370.      }
  371. }
  373. // Get Time In Milliseconds
  374. inline GLdouble TimerGetTime()
  375. {
  376.   __int64 time;                                  // 'time' Will Hold A 64 Bit Integer
  377.   if (timer.performance_timer)           // Are We Using The Performance Timer?
  378.   {
  379.     QueryPerformanceCounter((LARGE_INTEGER *) &time); // Current Performance Time
  380.     // Return The Time Elapsed since TimerInit was called
  381.     return ( (GLdouble) ( time - timer.performance_timer_start) * timer.resolution)*1000.0f;
  382.   }
  383.   else
  384.   {
  385.     // Return The Time Elapsed since TimerInit was called
  386.     return ( (GLdouble) ( timeGetTime() - timer.mm_timer_start) * timer.resolution)*1000.0f;
  387.   }
  388. }
  390. int LoadGLTextures() // Load Bitmap And Convert To A Texture
  391. {
  392.   int Status=FALSE; // Status Indicator
  393.   AUX_RGBImageRec *TextureImage[1]; // Create Storage Space For The Textures
  394.   memset(TextureImage,0,sizeof(void *)*1); // Set The Pointer To NULL
  396.   if (TextureImage[0]=LoadBMP("Data/walls.bmp")) // Load Particle Texture
  397.   {
  398.     Status=TRUE; // Set The Status To TRUE
  399.     glGenTextures(1, &texture[1]); // Create One Texture
  401.     // Create MipMapped Texture
  402.     glBindTexture(GL_TEXTURE_2D, texture[1]);
  403.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  404.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  405.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  406.   }
  408.   if (TextureImage[0]=LoadBMP("Data/crosshair.bmp")) // Load Particle Texture
  409.   {
  410.     Status=TRUE; // Set The Status To TRUE
  411.     glGenTextures(1, &texture[2]); // Create One Texture
  413.     // Create MipMapped Texture
  414.     glBindTexture(GL_TEXTURE_2D, texture[2]);
  415.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  416.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  417.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  418.   }
  420.   if (TextureImage[0]=LoadBMP("Data/smoke.bmp")) // Load Particle Texture
  421.   {
  422.     Status=TRUE; // Set The Status To TRUE
  423.     glGenTextures(1, &texture[3]); // Create One Texture
  425.     // Create MipMapped Texture
  426.     glBindTexture(GL_TEXTURE_2D, texture[3]);
  427.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  428.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  429.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  430.   }
  432.   if (TextureImage[0]=LoadBMP("hobgoblin.bmp")) // Load Particle Texture
  433.   {
  434.     Status=TRUE; // Set The Status To TRUE
  435.     glGenTextures(1, &texture[4]); // Create One Texture
  437.     // Create MipMapped Texture
  438.     glBindTexture(GL_TEXTURE_2D, texture[4]);
  439.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  440.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  441.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  442.   }
  444.   if (TextureImage[0]=LoadBMP("Data/exit.bmp")) // Load Particle Texture
  445.   {
  446.     Status=TRUE; // Set The Status To TRUE
  447.     glGenTextures(1, &texture[5]); // Create One Texture
  449.     // Create MipMapped Texture
  450.     glBindTexture(GL_TEXTURE_2D, texture[5]);
  451.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  452.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  453.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  454.   }
  456.   if (TextureImage[0]=LoadBMP("Data/floor.bmp")) // Load Particle Texture
  457.   {
  458.     Status=TRUE; // Set The Status To TRUE
  459.     glGenTextures(1, &texture[6]); // Create One Texture
  461.     // Create MipMapped Texture
  462.     glBindTexture(GL_TEXTURE_2D, texture[6]);
  463.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  464.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  465.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);           
  466.   }
  468.   if (TextureImage[0]) // If Texture Exists
  469. {
  470.     if (TextureImage[0]->data) // If Texture Image Exists
  471.     {
  472.       free(TextureImage[0]->data); // Free The Texture Image Memory
  473.     }
  474.     free(TextureImage[0]); // Free The Image Structure
  475.   }
  477.   return Status; // Return The Status
  478. }
  480. GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
  481. {
  482. if (height==0) // Prevent A Divide By Zero By
  483. {
  484. height=1; // Making Height Equal One
  485. }
  487. WIDTH=width;
  488. HEIGHT=height;
  489. glViewport(0,0,width,height); // Reset The Current Viewport
  491. glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
  492. glLoadIdentity(); // Reset The Projection Matrix
  494. // Calculate The Aspect Ratio Of The Window
  495. glLoadIdentity(); // Reset The Modelview Matrix
  496. gluPerspective(60.0f,(GLdouble)width/(GLdouble)height,1.0f,1250.0f);
  498. glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
  499. glLoadIdentity(); // Reset The Modelview Matrix
  500. }
  502. static GLuint ROOM[18], MODEL; // Storage For The Room Display List
  504. GLdouble xtrans2 = CELL*5-40.0f; // fail if 80.0f?
  505. GLdouble ytrans2 = 10;
  506. GLdouble ztrans2 = CELL*7-40.0f;
  508. GLdouble xtrans = 0;
  509. GLdouble ztrans = 0;
  511. // Build Cube Display Lists
  512. GLvoid BuildLists()
  513. { 
  514. ROOM[0]=glGenLists(18); // IDENTITY[IJ=1 1], Generate 18 Different Lists
  515.     glNewList(ROOM[0],GL_COMPILE); // Start With The Box List
  516.     
  517. glBindTexture(GL_TEXTURE_2D, texture[6]); 
  518.    
  519. glBegin(GL_QUADS);//bottom
  520. glTexCoord2d(20,28);  glVertex3d(CELL*5,0,CELL*7);
  521. glTexCoord2d(20,0);  glVertex3d(CELL*5,0,0);
  522. glTexCoord2d(0,0);  glVertex3d(0,0,0);
  523. glTexCoord2d(0,28);  glVertex3d(0,0,CELL*7);
  524. glEnd();
  526. glBegin(GL_QUADS);//top
  527. glTexCoord2d(20,28);  glVertex3d(CELL*5,CELL/4,CELL*7);
  528. glTexCoord2d(20,0);  glVertex3d(CELL*5,CELL/4,0);
  529. glTexCoord2d(0,0);  glVertex3d(0,CELL/4,0);
  530. glTexCoord2d(0,28);  glVertex3d(0,CELL/4,CELL*7);
  531. glEnd(); 
  532. /////////////////////////Wall Start///////////////////////////////////
  533.  
  534. glBindTexture(GL_TEXTURE_2D, texture[1]); 
  535. glBegin(GL_QUADS);//front
  536. glTexCoord2d(4,1);  glVertex3d(CELL*5,CELL/4,CELL*6);
  537. glTexCoord2d(4,0);  glVertex3d(CELL*5,0,CELL*6);
  538. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*6);
  539. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*6);
  540. glEnd();
  542. glBegin(GL_QUADS);//back
  543. glTexCoord2d(4,1);  glVertex3d(CELL*5,CELL/4,CELL*7);
  544. glTexCoord2d(4,0);  glVertex3d(CELL*5,0,CELL*7);
  545. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*7);
  546. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*7);
  547. glEnd();
  549. glBegin(GL_QUADS);//right
  550. glTexCoord2d(4,1);  glVertex3d(CELL*5,CELL/4,CELL*7);
  551. glTexCoord2d(4,0);  glVertex3d(CELL*5,0,CELL*7);
  552. glTexCoord2d(0,0);  glVertex3d(CELL*5,0,CELL*6);
  553. glTexCoord2d(0,1);  glVertex3d(CELL*5,CELL/4,CELL*6);
  554. glEnd();
  555. /////////////////////////Wall End///////////////////////////////////
  556.     glEndList();
  558. ROOM[1]=ROOM[0]+1;//IDENTITY[IJ=2 1]
  559. glNewList(ROOM[1],GL_COMPILE);
  560.  
  561. glBegin(GL_QUADS);//back
  562. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*7);
  563. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*7);
  564. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*7);
  565. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*7);
  566. glEnd();
  568. glBegin(GL_QUADS);//right
  569. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*7);
  570. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*7);
  571. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*6);
  572. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*6);
  573. glEnd();
  574. /////////////////////////Wall End///////////////////////////////////
  575.     glEndList();
  577. ROOM[2]=ROOM[1]+1;//IDENTITY[IJ=2 2]
  578. glNewList(ROOM[2],GL_COMPILE);  
  579.  
  580. glBegin(GL_QUADS);//right
  581. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*6);
  582. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*6);
  583. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*5);
  584. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*5);
  585. glEnd();
  586. /////////////////////////Wall End///////////////////////////////////
  587.     glEndList();
  589. ROOM[3]=ROOM[2]+1;//IDENTITY[IJ=2 3]
  590. glNewList(ROOM[3],GL_COMPILE); 
  591.  
  592. glBegin(GL_QUADS);//left
  593. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*5);
  594. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*5);
  595. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*4);
  596. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*4);
  597. glEnd();  
  599. glBegin(GL_QUADS);//right
  600. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*5);
  601. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*5);
  602. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*4);
  603. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*4);
  604. glEnd();
  605. /////////////////////////Wall End///////////////////////////////////
  606.     glEndList();
  608. ROOM[4]=ROOM[3]+1;//IDENTITY[IJ=2 4]
  609. glNewList(ROOM[4],GL_COMPILE); 
  610.  
  611. glBegin(GL_QUADS);//front
  612. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  613. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*3);
  614. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*3);
  615. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*3);
  616. glEnd(); 
  618. glBegin(GL_QUADS);//right
  619. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*4);
  620. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*4);
  621. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*3);
  622. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  623. glEnd();
  624. /////////////////////////Wall End///////////////////////////////////
  625.     glEndList();
  627. ROOM[4]=ROOM[3]+1;//IDENTITY[IJ=2 4]
  628. glNewList(ROOM[4],GL_COMPILE); 
  629.  
  630. glBegin(GL_QUADS);//front
  631. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  632. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*3);
  633. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*3);
  634. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*3);
  635. glEnd(); 
  637. glBegin(GL_QUADS);//right
  638. glTexCoord2d(4,1);  glVertex3d(CELL*4,CELL/4,CELL*4);
  639. glTexCoord2d(4,0);  glVertex3d(CELL*4,0,CELL*4);
  640. glTexCoord2d(0,0);  glVertex3d(CELL*4,0,CELL*3);
  641. glTexCoord2d(0,1);  glVertex3d(CELL*4,CELL/4,CELL*3);
  642. glEnd();
  643. /////////////////////////Wall End///////////////////////////////////
  644.     glEndList();
  646. ROOM[5]=ROOM[4]+1;//IDENTITY[IJ=3 2]
  647. glNewList(ROOM[5],GL_COMPILE); 
  648.  
  649. glBegin(GL_QUADS);//front
  650. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*5);
  651. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*5);
  652. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*5);
  653. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*5);
  654. glEnd(); 
  656. glBegin(GL_QUADS);//back
  657. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*6);
  658. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*6);
  659. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*6);
  660. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*6);
  661. glEnd();
  662. /////////////////////////Wall End///////////////////////////////////
  663.     glEndList();
  665. ROOM[6]=ROOM[5]+1;//IDENTITY[IJ=3 4]
  666. glNewList(ROOM[6],GL_COMPILE); 
  667.  
  668. glBegin(GL_QUADS);//back
  669. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*4);
  670. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*4);
  671. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*4);
  672. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*4);
  673. glEnd();  
  674. /////////////////////////Wall End///////////////////////////////////
  675.     glEndList();
  677. ROOM[7]=ROOM[6]+1;//IDENTITY[IJ=3 5]
  678. glNewList(ROOM[7],GL_COMPILE); 
  679.  
  680. glBegin(GL_QUADS);//left
  681. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*3);
  682. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*3);
  683. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL*2);
  684. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL*2);
  685. glEnd(); 
  687. glBegin(GL_QUADS);//right
  688. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*3);
  689. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*3);
  690. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL*2);
  691. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL*2);
  692. glEnd();
  693. /////////////////////////Wall End///////////////////////////////////
  694.     glEndList();
  696. ROOM[8]=ROOM[7]+1;//IDENTITY[IJ=3 6]
  697. glNewList(ROOM[8],GL_COMPILE); 
  698.  
  699. glBegin(GL_QUADS);//front
  700. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL);
  701. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL);
  702. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL);
  703. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL);
  704. glEnd(); 
  706. glBegin(GL_QUADS);//left
  707. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*2);
  708. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*2);
  709. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,CELL);
  710. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,CELL);
  711. glEnd(); 
  713. glBegin(GL_QUADS);//right
  714. glTexCoord2d(4,1);  glVertex3d(CELL*3,CELL/4,CELL*2);
  715. glTexCoord2d(4,0);  glVertex3d(CELL*3,0,CELL*2);
  716. glTexCoord2d(0,0);  glVertex3d(CELL*3,0,CELL);
  717. glTexCoord2d(0,1);  glVertex3d(CELL*3,CELL/4,CELL);
  718. glEnd();
  719. /////////////////////////Wall End///////////////////////////////////
  720.     glEndList();
  722. ROOM[9]=ROOM[8]+1;//IDENTITY[IJ=4 2]
  723. glNewList(ROOM[9],GL_COMPILE); 
  724.  
  725. glBegin(GL_QUADS);//front
  726. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*5);
  727. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*5);
  728. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*5);
  729. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*5);
  730. glEnd(); 
  732. glBegin(GL_QUADS);//back
  733. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*6);
  734. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*6);
  735. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*6);
  736. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*6);
  737. glEnd();
  738. /////////////////////////Wall End///////////////////////////////////
  739.     glEndList();
  741. ROOM[10]=ROOM[9]+1;//IDENTITY[IJ=4 4]
  742. glNewList(ROOM[10],GL_COMPILE); 
  743.  
  744. glBegin(GL_QUADS);//front
  745. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*3);
  746. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*3);
  747. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*3);
  748. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*3);
  749. glEnd(); 
  751. glBegin(GL_QUADS);//back
  752. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*4);
  753. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*4);
  754. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*4);
  755. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*4);
  756. glEnd();
  757. /////////////////////////Wall End///////////////////////////////////
  758.     glEndList();
  760. ROOM[11]=ROOM[10]+1;//IDENTITY[IJ=4 6]
  761. glNewList(ROOM[11],GL_COMPILE); 
  762.  
  763. glBegin(GL_QUADS);//back
  764. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL*2);
  765. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL*2);
  766. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*2);
  767. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*2);
  768. glEnd(); 
  769. /////////////////////////Wall End///////////////////////////////////
  770.     glEndList();
  772. ROOM[12]=ROOM[11]+1;//IDENTITY[IJ=4 7]
  773. glNewList(ROOM[12],GL_COMPILE); 
  775. glBindTexture(GL_TEXTURE_2D, texture[5]); 
  776. glBegin(GL_QUADS);//front
  777. glTexCoord2d(1,1);  glVertex3d(CELL*2-CELL*3/8,CELL/4,0);
  778. glTexCoord2d(1,0);  glVertex3d(CELL*2-CELL*3/8,0,0);
  779. glTexCoord2d(0,0);  glVertex3d(CELL+CELL*3/8,0,0);
  780. glTexCoord2d(0,1);  glVertex3d(CELL+CELL*3/8,CELL/4,0);
  781. glEnd(); 
  782.  
  783. glBindTexture(GL_TEXTURE_2D, texture[1]);
  784. glBegin(GL_QUADS);//front left
  785. glTexCoord2d(1.5,1);  glVertex3d(CELL+CELL*3/8,CELL/4,0);
  786. glTexCoord2d(1.5,0);  glVertex3d(CELL+CELL*3/8,0,0);
  787. glTexCoord2d(0,0);  glVertex3d(CELL,0,0);
  788. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,0);
  789. glEnd();
  791. glBegin(GL_QUADS);//front right
  792. glTexCoord2d(1.5,1);  glVertex3d(CELL*2,CELL/4,0);
  793. glTexCoord2d(1.5,0);  glVertex3d(CELL*2,0,0);
  794. glTexCoord2d(0,0);  glVertex3d(CELL*2-CELL*3/8,0,0);
  795. glTexCoord2d(0,1);  glVertex3d(CELL*2-CELL*3/8,CELL/4,0);
  796. glEnd();
  798. glBegin(GL_QUADS);//left
  799. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL);
  800. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL);
  801. glTexCoord2d(0,0);  glVertex3d(CELL,0,0);
  802. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,0);
  803. glEnd();  
  805. glBegin(GL_QUADS);//right
  806. glTexCoord2d(4,1);  glVertex3d(CELL*2,CELL/4,CELL);
  807. glTexCoord2d(4,0);  glVertex3d(CELL*2,0,CELL);
  808. glTexCoord2d(0,0);  glVertex3d(CELL*2,0,0);
  809. glTexCoord2d(0,1);  glVertex3d(CELL*2,CELL/4,0);
  810. glEnd();
  812. /////////////////////////Wall End///////////////////////////////////
  813.     glEndList();
  815. ROOM[13]=ROOM[12]+1;//IDENTITY[IJ=5 2]
  816. glNewList(ROOM[13],GL_COMPILE); 
  817.  
  818. glBegin(GL_QUADS);//back
  819. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*6);
  820. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*6);
  821. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*6);
  822. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*6);
  823. glEnd(); 
  825. glBegin(GL_QUADS);//left
  826. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*6);
  827. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*6);
  828. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*5);
  829. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*5);
  830. glEnd();  
  831. /////////////////////////Wall End///////////////////////////////////
  832.     glEndList();
  834. ROOM[14]=ROOM[13]+1;//IDENTITY[IJ=5 3]
  835. glNewList(ROOM[14],GL_COMPILE); 
  836.  
  837. glBegin(GL_QUADS);//front
  838. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*4);
  839. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*4);
  840. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*4);
  841. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*4);
  842. glEnd(); 
  844. glBegin(GL_QUADS);//left
  845. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*5);
  846. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*5);
  847. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*4);
  848. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*4);
  849. glEnd(); 
  851. glBegin(GL_QUADS);//right
  852. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*5);
  853. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*5);
  854. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*4);
  855. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*4);
  856. glEnd();
  857. /////////////////////////Wall End///////////////////////////////////
  858.     glEndList();
  860. ROOM[15]=ROOM[14]+1;//IDENTITY[IJ=5 4]
  861. glNewList(ROOM[15],GL_COMPILE); 
  862.  
  863. glBegin(GL_QUADS);//left
  864. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*4);
  865. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*4);
  866. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*3);
  867. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*3);
  868. glEnd();  
  869. /////////////////////////Wall End///////////////////////////////////
  870.     glEndList();
  872. ROOM[16]=ROOM[15]+1;//IDENTITY[IJ=5 5]
  873. glNewList(ROOM[16],GL_COMPILE); 
  874.  
  875. glBegin(GL_QUADS);//left
  876. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*3);
  877. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*3);
  878. glTexCoord2d(0,0);  glVertex3d(0,0,CELL*2);
  879. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL*2);
  880. glEnd(); 
  882. glBegin(GL_QUADS);//right
  883. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL*3);
  884. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL*3);
  885. glTexCoord2d(0,0);  glVertex3d(CELL,0,CELL*2);
  886. glTexCoord2d(0,1);  glVertex3d(CELL,CELL/4,CELL*2);
  887. glEnd();
  888. /////////////////////////Wall End///////////////////////////////////
  889.     glEndList();
  891. ROOM[17]=ROOM[16]+1;//IDENTITY[IJ=5 6]
  892. glNewList(ROOM[17],GL_COMPILE); 
  893.  
  894. glBegin(GL_QUADS);//front
  895. glTexCoord2d(4,1);  glVertex3d(CELL,CELL/4,CELL);
  896. glTexCoord2d(4,0);  glVertex3d(CELL,0,CELL);
  897. glTexCoord2d(0,0);  glVertex3d(0,0,CELL);
  898. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL);
  899. glEnd(); 
  901. glBegin(GL_QUADS);//left
  902. glTexCoord2d(4,1);  glVertex3d(0,CELL/4,CELL*2);
  903. glTexCoord2d(4,0);  glVertex3d(0,0,CELL*2);
  904. glTexCoord2d(0,0);  glVertex3d(0,0,CELL);
  905. glTexCoord2d(0,1);  glVertex3d(0,CELL/4,CELL);
  906. glEnd();  
  907. /////////////////////////Wall End///////////////////////////////////
  908.     glEndList();
  910. //glEnable(GL_BLEND);
  911. }
  913. GLvoid BuildLists1()
  914. {
  915. MODEL=glGenLists(1); // Generate 2 Different Lists
  916.     glNewList(MODEL,GL_COMPILE); // Start With The Box List
  917. glDisable(GL_BLEND);
  918. //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
  919. glBindTexture(GL_TEXTURE_2D, texture[4]);
  920. if(g_3DModel.pObject.size() > 0)
  921. {
  922. // Get the current object that we are displaying
  923. t3DObject *pObject = &g_3DModel.pObject[0];
  925. // Render lines or normal triangles mode, depending on the global variable
  926. glBegin(GL_TRIANGLES);
  928. // Go through all of the faces (polygons) of the object and draw them
  929. for(int j = 0; j < pObject->numOfFaces; j++)
  930. {
  931. // Go through each corner of the triangle and draw it.
  932. for(int whichVertex = 0; whichVertex < 3; whichVertex++)
  933. {
  934. // Get the index for each point in the face
  935. int index = pObject->pFaces[j].vertIndex[whichVertex];
  937. // Get the index for each texture coord in the face
  938. int index2 = pObject->pFaces[j].coordIndex[whichVertex];
  940. // Give OpenGL the normal for this vertex.  Notice that we put a 
  941. // - sign in front.  It appears that because of the ordering of Quake2's
  942. // polygons, we need to invert the normal
  943. glNormal3f(-pObject->pNormals[ index ].x, -pObject->pNormals[ index ].y, -pObject->pNormals[ index ].z);
  945. // Make sure there was a UVW map applied to the object or else it won't have tex coords.
  946. if(pObject->pTexVerts) 
  947. {
  948. glTexCoord2f(pObject->pTexVerts[ index2 ].x, pObject->pTexVerts[ index2 ].y);
  949. }
  951. // Pass in the current vertex of the object (Corner of current face)
  952. glVertex3f(pObject->pVerts[ index ].x, pObject->pVerts[ index ].y, pObject->pVerts[ index ].z);
  953. }
  954. }
  956. glEnd();
  957. }
  958. glEnable(GL_BLEND);
  959. glEndList();
  960. }
  962. GLdouble Time1;
  963. GLdouble Time2;
  964. GLdouble DiffTime;
  965. GLdouble StartTime;
  966. LPARAM lParam;
  968. int InitGL(GLvoid) // All Setup For OpenGL Goes Here
  969. {
  970. if (!g_LoadMd2.ImportMD2(&g_3DModel, FILE_NAME, TEXTURE_NAME)) // KEY of Clashing
  971.       return false; 
  973. if (!LoadTGA(&textures[0],"Data/Font.TGA")) // Load The Font Texture
  974. {
  975. return false; // If Loading Failed, Return False
  976. }
  978. if (!LoadGLTextures()) // Jump To Texture Loading Routine
  979.       return false;  
  981. //LPARAM lParam;
  982. SetCursorPos(322,240);
  983. float temp_mouse_x = LOWORD(lParam);
  984. float temp_mouse_y = HIWORD(lParam);
  985. SetCursorPos(320,240);
  987.   BuildLists();
  988.   BuildLists1();
  990.   glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
  991. glClearColor(0, 0, 0, 1.0f); // Black Background
  992.   glEnable(GL_DEPTH_TEST);
  993.   glDepthFunc(GL_LEQUAL);
  994. 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
  1002. }
  1004. // Detect collision and reflect movement if collision is detected
  1005. // cx = x position; cy = y position; cz = z position;
  1006. // cxi = x increment; cyi = y increment; czi = z increment;
  1007. // padding = a square border around the object.  your value will be 1/2 the length of one side of the square
  1008. // bounce = bounce coefficient -- 0 = no bounce; 1 = perfect bounce
  1009. inline bool Collision11(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1010. {
  1011.   bool Status = false;
  1012.   if (cx > CELL*5-padding) //right
  1013.   {
  1014.     cx = CELL*5-padding; 
  1015.     cxi = -cxi;
  1016.     cxi *= bounce; 
  1017.     Status = true;
  1018.   }
  1020.   if (cy > CELL/4-padding) //top
  1021.   {
  1022.     cy = CELL/4-padding; 
  1023.     cyi = -cyi;
  1024.     cyi *= bounce; 
  1025.     Status = true;
  1026.   }
  1027.   else if (cy < 0+padding) //bottom
  1028.   {
  1029.     cy = 0+padding; 
  1030.     cyi = -cyi;
  1031.     cyi *= bounce; 
  1032.     Status = true;
  1033.   }
  1035.   if (cz > CELL*7-padding) //back
  1036.   {
  1037.     cz = CELL*7-padding; 
  1038.     czi = -czi;
  1039.     czi *= bounce; 
  1040.     Status = true;
  1041.   }
  1042.   else if (cz < CELL*6+padding) //front
  1043.   {
  1044.     cz = CELL*6+padding; 
  1045.     czi = -czi;
  1046.     czi *= bounce; 
  1047.     Status = true;
  1048.   }
  1050.   return Status;
  1051. }
  1053. inline bool Collision21(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1054. {
  1055.   bool Status = false;
  1056.   if (cx < CELL*3+padding)//left
  1057.   {
  1058.     cx = CELL*3+padding; 
  1059.     cxi = -cxi;
  1060.     cxi *= bounce; 
  1061.     Status = true;
  1062.   }
  1064.   if (cy > CELL/4-padding) //top
  1065.   {
  1066.     cy = CELL/4-padding; 
  1067.     cyi = -cyi;
  1068.     cyi *= bounce; 
  1069.     Status = true;
  1070.   }
  1071.   else if (cy < 0+padding) //bottom
  1072.   {
  1073.     cy = 0+padding; 
  1074.     cyi = -cyi;
  1075.     cyi *= bounce; 
  1076.     Status = true;
  1077.   }
  1079.   if (cz > CELL*7-padding) //back
  1080.   {
  1081.     cz = CELL*7-padding; 
  1082.     czi = -czi;
  1083.     czi *= bounce; 
  1084.     Status = true;
  1085.   } 
  1087.   return Status;
  1088. }
  1090. inline bool Collision22(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1091. {
  1092.   bool Status = false;
  1093.   if (cx > CELL*4-padding)//right
  1094.   {
  1095.     cx = CELL*4-padding; 
  1096.     cxi = -cxi;
  1097.     cxi *= bounce; 
  1098.     Status = true;
  1099.   }
  1101.   if (cy > CELL/4-padding) //top
  1102.   {
  1103.     cy = CELL/4-padding; 
  1104.     cyi = -cyi;
  1105.     cyi *= bounce; 
  1106.     Status = true;
  1107.   }
  1108.   else if (cy < 0+padding) //bottom
  1109.   {
  1110.     cy = 0+padding; 
  1111.     cyi = -cyi;
  1112.     cyi *= bounce; 
  1113.     Status = true;
  1114.   } 
  1116.   return Status;
  1117. }
  1119. inline bool Collision23(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1120. {
  1121.   bool Status = false;
  1122.   if (cx < CELL*3+padding)//left
  1123.   {
  1124.     cx = CELL*3+padding; 
  1125.     cxi = -cxi;
  1126.     cxi *= bounce; 
  1127.     Status = true;
  1128.   }
  1129.   else if (cx > CELL*4-padding)//right
  1130.   {
  1131.     cx = CELL*4-padding; 
  1132.     cxi = -cxi;
  1133.     cxi *= bounce; 
  1134.     Status = true;
  1135.   }
  1137.   if (cy > CELL/4-padding) //top
  1138.   {
  1139.     cy = CELL/4-padding; 
  1140.     cyi = -cyi;
  1141.     cyi *= bounce; 
  1142.     Status = true;
  1143.   }
  1144.   else if (cy < 0+padding) //bottom
  1145.   {
  1146.     cy = 0+padding; 
  1147.     cyi = -cyi;
  1148.     cyi *= bounce; 
  1149.     Status = true;
  1150.   }
  1152.   return Status;
  1153. }
  1155. inline bool Collision24(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1156. {
  1157.   bool Status = false;
  1158.   if (cx > CELL*4-padding)//right
  1159.   {
  1160.     cx = CELL*4-padding; 
  1161.     cxi = -cxi;
  1162.     cxi *= bounce; 
  1163.     Status = true;
  1164.   }
  1166.   if (cy > CELL/4-padding) //top
  1167.   {
  1168.     cy = CELL/4-padding; 
  1169.     cyi = -cyi;
  1170.     cyi *= bounce; 
  1171.     Status = true;
  1172.   }
  1173.   else if (cy < 0+padding) //bottom
  1174.   {
  1175.     cy = 0+padding; 
  1176.     cyi = -cyi;
  1177.     cyi *= bounce; 
  1178.     Status = true;
  1179.   }
  1181.   if (cz < CELL*3+padding) //front
  1182.   {
  1183.     cz = CELL*3+padding; 
  1184.     czi = -czi;
  1185.     czi *= bounce; 
  1186.     Status = true;
  1187.   }
  1189.   return Status;
  1190. }
  1192. inline bool Collision32(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1193. {
  1194.   bool Status = false; 
  1195.   if (cy > CELL/4-padding) //top
  1196.   {
  1197.     cy = CELL/4-padding; 
  1198.     cyi = -cyi;
  1199.     cyi *= bounce; 
  1200.     Status = true;
  1201.   }
  1202.   else if (cy < 0+padding) //bottom
  1203.   {
  1204.     cy = 0+padding; 
  1205.     cyi = -cyi;
  1206.     cyi *= bounce; 
  1207.     Status = true;
  1208.   }
  1210.   if (cz > CELL*6-padding) //back
  1211.   {
  1212.     cz = CELL*6-padding; 
  1213.     czi = -czi;
  1214.     czi *= bounce; 
  1215.     Status = true;
  1216.   }
  1217.   else if (cz < CELL*5+padding) //front
  1218.   {
  1219.     cz = CELL*5+padding; 
  1220.     czi = -czi;
  1221.     czi *= bounce; 
  1222.     Status = true;
  1223.   }
  1225.   return Status;
  1226. }
  1228. inline bool Collision34(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1229. {
  1230.   bool Status = false; 
  1231.   if (cy > CELL/4-padding) //top
  1232.   {
  1233.     cy = CELL/4-padding; 
  1234.     cyi = -cyi;
  1235.     cyi *= bounce; 
  1236.     Status = true;
  1237.   }
  1238.   else if (cy < 0+padding) //bottom
  1239.   {
  1240.     cy = 0+padding; 
  1241.     cyi = -cyi;
  1242.     cyi *= bounce; 
  1243.     Status = true;
  1244.   }
  1246.   if (cz > CELL*4-padding) //back
  1247.   {
  1248.     cz = CELL*4-padding; 
  1249.     czi = -czi;
  1250.     czi *= bounce; 
  1251.     Status = true;
  1252.   } 
  1254.   return Status;
  1255. }
  1257. inline bool Collision35(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1258. {
  1259.   bool Status = false;
  1260.   if (cx < CELL*2+padding)//left
  1261.   {
  1262.     cx = CELL*2+padding; 
  1263.     cxi = -cxi;
  1264.     cxi *= bounce; 
  1265.     Status = true;
  1266.   }
  1267.   else if (cx > CELL*3-padding)//right
  1268.   {
  1269.     cx = CELL*3-padding; 
  1270.     cxi = -cxi;
  1271.     cxi *= bounce; 
  1272.     Status = true;
  1273.   }
  1275.   if (cy > CELL/4-padding) //top
  1276.   {
  1277.     cy = CELL/4-padding; 
  1278.     cyi = -cyi;
  1279.     cyi *= bounce; 
  1280.     Status = true;
  1281.   }
  1282.   else if (cy < 0+padding) //bottom
  1283.   {
  1284.     cy = 0+padding; 
  1285.     cyi = -cyi;
  1286.     cyi *= bounce; 
  1287.     Status = true;
  1288.   }
  1290.   return Status;
  1291. }
  1293. inline bool Collision36(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1294. {
  1295.   bool Status = false;
  1296.   if (cx < CELL*2+padding)//left
  1297.   {
  1298.     cx = CELL*2+padding; 
  1299.     cxi = -cxi;
  1300.     cxi *= bounce; 
  1301.     Status = true;
  1302.   }
  1303.   else if (cx > CELL*3-padding)//right
  1304.   {
  1305.     cx = CELL*3-padding; 
  1306.     cxi = -cxi;
  1307.     cxi *= bounce; 
  1308.     Status = true;
  1309.   }
  1311.   if (cy > CELL/4-padding) //top
  1312.   {
  1313.     cy = CELL/4-padding; 
  1314.     cyi = -cyi;
  1315.     cyi *= bounce; 
  1316.     Status = true;
  1317.   }
  1318.   else if (cy < 0+padding) //bottom
  1319.   {
  1320.     cy = 0+padding; 
  1321.     cyi = -cyi;
  1322.     cyi *= bounce; 
  1323.     Status = true;
  1324.   }
  1326.   if (cz < CELL+padding) //front
  1327.   {
  1328.     cz = CELL+padding; 
  1329.     czi = -czi;
  1330.     czi *= bounce; 
  1331.     Status = true;
  1332.   }
  1334.   return Status;
  1335. }
  1337. inline bool Collision42(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1338. {
  1339.   bool Status = false; 
  1340.   if (cy > CELL/4-padding) //top
  1341.   {
  1342.     cy = CELL/4-padding; 
  1343.     cyi = -cyi;
  1344.     cyi *= bounce; 
  1345.     Status = true;
  1346.   }
  1347.   else if (cy < 0+padding) //bottom
  1348.   {
  1349.     cy = 0+padding; 
  1350.     cyi = -cyi;
  1351.     cyi *= bounce; 
  1352.     Status = true;
  1353.   }
  1355.   if (cz > CELL*6-padding) //back
  1356.   {
  1357.     cz = CELL*6-padding; 
  1358.     czi = -czi;
  1359.     czi *= bounce; 
  1360.     Status = true;
  1361.   }
  1362.   else if (cz < CELL*5+padding) //front
  1363.   {
  1364.     cz = CELL*5+padding; 
  1365.     czi = -czi;
  1366.     czi *= bounce; 
  1367.     Status = true;
  1368.   }
  1370.   return Status;
  1371. }
  1373. inline bool Collision44(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1374. {
  1375.   bool Status = false;
  1376.   if (cy > CELL/4-padding) //top
  1377.   {
  1378.     cy = CELL/4-padding; 
  1379.     cyi = -cyi;
  1380.     cyi *= bounce; 
  1381.     Status = true;
  1382.   }
  1383.   else if (cy < 0+padding) //bottom
  1384.   {
  1385.     cy = 0+padding; 
  1386.     cyi = -cyi;
  1387.     cyi *= bounce; 
  1388.     Status = true;
  1389.   }
  1391.   if (cz > CELL*4-padding) //back
  1392.   {
  1393.     cz = CELL*4-padding; 
  1394.     czi = -czi;
  1395.     czi *= bounce; 
  1396.     Status = true;
  1397.   }
  1398.   else if (cz < CELL*3+padding) //front
  1399.   {
  1400.     cz = CELL*3+padding; 
  1401.     czi = -czi;
  1402.     czi *= bounce; 
  1403.     Status = true;
  1404.   }
  1406.   return Status;
  1407. }
  1409. inline bool Collision46(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1410. {
  1411.   bool Status = false;
  1412.   if (cx > CELL*2-padding) //right
  1413.   {
  1414.     cx = CELL*2-padding; 
  1415.     cxi = -cxi;
  1416.     cxi *= bounce; 
  1417.     Status = true;
  1418.   }
  1420.   if (cy > CELL/4-padding) //top
  1421.   {
  1422.     cy = CELL/4-padding; 
  1423.     cyi = -cyi;
  1424.     cyi *= bounce; 
  1425.     Status = true;
  1426.   }
  1427.   else if (cy < 0+padding) //bottom
  1428.   {
  1429.     cy = 0+padding; 
  1430.     cyi = -cyi;
  1431.     cyi *= bounce; 
  1432.     Status = true;
  1433.   }
  1435.   if (cz > CELL*2-padding) //back
  1436.   {
  1437.     cz = CELL*2-padding; 
  1438.     czi = -czi;
  1439.     czi *= bounce; 
  1440.     Status = true;
  1441.   } 
  1442.   return Status;
  1443. }
  1445. inline bool Collision47(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1446. {
  1447.   bool Status = false;
  1448.   if (cx < CELL+padding)//left
  1449.   {
  1450.     cx = CELL+padding; 
  1451.     cxi = -cxi;
  1452.     cxi *= bounce; 
  1453.     Status = true;
  1454.   }
  1455.   else if (cx > CELL*2-padding)//right
  1456.   {
  1457.     cx = CELL*2-padding; 
  1458.     cxi = -cxi;
  1459.     cxi *= bounce; 
  1460.     Status = true;
  1461.   }
  1463.   if (cy > CELL/4-padding) //top
  1464.   {
  1465.     cy = CELL/4-padding; 
  1466.     cyi = -cyi;
  1467.     cyi *= bounce; 
  1468.     Status = true;
  1469.   }
  1470.   else if (cy < 0+padding) //bottom
  1471.   {
  1472.     cy = 0+padding; 
  1473.     cyi = -cyi;
  1474.     cyi *= bounce; 
  1475.     Status = true;
  1476.   } 
  1478.   if (cz < 0+padding && 
  1479. (cx < CELL*1+CELL*3/8+padding || 
  1480. cx > CELL*2-CELL*3/8-padding)) //[4 7]front door
  1481.   {
  1482.     cz = 0+padding;
  1483.     czi = -czi;
  1484.     czi *= bounce; 
  1485.     Status = true;
  1486.   }
  1488.   return Status;
  1489. }
  1491. inline bool Collision52(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1492. {
  1493.   bool Status = false;
  1494.   if (cx < 0+padding) //left
  1495.   {
  1496.     cx = 0+padding; 
  1497.     cxi = -cxi;
  1498.     cxi *= bounce; 
  1499.     Status = true;
  1500.   }
  1502.   if (cy > CELL/4-padding) //top
  1503.   {
  1504.     cy = CELL/4-padding; 
  1505.     cyi = -cyi;
  1506.     cyi *= bounce; 
  1507.     Status = true;
  1508.   }
  1509.   else if (cy < 0+padding) //bottom
  1510.   {
  1511.     cy = 0+padding; 
  1512.     cyi = -cyi;
  1513.     cyi *= bounce; 
  1514.     Status = true;
  1515.   }
  1517.   if (cz > CELL*6-padding) //back
  1518.   {
  1519.     cz = CELL*6-padding; 
  1520.     czi = -czi;
  1521.     czi *= bounce; 
  1522.     Status = true;
  1523.   } 
  1524.   return Status;
  1525. }
  1527. inline bool Collision53(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1528. {
  1529.   bool Status = false;
  1530.   if (cx < 0+padding)//left
  1531.   {
  1532.     cx = 0+padding; 
  1533.     cxi = -cxi;
  1534.     cxi *= bounce; 
  1535.     Status = true;
  1536.   }
  1537.   else if (cx > CELL-padding)//right
  1538.   {
  1539.     cx = CELL-padding; 
  1540.     cxi = -cxi;
  1541.     cxi *= bounce; 
  1542.     Status = true;
  1543.   }
  1545.   if (cy > CELL/4-padding) //top
  1546.   {
  1547.     cy = CELL/4-padding; 
  1548.     cyi = -cyi;
  1549.     cyi *= bounce; 
  1550.     Status = true;
  1551.   }
  1552.   else if (cy < 0+padding) //bottom
  1553.   {
  1554.     cy = 0+padding; 
  1555.     cyi = -cyi;
  1556.     cyi *= bounce; 
  1557.     Status = true;
  1558.   }
  1560.   if (cz < CELL*4+padding) //front
  1561.   {
  1562.     cz = CELL*4+padding; 
  1563.     czi = -czi;
  1564.     czi *= bounce; 
  1565.     Status = true;
  1566.   }
  1568.   return Status;
  1569. }
  1571. inline bool Collision54(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1572. {
  1573.   bool Status = false;
  1574.   if (cx < 0+padding) //left
  1575.   {
  1576.     cx = 0+padding; 
  1577.     cxi = -cxi;
  1578.     cxi *= bounce; 
  1579.     Status = true;
  1580.   }
  1582.   if (cy > CELL/4-padding) //top
  1583.   {
  1584.     cy = CELL/4-padding; 
  1585.     cyi = -cyi;
  1586.     cyi *= bounce; 
  1587.     Status = true;
  1588.   }
  1589.   else if (cy < 0+padding) //bottom
  1590.   {
  1591.     cy = 0+padding; 
  1592.     cyi = -cyi;
  1593.     cyi *= bounce; 
  1594.     Status = true;
  1595.   }
  1597.   if (cz > CELL*4-padding) //back
  1598.   {
  1599.     cz = CELL*4-padding; 
  1600.     czi = -czi;
  1601.     czi *= bounce; 
  1602.     Status = true;
  1603.   }
  1605.   return Status;
  1606. }
  1608. inline bool Collision55(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1609. {
  1610.   bool Status = false;
  1611.   if (cx < 0+padding)//left
  1612.   {
  1613.     cx = 0+padding; 
  1614.     cxi = -cxi;
  1615.     cxi *= bounce; 
  1616.     Status = true;
  1617.   }
  1618.   else if (cx > CELL-padding)//right
  1619.   {
  1620.     cx = CELL-padding; 
  1621.     cxi = -cxi;
  1622.     cxi *= bounce; 
  1623.     Status = true;
  1624.   }
  1626.   if (cy > CELL/4-padding) //top
  1627.   {
  1628.     cy = CELL/4-padding; 
  1629.     cyi = -cyi;
  1630.     cyi *= bounce; 
  1631.     Status = true;
  1632.   }
  1633.   else if (cy < 0+padding) //bottom
  1634.   {
  1635.     cy = 0+padding; 
  1636.     cyi = -cyi;
  1637.     cyi *= bounce; 
  1638.     Status = true;
  1639.   }
  1640.  
  1641.   return Status;
  1642. }
  1644. inline bool Collision56(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1645. {
  1646.   bool Status = false;
  1647.   if (cx < 0+padding)//left
  1648.   {
  1649.     cx = 0+padding; 
  1650.     cxi = -cxi;
  1651.     cxi *= bounce; 
  1652.     Status = true;
  1653.   }
  1655.   if (cy > CELL/4-padding) //top
  1656.   {
  1657.     cy = CELL/4-padding; 
  1658.     cyi = -cyi;
  1659.     cyi *= bounce; 
  1660.     Status = true;
  1661.   }
  1662.   else if (cy < 0+padding) //bottom
  1663.   {
  1664.     cy = 0+padding; 
  1665.     cyi = -cyi;
  1666.     cyi *= bounce; 
  1667.     Status = true;
  1668.   }
  1670.   if (cz < CELL+padding) //front
  1671.   {
  1672.     cz = CELL+padding; 
  1673.     czi = -czi;
  1674.     czi *= bounce; 
  1675.     Status = true;
  1676.   }
  1678.   return Status;
  1679. }
  1681. inline bool CollisionAll(GLdouble &cx, GLdouble &cy, GLdouble &cz, GLdouble &cxi, GLdouble &cyi, GLdouble &czi, GLdouble padding, GLdouble bounce)
  1682. {
  1683. bool Status = false;
  1685. if( xtrans2 > CELL*3 && xtrans2 < CELL*5 &&
  1686. ztrans2 > CELL*6 && ztrans2 < CELL*7 ) //[11][21]
  1687. {
  1688. if (cx > CELL*5-padding) //right
  1689. {
  1690. cx = CELL*5-padding; 
  1691. cxi = -cxi;
  1692. cxi *= bounce; 
  1693. Status = true;
  1694. }
  1695. else if (cx < CELL*3+padding)//left
  1696. {
  1697. cx = CELL*3+padding; 
  1698. cxi = -cxi;
  1699. cxi *= bounce; 
  1700. Status = true;
  1701. }
  1703. if (cy > CELL/4-padding) //top
  1704. {
  1705. cy = CELL/4-padding; 
  1706. cyi = -cyi;
  1707. cyi *= bounce; 
  1708. Status = true;
  1709. }
  1710. else if (cy < 0+padding) //bottom
  1711. {
  1712. cy = 0+padding; 
  1713. cyi = -cyi;
  1714. cyi *= bounce; 
  1715. Status = true;
  1716. }
  1718. if (cz > CELL*7-padding) //back
  1719. {
  1720. cz = CELL*7-padding; 
  1721. czi = -czi;
  1722. czi *= bounce; 
  1723. Status = true;
  1724. }
  1725. else if (cz < CELL*6+padding) //front
  1726. {
  1727. cz = CELL*6+padding; 
  1728. czi = -czi;
  1729. czi *= bounce; 
  1730. Status = true;
  1731. }
  1732. }
  1733. else if( xtrans2 > 0 && xtrans2 < CELL*4 &&
  1734. ztrans2 > CELL*5 && ztrans2 < CELL*6 ) //[22][32][42][52]
  1735. {
  1736. if (cx > CELL*4-padding) //right
  1737. {
  1738. cx = CELL*4-padding; 
  1739. cxi = -cxi;
  1740. cxi *= bounce; 
  1741. Status = true;
  1742. }
  1743. else if (cx < 0+padding)//left
  1744. {
  1745. cx = 0+padding; 
  1746. cxi = -cxi;
  1747. cxi *= bounce; 
  1748. Status = true;
  1749. }
  1751. if (cy > CELL/4-padding) //top
  1752. {
  1753. cy = CELL/4-padding; 
  1754. cyi = -cyi;
  1755. cyi *= bounce; 
  1756. Status = true;
  1757. }
  1758. else if (cy < 0+padding) //bottom
  1759. {
  1760. cy = 0+padding; 
  1761. cyi = -cyi;
  1762. cyi *= bounce; 
  1763. Status = true;
  1764. }
  1766. if (cz > CELL*6-padding) //back
  1767. {
  1768. cz = CELL*6-padding; 
  1769. czi = -czi;
  1770. czi *= bounce; 
  1771. Status = true;
  1772. }
  1773. else if (cz < CELL*5+padding) //front
  1774. {
  1775. cz = CELL*5+padding; 
  1776. czi = -czi;
  1777. czi *= bounce; 
  1778. Status = true;
  1779. }
  1780. }
  1782. else if( xtrans2 > CELL*3 && xtrans2 < CELL*4 &&
  1783. ztrans2 > CELL*3 && ztrans2 < CELL*5 ) //[23][24]
  1784. {
  1785. if (cx > CELL*4-padding) //right
  1786. {
  1787. cx = CELL*4-padding; 
  1788. cxi = -cxi;
  1789. cxi *= bounce; 
  1790. Status = true;
  1791. }
  1792. else if (cx < CELL*3+padding)//left
  1793. {
  1794. cx = CELL*3+padding; 
  1795. cxi = -cxi;
  1796. cxi *= bounce; 
  1797. Status = true;
  1798. }
  1800. if (cy > CELL/4-padding) //top
  1801. {
  1802. cy = CELL/4-padding; 
  1803. cyi = -cyi;
  1804. cyi *= bounce; 
  1805. Status = true;
  1806. }
  1807. else if (cy < 0+padding) //bottom
  1808. {
  1809. cy = 0+padding; 
  1810. cyi = -cyi;
  1811. cyi *= bounce; 
  1812. Status = true;
  1813. }
  1815. if (cz > CELL*5-padding) //back
  1816. {
  1817. cz = CELL*5-padding; 
  1818. czi = -czi;
  1819. czi *= bounce; 
  1820. Status = true;
  1821. }
  1822. else if (cz < CELL*3+padding) //front
  1823. {
  1824. cz = CELL*3+padding; 
  1825. czi = -czi;
  1826. czi *= bounce; 
  1827. Status = true;
  1828. }
  1829. }
  1831. else if( xtrans2 > 0 && xtrans2 < CELL &&
  1832. ztrans2 > CELL*4 && ztrans2 < CELL*5 ) //[53]
  1833. {
  1834. if (cx > CELL-padding) //right
  1835. {
  1836. cx = CELL-padding; 
  1837. cxi = -cxi;
  1838. cxi *= bounce; 
  1839. Status = true;
  1840. }
  1841. else if (cx < 0+padding)//left
  1842. {
  1843. cx = 0+padding; 
  1844. cxi = -cxi;
  1845. cxi *= bounce; 
  1846. Status = true;
  1847. }
  1849. if (cy > CELL/4-padding) //top
  1850. {
  1851. cy = CELL/4-padding; 
  1852. cyi = -cyi;
  1853. cyi *= bounce; 
  1854. Status = true;
  1855. }
  1856. else if (cy < 0+padding) //bottom
  1857. {
  1858. cy = 0+padding; 
  1859. cyi = -cyi;
  1860. cyi *= bounce; 
  1861. Status = true;
  1862. }
  1864. if (cz > CELL*5-padding) //back
  1865. {
  1866. cz = CELL*5-padding; 
  1867. czi = -czi;
  1868. czi *= bounce; 
  1869. Status = true;
  1870. }
  1871. else if (cz < CELL*4+padding) //front
  1872. {
  1873. cz = CELL*4+padding; 
  1874. czi = -czi;
  1875. czi *= bounce; 
  1876. Status = true;
  1877. }
  1878. }
  1880. else if( xtrans2 > CELL*2 && xtrans2 < CELL*3 &&
  1881. ztrans2 > CELL && ztrans2 < CELL*4 ) //[34][35][36]
  1882. {
  1883. if (cx > CELL*3-padding) //right
  1884. {
  1885. cx = CELL*3-padding; 
  1886. cxi = -cxi;
  1887. cxi *= bounce; 
  1888. Status = true;
  1889. }
  1890. else if (cx < CELL*2+padding)//left
  1891. {
  1892. cx = CELL*2+padding; 
  1893. cxi = -cxi;
  1894. cxi *= bounce; 
  1895. Status = true;
  1896. }
  1898. if (cy > CELL/4-padding) //top
  1899. {
  1900. cy = CELL/4-padding; 
  1901. cyi = -cyi;
  1902. cyi *= bounce; 
  1903. Status = true;
  1904. }
  1905. else if (cy < 0+padding) //bottom
  1906. {
  1907. cy = 0+padding; 
  1908. cyi = -cyi;
  1909. cyi *= bounce; 
  1910. Status = true;
  1911. }
  1913. if (cz > CELL*4-padding) //back
  1914. {
  1915. cz = CELL*4-padding; 
  1916. czi = -czi;
  1917. czi *= bounce; 
  1918. Status = true;
  1919. }
  1920. else if (cz < CELL+padding) //front
  1921. {
  1922. cz = CELL+padding; 
  1923. czi = -czi;
  1924. czi *= bounce; 
  1925. Status = true;
  1926. }
  1927. }
  1929. else if( xtrans2 > CELL && xtrans2 < CELL*2 &&
  1930. ztrans2 > CELL*3 && ztrans2 < CELL*4 ) //[44]
  1931. {
  1932. if (cx > CELL*2-padding) //right
  1933. {
  1934. cx = CELL*2-padding; 
  1935. cxi = -cxi;
  1936. cxi *= bounce; 
  1937. Status = true;
  1938. }
  1939. else if (cx < CELL+padding)//left
  1940. {
  1941. cx = CELL+padding; 
  1942. cxi = -cxi;
  1943. cxi *= bounce; 
  1944. Status = true;
  1945. }
  1947. if (cy > CELL/4-padding) //top
  1948. {
  1949. cy = CELL/4-padding; 
  1950. cyi = -cyi;
  1951. cyi *= bounce; 
  1952. Status = true;
  1953. }
  1954. else if (cy < 0+padding) //bottom
  1955. {
  1956. cy = 0+padding; 
  1957. cyi = -cyi;
  1958. cyi *= bounce; 
  1959. Status = true;
  1960. }
  1962. if (cz > CELL*4-padding) //back
  1963. {
  1964. cz = CELL*4-padding; 
  1965. czi = -czi;
  1966. czi *= bounce; 
  1967. Status = true;
  1968. }
  1969. else if (cz < CELL*3+padding) //front
  1970. {
  1971. cz = CELL*3+padding; 
  1972. czi = -czi;
  1973. czi *= bounce; 
  1974. Status = true;
  1975. }
  1976. }
  1978. else if( xtrans2 > 0 && xtrans2 < CELL &&
  1979. ztrans2 > CELL && ztrans2 < CELL*4 ) //[54][55][56]
  1980. {
  1981. if (cx > CELL-padding) //right
  1982. {
  1983. cx = CELL-padding; 
  1984. cxi = -cxi;
  1985. cxi *= bounce; 
  1986. Status = true;
  1987. }
  1988. else if (cx < 0+padding)//left
  1989. {
  1990. cx = 0+padding; 
  1991. cxi = -cxi;
  1992. cxi *= bounce; 
  1993. Status = true;
  1994. }
  1996. if (cy > CELL/4-padding) //top
  1997. {
  1998. cy = CELL/4-padding; 
  1999. cyi = -cyi;
  2000. cyi *= bounce; 
  2001. Status = true;
  2002. }
  2003. else if (cy < 0+padding) //bottom
  2004. {
  2005. cy = 0+padding; 
  2006. cyi = -cyi;
  2007. cyi *= bounce; 
  2008. Status = true;
  2009. }
  2011. if (cz > CELL*4-padding) //back
  2012. {
  2013. cz = CELL*4-padding; 
  2014. czi = -czi;
  2015. czi *= bounce; 
  2016. Status = true;
  2017. }
  2018. else if (cz < CELL+padding) //front
  2019. {
  2020. cz = CELL+padding; 
  2021. czi = -czi;
  2022. czi *= bounce; 
  2023. Status = true;
  2024. }
  2025. }
  2027. else if( xtrans2 > CELL && xtrans2 < CELL*2 &&
  2028. ztrans2 > 0 && ztrans2 < CELL*2 ) //[46][47]
  2029. {
  2030. if (cx > CELL*2-padding) //right
  2031. {
  2032. cx = CELL*2-padding; 
  2033. cxi = -cxi;
  2034. cxi *= bounce; 
  2035. Status = true;
  2036. }
  2037. else if (cx < CELL+padding)//left
  2038. {
  2039. cx = CELL+padding; 
  2040. cxi = -cxi;
  2041. cxi *= bounce; 
  2042. Status = true;
  2043. }
  2045. if (cy > CELL/4-padding) //top
  2046. {
  2047. cy = CELL/4-padding; 
  2048. cyi = -cyi;
  2049. cyi *= bounce; 
  2050. Status = true;
  2051. }
  2052. else if (cy < 0+padding) //bottom
  2053. {
  2054. cy = 0+padding; 
  2055. cyi = -cyi;
  2056. cyi *= bounce; 
  2057. Status = true;
  2058. }
  2060. if (cz > CELL*2-padding) //back
  2061. {
  2062. cz = CELL*2-padding; 
  2063. czi = -czi;
  2064. czi *= bounce; 
  2065. Status = true;
  2066. }
  2067. else if (cz < 0+padding) //front
  2068. {
  2069. cz = 0+padding; 
  2070. czi = -czi;
  2071. czi *= bounce; 
  2072. Status = true;
  2073. }
  2074. }
  2076.   return Status;
  2077. }
  2079. inline void Ricochet()
  2080. {
  2081.   int i;
  2082.   
  2083.   for (i = 0; i < MAX_PARTICLES; i++)
  2084.   {
  2085.     if (i == 0)
  2086.       particle[i][shots_fired].size = 2;
  2087.     else
  2088.       particle[i][shots_fired].size = GLdouble((rand()%25)+25)/50;
  2089.     
  2090.     particle[i][shots_fired].triangle_x1 = GLdouble((rand()%50)-25)/75.f;
  2091.     particle[i][shots_fired].triangle_x2 = GLdouble((rand()%50)-25)/75.f;
  2092.     particle[i][shots_fired].triangle_x3 = GLdouble((rand()%50)-25)/75.f;
  2094.     particle[i][shots_fired].triangle_y1 = GLdouble((rand()%50)-25)/75.f;
  2095.     particle[i][shots_fired].triangle_y2 = GLdouble((rand()%50)-25)/75.f;
  2096.     particle[i][shots_fired].triangle_y3 = GLdouble((rand()%50)-25)/75.f;
  2097.     
  2098.     particle[i][shots_fired].triangle_z1 = GLdouble((rand()%50)-25)/75.f;
  2099.     particle[i][shots_fired].triangle_z2 = GLdouble((rand()%50)-25)/75.f;
  2100.     particle[i][shots_fired].triangle_z3 = GLdouble((rand()%50)-25)/75.f;
  2102.     particle[i][shots_fired].triangle_rotate_x = rand()%360;
  2103.     particle[i][shots_fired].triangle_rotate_y = rand()%360;
  2104.     particle[i][shots_fired].triangle_rotate_z = rand()%360;
  2106.     particle[i][shots_fired].triangle_rotate_xi = GLdouble((rand()%50)-25)/5;
  2107.     particle[i][shots_fired].triangle_rotate_yi = GLdouble((rand()%50)-25)/5;
  2108.     particle[i][shots_fired].triangle_rotate_zi = GLdouble((rand()%50)-25)/5;
  2110.     particle[i][shots_fired].life = 1;
  2111.     particle[i][shots_fired].fade = GLdouble(rand()%100)/5000 + .02f;
  2112.     particle[i][shots_fired].x = fire_x;
  2113.     particle[i][shots_fired].y = fire_y;
  2114.     particle[i][shots_fired].z = fire_z;
  2115.     GLdouble angle = rand()%360;
  2116.     GLdouble angle2 = rand()%360;
  2117.     GLdouble speed = GLdouble(rand()%100) / 500;
  2118.     GLdouble Hyp = Hypot(angle,angle2);
  2120.     particle[i][shots_fired].xi = sin(Hypot(angle,Hyp))*speed + fire_xp;
  2121.     particle[i][shots_fired].yi = cos(Hypot(angle,Hyp))*speed + fire_yp;
  2122.     particle[i][shots_fired].zi = cos(Hypot(angle2,Hyp))*speed + fire_zp;
  2123.   }
  2124. }
  2126. void LoadMonster( int ID,float xPosition, float yPosition, float zPosition)
  2127. { 
  2128.   Monster[ID].transX = xPosition;
  2129.   Monster[ID].transY = yPosition;
  2130.   Monster[ID].transZ = zPosition;
  2131. if(Monster[ID].trigger == true )
  2132. {   
  2133.   if( Monster[ID].hitStatus == false )
  2134.   {  
  2135. //glPushMatrix();
  2136. //////////// *** NEW *** //////////  START GAME AI ///////////// *** NEW *** ///////////////
  2137. if((xtrans2 - Monster[ID].transX ) > 15) //if on the left, move towards right
  2138. {
  2139. Monster[ID].transXSpeed += 0.5f;
  2140. gameOverOnX = false;
  2141. }else if((Monster[ID].transX - xtrans2) > 15) //if on the right, move towards left
  2142. {
  2143. Monster[ID].transXSpeed -= 0.5f;
  2144. gameOverOnX = false;
  2145. }else
  2146. {
  2147. Monster[ID].transXSpeed = 0.0f; 
  2148. gameOverOnX = true;
  2149. }
  2150. Monster[ID].transX += Monster[ID].transXSpeed;
  2151. glTranslatef(Monster[ID].transX, 0, 0);
  2153. if((ztrans2 - Monster[ID].transZ) > 15) //if on the front, move forwards 
  2154. {
  2155. Monster[ID].transZSpeed += 0.5f;
  2156. gameOverOnZ = false;
  2157. }else if( ( Monster[ID].transZ - ztrans2) > 15) //if on the back, move backwards
  2158. {
  2159. Monster[ID].transZSpeed -= 0.5f; 
  2160. gameOverOnZ = false;
  2161. }else
  2162. {
  2163. Monster[ID].transZSpeed = 0.0f;
  2164. gameOverOnZ = false;
  2165. } 
  2166. Monster[ID].transZ += Monster[ID].transZSpeed;
  2167. glTranslatef( 0, 0, Monster[ID].transZ);
  2169. if( gameOverOnX == true && gameOverOnZ == true)
  2170. {
  2171. gameOver = true;
  2172. }else
  2173. {
  2174. gameOver = false;
  2175. }
  2176.  
  2177. //////////// *** NEW *** AI to let Monster face player always *** NEW *** //////////////////// 
  2178. Monster[ID].rotateX = atan ( (ztrans2 - Monster[ID].transZ) / (xtrans2 - Monster[ID].transX + 0.5f) ) / piover180;
  2180. //if degree is in 3rd quadrant
  2181. if( (ztrans2 - Monster[ID].transZ) < 0.0f && (xtrans2 - Monster[ID].transX) < 0.0f ) 
  2182. {
  2183. Monster[ID].XMultiplier = -1.0f;
  2184. }
  2185. //if degree is in 2nd quadrant
  2186. else if( (xtrans2 - Monster[ID].transX) < 0.0f &&  (ztrans2 - Monster[ID].transZ) > 0.0f) 
  2187. {
  2188. Monster[ID].XMultiplier = 0.5f;
  2189. }
  2190. //if degree is in 4th quadrant
  2191. else if( (xtrans2 - Monster[ID].transX) > 0.0f &&  (ztrans2 - Monster[ID].transZ) < 0.0f) 
  2192. {
  2193. Monster[ID].XMultiplier = -1.0f;
  2194. }
  2195. //if degree is in 1st quadrant
  2196. else
  2197. {
  2198. Monster[ID].XMultiplier = 0.0f;
  2199. }
  2200.     // Face the player around the Y-Axis
  2201. glRotatef(Monster[ID].XMultiplier * 90.0f + Monster[ID].rotateX - 135.0f, 0.0f, 1.0f, 0.0f); 
  2202. //////////// *** NEW *** ////////// END GAME AI ///////////// *** NEW *** //////////////////
  2203. if( (atan((Monster[ID].transZ - fire_z)/(Monster[ID].transX - fire_x + 0.5f)) 
  2204.   - atan((ztrans2 -Monster[ID].transZ)/(xtrans2 - Monster[ID].transX + 0.5f)) < 0.0873*2) && //5 degrees in radian
  2205.   (atan((Monster[ID].transZ - fire_z)/(Monster[ID].transX - fire_x + 0.5f))
  2206.   - atan((ztrans2 -Monster[ID].transZ)/(xtrans2 - Monster[ID].transX + 0.5f)) > -0.0873*2) &&
  2207.   isFire == true &&
  2208.   ( (ztrans2 > Monster[ID].transZ && Monster[ID].transZ > fire_z) ||
  2209.      (ztrans2 < Monster[ID].transZ && Monster[ID].transZ < fire_z) ) &&
  2210.   ( (xtrans2 > Monster[ID].transX && Monster[ID].transX > fire_x) ||
  2211.      (xtrans2 < Monster[ID].transX && Monster[ID].transX < fire_x) ))
  2212. {
  2213. Monster[ID].hitCount += 1;
  2214. if( Monster[ID].hitCount == 3)
  2215. {
  2216. Monster[ID].transXSpare = Monster[ID].transX; 
  2217. Monster[ID].transZSpare = Monster[ID].transZ;
  2218. Monster[ID].hitStatus = true;
  2219. }
  2220. }
  2222. glTranslatef( 0, 25.0f, 0); //move the model upwards
  2223. glCallList(MODEL);
  2224. //glPopMatrix(); 
  2225.  }
  2226. else
  2227. { 
  2228. glTranslatef( Monster[ID].transXSpare, 25.0f + Monster[ID].fall, Monster[ID].transZSpare);
  2229. glRotatef(Monster[ID].XMultiplier * 90.0f + Monster[ID].rotateX- 135.0f, 0.0f, 1.0f, 0.0f);
  2230.   
  2231. if(ABS(Monster[ID].rotateY) < 89.0f)
  2232. {
  2233. Monster[ID].rotateYSpeed += 1.0f;
  2234. Monster[ID].fall -= 1.01f;
  2235. }else
  2236. {
  2237. Monster[ID].rotateYSpeed = 0.0f;
  2238. }  
  2239. Monster[ID].rotateY += Monster[ID].rotateYSpeed;  
  2240. glRotatef(Monster[ID].rotateY, 1.0f, 0.0f, -1.0f);  // Fall@Rotate the object around the XZ-Axis
  2241. glCallList(MODEL);
  2242. }
  2243. }
  2244. }
  2246. int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
  2247. {
  2248.   glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); // Clear The Screen And The Depth Buffer
  2250.   XP *= 0.8f; 
  2251.   ZP *= 0.8f; 
  2252.   xtrans2 += XP/10;
  2253.   ztrans2 += ZP/10;
  2255.   xtrans = -xtrans2;
  2256.   ztrans = -ztrans2;
  2257.  
  2258.   if( gameOver == false)
  2259.   {
  2260. if(ztrans2>CELL*6 && ztrans2<CELL*7 && 
  2261. xtrans2>CELL*4 && xtrans2<CELL*5)
  2262. { 
  2263. Collision11(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2264. }
  2265. else if(ztrans2>CELL*6 && ztrans2<CELL*7 && 
  2266. xtrans2>CELL*3 && xtrans2<CELL*4) 
  2267. {
  2268. Collision21(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2269. }
  2270. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  2271. xtrans2>CELL*3 && xtrans2<CELL*4) 
  2272. {
  2273. Collision22(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2274. }
  2275. else if(ztrans2>CELL*4 && ztrans2<CELL*5 && 
  2276. xtrans2>CELL*3 && xtrans2<CELL*4) 
  2277. {
  2278. Collision23(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2279. }
  2280. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  2281. xtrans2>CELL*3 && xtrans2<CELL*4)
  2282. {
  2283. Collision24(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2284. }
  2285. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  2286. xtrans2>CELL*2 && xtrans2<CELL*3)
  2287. {
  2288. Collision32(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2289. }
  2290. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  2291. xtrans2>CELL*2 && xtrans2<CELL*3)
  2292. {
  2293. Collision34(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2294. }
  2295. else if(ztrans2>CELL*2 && ztrans2<CELL*3 && 
  2296. xtrans2>CELL*2 && xtrans2<CELL*3)
  2297. {
  2298. Collision35(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2299. }
  2300. else if(ztrans2>CELL && ztrans2<CELL*2 && 
  2301. xtrans2>CELL*2 && xtrans2<CELL*3)
  2302. {
  2303. Collision36(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2304. }
  2305. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  2306. xtrans2>CELL && xtrans2<CELL*2)
  2307. {
  2308. Collision42(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2309. }
  2310. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  2311. xtrans2>CELL && xtrans2<CELL*2)
  2312. {
  2313. Collision44(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2314. }
  2315. else if(ztrans2>CELL && ztrans2<CELL*2 && 
  2316. xtrans2>CELL && xtrans2<CELL*2)
  2317. {
  2318. Collision46(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2319. }
  2320. else if(ztrans2>0 && ztrans2<CELL && 
  2321. xtrans2>CELL && xtrans2<CELL*2)
  2322. {
  2323. Collision47(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2324. }
  2325. else if(ztrans2>CELL*5 && ztrans2<CELL*6 && 
  2326. xtrans2>0 && xtrans2<CELL)
  2327. {
  2328. Collision52(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2329. }
  2330. else if(ztrans2>CELL*4 && ztrans2<CELL*5 && 
  2331. xtrans2>0 && xtrans2<CELL)
  2332. {
  2333. Collision53(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2334. }
  2335. else if(ztrans2>CELL*3 && ztrans2<CELL*4 && 
  2336. xtrans2>0 && xtrans2<CELL)
  2337. {
  2338. Collision54(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2339. }
  2340. else if(ztrans2>CELL*2 && ztrans2<CELL*3 && 
  2341. xtrans2>0 && xtrans2<CELL)
  2342. {
  2343. Collision55(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2344. }
  2345. else if(ztrans2>CELL && ztrans2<CELL*2 && 
  2346. xtrans2>0 && xtrans2<CELL)
  2347. {
  2348. Collision56(xtrans2, ytrans2, ztrans2, XP, BlankNum, ZP, 5.0f, 0);
  2349. }
  2351.   zprot*=.9f;
  2352.   _heading += zprot;
  2353.   heading = mouse_3d_x + _heading;
  2354.     
  2355.   yrot = heading;
  2357.   sceneroty = 360.0f - yrot;
  2359.   glLoadIdentity();
  2360.   m16_kicki += -m16_kick/50;
  2361.   m16_kick += m16_kicki/10;
  2362.   m16_kicki *= .8f;
  2363.   m16_kick *= .9f;
  2364.   if (m16_kick != 0)
  2365.   {
  2366.     glRotated(-m16_kick,1,0,0);
  2367.     glTranslatef(0,0,-m16_kick);
  2368.   }
  2370.   glLoadIdentity();
  2372.   glRotated(mouse_3d_y,1.f,0,0);
  2373.   glRotated(sceneroty,0,1.f,0); 
  2374.   glTranslated(xtrans, -25 ,ztrans); // Player position
  2376.   glDisable(GL_BLEND);
  2377.   for(int i=0; i<18; i++)
  2378.   {
  2379. glCallList(ROOM[i]);
  2380.   }
  2381.   glEnable(GL_BLEND);
  2383. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2384.   LoadMonster(0, CELL*4 + 20.0f, 0.0, CELL*6 + 20.0f);
  2385.   if(xtrans2 > CELL*3 && xtrans2 < CELL*5 &&
  2386.   ztrans2 > CELL*6 && ztrans2 < CELL*7 )
  2387.   {   
  2388.   Monster[0].trigger = true;
  2389.   }else
  2390.   {
  2391.   Monster[0].trigger = false;
  2392.   }
  2394.   LoadMonster(1, CELL*2 + 20.0f, 0.0, CELL*5 + 20.0f);
  2395.   if(xtrans2 > 0 && xtrans2 < CELL*4 &&
  2396.   ztrans2 > CELL*5 && ztrans2 < CELL*6 )
  2397.   {   
  2398.   Monster[1].trigger = true;
  2399.   }else
  2400.   {
  2401.   Monster[1].trigger = false;
  2402.   }
  2404.   LoadMonster(2, 20.0f, 0.0, CELL*4 + 20.0f);
  2405.   if(xtrans2 > 0 && xtrans2 < CELL &&
  2406.   ztrans2 > CELL*4 && ztrans2 < CELL*5 )
  2407.   {
  2408.   Monster[2].trigger = true;
  2409.   }else
  2410.   {
  2411.   Monster[2].trigger = false;
  2412.   }
  2414.   LoadMonster(3, CELL*2 + 20.0f, 0.0, CELL*2 + 20.0f);
  2415.   if(xtrans2 > CELL*2 && xtrans2 < CELL*3 &&
  2416.   ztrans2 > CELL && ztrans2 < CELL*4 )
  2417.   {
  2418.   Monster[3].trigger = true;
  2419.   }else
  2420.   {
  2421.   Monster[3].trigger = false;
  2422.   }
  2423.   LoadMonster(4, 20.0f, 0.0, CELL*2 + 20.0f);
  2424.   if(xtrans2 > 0 && xtrans2 < CELL &&
  2425.   ztrans2 > CELL && ztrans2 < CELL*4 )
  2426.   {
  2427.   Monster[4].trigger = true;
  2428.   }else
  2429.   {
  2430.   Monster[4].trigger = false;
  2431.   }
  2433.   LoadMonster(5, CELL + 20.0f, 0.0, 20.0f);
  2434.   if(xtrans2 > CELL && xtrans2 < CELL*2 &&
  2435.   ztrans2 > 0 && ztrans2 < CELL*2 )
  2436.   {
  2437.   Monster[5].trigger = true;
  2438.   }else
  2439.   {
  2440.   Monster[5].trigger = false;
  2441.   } 
  2442. //////////// *** NEW *** ////////// GAME AI ///////////// *** NEW *** ////////////////////
  2443. // Determine if you have fired a weapon
  2444.   if (isFire)
  2445.   {
  2446.     PlaySound("Data/rifle.WAV", NULL, SND_ASYNC);
  2447.     m16_kicki = 1;
  2448.     
  2449.     shots_fired++;
  2450.     if (shots_fired > MAX_SHOTS_FIRED-1) shots_fired = 0;
  2451.     isFireComplete = false;
  2452.     isFire = false;
  2454.     fire_x = -xtrans;
  2455.     fire_y = 10;
  2456.     fire_z = -ztrans;
  2458.     fire_xp = -(GLdouble)sin(heading*piover180) / 5;
  2459.     fire_yp = -(GLdouble)tan(mouse_3d_y*piover180) / 5;
  2460.     fire_zp = -(GLdouble)cos(heading*piover180) / 5;
  2461.   }
  2462.   int fire_counter = 0;
  2464.   // Begin calculations for the projectile
  2465.   while (!isFireComplete)
  2466.   {     
  2467.     fire_counter++;
  2468.     fire_x += fire_xp;
  2469.     fire_y += fire_yp;
  2470.     fire_z += fire_zp;
  2471.       
  2472.     if (CollisionAll(fire_x,  fire_y,  fire_z, BlankNum, BlankNum, BlankNum, 0, 0))
  2473.     {
  2474.       isFireComplete = true;
  2475.       Ricochet();
  2476.       isRicochet = true; 
  2477.     }
  2478.     else if (fire_counter > 10000)
  2479.     {
  2480.       isFireComplete = true;
  2481.     } 
  2482.   } 
  2484. // Determine if it was the M16 that was fired.
  2485.   if (isRicochet)
  2486.   {   
  2487.     int i;
  2488.     bool isRicochetComplete = true;
  2489.     glDisable(GL_TEXTURE_2D);
  2490.     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  2492.     for (int j = 0; j < MAX_SHOTS_FIRED; j++)
  2493.     {
  2494.       for (i = 8; i < MAX_PARTICLES; i++)
  2495.       {
  2496.         if (particle[i][j].life > 0)
  2497.         {
  2498.           isRicochetComplete = false;
  2500.           particle[i][j].x += particle[i][j].xi;
  2501.           particle[i][j].y += particle[i][j].yi;
  2502.           particle[i][j].z += particle[i][j].zi;
  2504.           CollisionAll(particle[i][j].x,  particle[i][j].y,  particle[i][j].z,
  2505.                           particle[i][j].xi, particle[i][j].yi, particle[i][j].zi, 0, .75f);
  2507.           particle[i][j].yi -= .01f;  // cheap simulated gravity
  2508.           particle[i][j].xi *= .99;
  2509.           particle[i][j].yi *= .99;
  2510.           particle[i][j].zi *= .99;
  2511.           particle[i][j].life -= particle[i][j].fade;
  2512.         
  2513.           glLoadIdentity();
  2514.           glRotated(mouse_3d_y,1.f,0,0);
  2515.           glRotated(sceneroty,0,1.f,0);
  2516.           glTranslated(xtrans,-10,ztrans);  
  2517.           glTranslated(particle[i][j].x,particle[i][j].y,particle[i][j].z);
  2518.           glRotated(-sceneroty,0,1.f,0);
  2519.           glRotated(-mouse_3d_y,1.f,0,0);
  2521.           particle[i][j].triangle_rotate_x += particle[i][j].triangle_rotate_xi;
  2522.           particle[i][j].triangle_rotate_y += particle[i][j].triangle_rotate_yi;
  2523.           particle[i][j].triangle_rotate_z += particle[i][j].triangle_rotate_zi;
  2524.           particle[i][j].triangle_rotate_xi -= particle[i][j].fade;
  2525.           particle[i][j].triangle_rotate_yi -= particle[i][j].fade;
  2526.           particle[i][j].triangle_rotate_zi -= particle[i][j].fade;
  2527.           glRotated(particle[i][j].triangle_rotate_x,1,0,0);
  2528.           glRotated(particle[i][j].triangle_rotate_y,0,1,0);
  2529.           glRotated(particle[i][j].triangle_rotate_z,0,0,1);
  2531.           glColor4d(0,0,0,particle[i][j].life);
  2533.           glBegin(GL_TRIANGLES);
  2534.           glVertex3d(particle[i][j].triangle_x1, particle[i][j].triangle_y1, particle[i][j].triangle_z1);
  2535.           glVertex3d(particle[i][j].triangle_x2, particle[i][j].triangle_y2, particle[i][j].triangle_z2);
  2536.           glVertex3d(particle[i][j].triangle_x3, particle[i][j].triangle_y3, particle[i][j].triangle_z3);
  2537.           glEnd();
  2538.         }
  2539.       }
  2540.     }
  2541.     glEnable(GL_TEXTURE_2D);
  2542.     glDisable(GL_DEPTH_TEST);
  2543.     glBlendFunc(GL_SRC_ALPHA,GL_ONE);
  2545.     glBindTexture(GL_TEXTURE_2D, texture[3]);
  2547.     // Display particles of the ricochet from the M16
  2548.     for (j = 0; j < MAX_SHOTS_FIRED; j++)
  2549.     {
  2550.       for (i = 0; i < 8; i++)
  2551.       {     
  2552.         if (particle[i][j].life > 0)
  2553.         {
  2554.           isRicochetComplete = false;
  2556.           particle[i][j].x += particle[i][j].xi/2;
  2557.           particle[i][j].y += particle[i][j].yi/2;
  2558.           particle[i][j].z += particle[i][j].zi/2;
  2560.           particle[i][j].yi += .01f;
  2562.           particle[i][j].xi *= .9f;
  2563.           particle[i][j].yi *= .9f;
  2564.           particle[i][j].zi *= .9f;
  2565.         
  2566.           particle[i][j].life -= particle[i][j].fade/2;
  2568.           glLoadIdentity();
  2569.           glRotated(mouse_3d_y,1.f,0,0);
  2570.           glRotated(sceneroty,0,1.f,0);
  2571.           glTranslated(xtrans,-10,ztrans);       
  2572.           glTranslated(particle[i][j].x,particle[i][j].y,particle[i][j].z);
  2573.           glRotated(-sceneroty,0,1.f,0);
  2574.           glRotated(-mouse_3d_y,1.f,0,0);
  2576.           glColor4d(.18f,.17f,.15f,particle[i][j].life);
  2577.           glBegin(GL_QUADS);
  2578.           glTexCoord2d(1,1); glVertex3d( particle[i][j].size, particle[i][j].size,0);
  2579.           glTexCoord2d(1,0); glVertex3d( particle[i][j].size,-particle[i][j].size,0);
  2580.           glTexCoord2d(0,0); glVertex3d(-particle[i][j].size,-particle[i][j].size,0);
  2581.           glTexCoord2d(0,1); glVertex3d(-particle[i][j].size, particle[i][j].size,0);
  2582.           glEnd();
  2583.         }  
  2584.       }
  2585.     }
  2586.     glEnable(GL_DEPTH_TEST);
  2588.     if (isRicochetComplete)
  2589.       isRicochet = false;
  2590.   }
  2591. // Crosshair  
  2592.   glDisable(GL_DEPTH_TEST);
  2593.   glLoadIdentity();
  2594.   glTranslated(0.0f,0.0f,-35.0f);   
  2596.   glBlendFunc(GL_SRC_ALPHA,GL_ONE);
  2598.   glColor4f(1,1,1,1);
  2599.   glBindTexture(GL_TEXTURE_2D,texture[2]);
  2600.   glBegin(GL_QUADS);
  2601.   glTexCoord2d(1,1); glVertex2f(1,1);
  2602.   glTexCoord2d(1,0); glVertex2f(1,-1);
  2603.   glTexCoord2d(0,0); glVertex2f(-1,-1);
  2604.   glTexCoord2d(0,1); glVertex2f(-1,1);
  2605.   glEnd(); 
  2606.   
  2607. glDisable(GL_DEPTH_TEST);   
  2608. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  2609. glColor4d(1,1,1,1);
  2610. glPrint(150,250,1,"Distance: %4.0f", Hypot( (xtrans2-CELL*3/2.0), (ztrans2-5.0) ) );
  2611. for( int k=0; k<6;k++)
  2612. {
  2613. if( Monster[k].trigger == true && Monster[k].hitCount < 3)
  2614. {
  2615. glColor4d(1,0,0,1);
  2616. glPrint(150,230,1,"ALERT!");
  2617. }
  2618. if( xtrans2 - Monster[k].transX < 15.0&& Monster[k].hitCount < 3)
  2619. {
  2620. glColor4d(1,0,0,1);
  2621. glPrint(150,230,1,"ALERT!");
  2622. }
  2623. }
  2624. glColor4d(1,1,1,1);
  2625. glEnable(GL_DEPTH_TEST);
  2626. glDisable(GL_TEXTURE_2D);
  2627.     glEnable(GL_TEXTURE_2D);
  2629. //  ESTABLISH A FPS FRAMERATE COUNTER
  2630.   if (isFPS)
  2631.   { 
  2632.     glDisable(GL_DEPTH_TEST);
  2633.     frames++;    
  2634.     if (frames%10 == 0) 
  2635.     {
  2636.       Time2 = TimerGetTime()/1000;
  2637.       DiffTime = ABS(Time2-Time1);      
  2638.       Time1 = TimerGetTime()/1000;     
  2639.       if (DiffTime != 0)
  2640.       FPS = 10/(DiffTime);
  2641.     }             
  2642.     
  2643. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  2644.     glColor4d(1,1,1,1);
  2645. glPrint(-350,250,1,"FPS: %4.0f", FPS);
  2646.   
  2647. glPrint(-350,230,1,"transX[0]: %4.2f C", Monster[0].transX);
  2648. glPrint(-350,210,1,"transZ[0]: %4.2f C", Monster[0].transZ);
  2649. glPrint(-350,190,1,"(xtrans2-transX): %4.2f", (xtrans2-Monster[0].transX) );
  2650. glPrint(-350,170,1,"xtrans2: %4.2f C", xtrans2/CELL);
  2651. glPrint(-350,150,1,"ztrans2: %4.2f C", ztrans2/CELL);
  2652. glPrint(-350,130,1,"(ztrans2-transZ): %4.2f", (ztrans2-Monster[0].transZ) );
  2653. glPrint(-350,110,1,"rotateX@atan: %4.2f", Monster[0].rotateX );
  2654. glPrint(-350,90,1,"multiplier+atan: %4.2f", Monster[0].XMultiplier*90.0f+Monster[0].rotateX-135.0f);
  2655. glPrint(-350,70,1,"fire_x: %4.2f C", fire_x/CELL );
  2656. glPrint(-350,50,1,"fire_y: %4.2f C", fire_y/CELL );
  2657. glPrint(-350,30,1,"fire_z: %4.2f C", fire_z/CELL );
  2658. glPrint(-350,10,1,"deg(M-H): %4.2f", atan((Monster[0].transZ - fire_z)/(Monster[0].transX - fire_x + 0.5f))/ piover180 );
  2659. glPrint(-350,-10,1,"deg(P-M): %4.2f", atan((ztrans2 -Monster[0].transZ)/(xtrans2 - Monster[0].transX + 0.5f))/ piover180);
  2660. glPrint(-350,-30,1,"condition[0]: %4.2f", atan((Monster[0].transZ - fire_z)/(Monster[0].transX - fire_x + 0.5f))/ piover180
  2661. - atan((ztrans2 -Monster[0].transZ)/(xtrans2 - Monster[0].transX + 0.5f))/ piover180);
  2662. glPrint(-350,-50,1,"[0]hit %2.0d", Monster[0].hitCount);
  2663. if( Monster[0].hitStatus == true )
  2664. {
  2665. glPrint(-350,-70,1,"[0]dead");
  2666. }
  2667. glPrint(-350,-90,1,"transX[1]: %4.2f C", Monster[1].transX/CELL);
  2668. glPrint(-350,-110,1,"transZ[1]: %4.2f C", Monster[1].transZ/CELL);
  2669. glPrint(-350,-130,1,"condition[1]: %4.2f", atan((Monster[1].transZ - fire_z)/(Monster[1].transX - fire_x + 0.5f))/ piover180
  2670. - atan((ztrans2 -Monster[1].transZ)/(xtrans2 - Monster[1].transX + 0.5f))/ piover180);
  2671. glPrint(-350,-150,1,"[1]hit %2.0d", Monster[1].hitCount);
  2672. if( Monster[1].hitStatus == true )
  2673. {
  2674. glPrint(-350,-170,1,"[1]dead");
  2675. }
  2676. glPrint(0,110,1,"transX[2]: %4.2f C", Monster[2].transX/CELL);
  2677. glPrint(0,90,1,"transZ[2]: %4.2f C", Monster[2].transZ/CELL);
  2678. glPrint(0,70,1,"condition[2]: %4.2f", atan((Monster[2].transZ - fire_z)/(Monster[2].transX - fire_x + 0.5f))/ piover180
  2679. - atan((ztrans2 -Monster[2].transZ)/(xtrans2 - Monster[2].transX + 0.5f))/ piover180);
  2680. glPrint(0,50,1,"[2]hit %2.0d", Monster[2].hitCount);
  2681. if( Monster[2].hitStatus == true )
  2682. {
  2683. glPrint(0,30,1,"[2]dead");
  2684. }
  2685. glPrint(0,10,1,"transX[3]: %4.2f C", Monster[3].transX/CELL);
  2686. glPrint(0,-10,1,"transZ[3]: %4.2f C", Monster[3].transZ/CELL);
  2687. glPrint(0,-30,1,"condition[3]: %4.2f", atan((Monster[3].transZ - fire_z)/(Monster[3].transX - fire_x + 0.5f))/ piover180
  2688. - atan((ztrans2 -Monster[3].transZ)/(xtrans2 - Monster[3].transX + 0.5f))/ piover180);
  2689. glPrint(0,-50,1,"[3]hit %2.0d", Monster[3].hitCount);
  2690. if( Monster[3].hitStatus == true )
  2691. {
  2692. glPrint(0,-70,1,"[3]dead");
  2693. }
  2694. glPrint(0,-90,1,"transX[4]: %4.2f C", Monster[4].transX/CELL);
  2695. glPrint(0,-110,1,"transZ[4]: %4.2f C", Monster[4].transZ/CELL);
  2696. glPrint(0,-130,1,"condition[4]: %4.2f", atan((Monster[4].transZ - fire_z)/(Monster[4].transX - fire_x + 0.5f))/ piover180
  2697. - atan((ztrans2 -Monster[4].transZ)/(xtrans2 - Monster[4].transX + 0.5f))/ piover180);
  2698. glPrint(0,-150,1,"[4]hit %2.0d", Monster[4].hitCount);
  2699. if( Monster[4].hitStatus == true )
  2700. {
  2701. glPrint(0,-170,1,"[4]dead");
  2702. }
  2703. glPrint(0,-190,1,"transX[5]: %4.2f C", Monster[5].transX/CELL);
  2704. glPrint(0,-210,1,"transZ[5]: %4.2f C", Monster[5].transZ/CELL);
  2705. glPrint(0,-230,1,"condition[5]: %4.2f", atan((Monster[5].transZ - fire_z)/(Monster[5].transX - fire_x + 0.5f))/ piover180
  2706. - atan((ztrans2 -Monster[5].transZ)/(xtrans2 - Monster[5].transX + 0.5f))/ piover180);
  2707. glPrint(0,-250,1,"[5]hit %2.0d", Monster[5].hitCount);
  2708. if( Monster[5].hitStatus == true )
  2709. {
  2710. glPrint(0,-270,1,"[5]dead");
  2711. }
  2713. glEnable(GL_DEPTH_TEST);           
  2714.     glDisable(GL_TEXTURE_2D);
  2715.     glEnable(GL_TEXTURE_2D);
  2716.   }
  2717. }else
  2718. {
  2719. glDisable(GL_DEPTH_TEST);   
  2720. glBindTexture(GL_TEXTURE_2D, textures[0].texID); // Select Our Font Texture
  2721. glColor4d(1,1,1,1);
  2722. glPrint(150,190,1,"Game Over!");
  2723. glEnable(GL_DEPTH_TEST);
  2724. glDisable(GL_TEXTURE_2D);
  2725.     glEnable(GL_TEXTURE_2D);
  2726. }
  2727.   return TRUE; // Keep Going
  2729. }
  2731. GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
  2732. {
  2733. // When we are done, we need to free all the model data
  2734. // We do this by walking through all the objects and freeing their information
  2736. // Go through all the objects in the scene
  2737. for(int i = 0; i < g_3DModel.numOfObjects; i++)
  2738. {
  2739. // Free the faces, normals, vertices, and texture coordinates.
  2740. if(g_3DModel.pObject[i].pFaces) delete [] g_3DModel.pObject[i].pFaces;
  2741. if(g_3DModel.pObject[i].pNormals) delete [] g_3DModel.pObject[i].pNormals;
  2742. if(g_3DModel.pObject[i].pVerts) delete [] g_3DModel.pObject[i].pVerts;
  2743. if(g_3DModel.pObject[i].pTexVerts) delete [] g_3DModel.pObject[i].pTexVerts;
  2744. }
  2746. KillFont();
  2747. if (hRC) // Do We Have A Rendering Context?
  2748. {
  2749. if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
  2750. {
  2751. MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  2752. }
  2754. if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
  2755. {
  2756. MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  2757. }
  2758. hRC=NULL; // Set RC To NULL
  2759. }
  2761. if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
  2762. {
  2763. MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  2764. hDC=NULL; // Set DC To NULL
  2765. }
  2767. if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
  2768. {
  2769. MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  2770. hWnd=NULL; // Set hWnd To NULL
  2771. }
  2773. if (fullscreen) // Are We In Fullscreen Mode?
  2774. {
  2775. ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
  2776. ShowCursor(TRUE); // Show Mouse Pointer
  2777. }
  2778. }
  2780. /* This Code Creates Our OpenGL Window.  Parameters Are: *
  2781.  * title - Title To Appear At The Top Of The Window *
  2782.  * width - Width Of The GL Window Or Fullscreen Mode *
  2783.  * height - Height Of The GL Window Or Fullscreen Mode *
  2784.  * bits - Number Of Bits To Use For Color (8/16/24/32) *
  2785.  * fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */
  2786.  
  2787. BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
  2788. {
  2789. GLuint PixelFormat; // Holds The Results After Searching For A Match
  2790. WNDCLASS wc; // Windows Class Structure
  2791. DWORD dwExStyle; // Window Extended Style
  2792. DWORD dwStyle; // Window Style
  2793. RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
  2794. WindowRect.left=(long)0; // Set Left Value To 0
  2795. WindowRect.right=(long)width; // Set Right Value To Requested Width
  2796. WindowRect.top=(long)0; // Set Top Value To 0
  2797. WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
  2799. fullscreen=fullscreenflag; // Set The Global Fullscreen Flag
  2801. hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
  2802. wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
  2803. wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
  2804. wc.cbClsExtra = 0; // No Extra Window Data
  2805. wc.cbWndExtra = 0; // No Extra Window Data
  2806. wc.hInstance = hInstance; // Set The Instance
  2807. wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
  2808. wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
  2809. wc.hbrBackground = NULL; // No Background Required For GL
  2810. wc.lpszMenuName = NULL; // We Don't Want A Menu
  2811. wc.lpszClassName = "OpenGL"; // Set The Class Name
  2813. if (!RegisterClass(&wc)) // Attempt To Register The Window Class
  2814. {
  2815. MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2816. return FALSE; // Return FALSE
  2817. }
  2819. if (fullscreen) // Attempt Fullscreen Mode?
  2820. {
  2821. DEVMODE dmScreenSettings; // Device Mode
  2822. memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
  2823. dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
  2824. dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
  2825. dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
  2826. dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
  2827. dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
  2829. // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
  2830. if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
  2831. {
  2832. // If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
  2833. if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported BynYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
  2834. {
  2835. fullscreen=FALSE; // Windowed Mode Selected.  Fullscreen = FALSE
  2836. }
  2837. else
  2838. {
  2839. // Pop Up A Message Box Letting User Know The Program Is Closing.
  2840. MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
  2841. return FALSE; // Return FALSE
  2842. }
  2843. }
  2844. }
  2846. if (fullscreen) // Are We Still In Fullscreen Mode?
  2847. {
  2848. dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
  2849. dwStyle=WS_POPUP; // Windows Style
  2850. ShowCursor(FALSE); // Hide Mouse Pointer
  2851. }
  2852. else
  2853. {
  2854. dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
  2855. dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
  2856. }
  2858. AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
  2860. // Create The Window
  2861. if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
  2862. "OpenGL", // Class Name
  2863. title, // Window Title
  2864. dwStyle | // Defined Window Style
  2865. WS_CLIPSIBLINGS | // Required Window Style
  2866. WS_CLIPCHILDREN, // Required Window Style
  2867. 0, 0, // Window Position
  2868. WindowRect.right-WindowRect.left, // Calculate Window Width
  2869. WindowRect.bottom-WindowRect.top, // Calculate Window Height
  2870. NULL, // No Parent Window
  2871. NULL, // No Menu
  2872. hInstance, // Instance
  2873. NULL))) // Dont Pass Anything To WM_CREATE
  2874. {
  2875. KillGLWindow(); // Reset The Display
  2876. MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2877. return FALSE; // Return FALSE
  2878. }
  2880. static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
  2881. {
  2882. sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
  2883. 1, // Version Number
  2884. PFD_DRAW_TO_WINDOW | // Format Must Support Window
  2885. PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
  2886. PFD_DOUBLEBUFFER, // Must Support Double Buffering
  2887. PFD_TYPE_RGBA, // Request An RGBA Format
  2888. bits, // Select Our Color Depth
  2889. 0, 0, 0, 0, 0, 0, // Color Bits Ignored
  2890. 0, // No Alpha Buffer
  2891. 0, // Shift Bit Ignored
  2892. 0, // No Accumulation Buffer
  2893. 0, 0, 0, 0, // Accumulation Bits Ignored
  2894. 16, // 16Bit Z-Buffer (Depth Buffer)  
  2895. 0, // No Stencil Buffer
  2896. 0, // No Auxiliary Buffer
  2897. PFD_MAIN_PLANE, // Main Drawing Layer
  2898. 0, // Reserved
  2899. 0, 0, 0 // Layer Masks Ignored
  2900. };
  2902. if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
  2903. {
  2904. KillGLWindow(); // Reset The Display
  2905. MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2906. return FALSE; // Return FALSE
  2907. }
  2909. if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
  2910. {
  2911. KillGLWindow(); // Reset The Display
  2912. MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2913. return FALSE; // Return FALSE
  2914. }
  2916. if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
  2917. {
  2918. KillGLWindow(); // Reset The Display
  2919. MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2920. return FALSE; // Return FALSE
  2921. }
  2923. if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
  2924. {
  2925. KillGLWindow(); // Reset The Display
  2926. MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2927. return FALSE; // Return FALSE
  2928. }
  2930. if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
  2931. {
  2932. KillGLWindow(); // Reset The Display
  2933. MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2934. return FALSE; // Return FALSE
  2935. }
  2937. ShowWindow(hWnd,SW_SHOW); // Show The Window
  2938. SetForegroundWindow(hWnd); // Slightly Higher Priority
  2939. SetFocus(hWnd); // Sets Keyboard Focus To The Window
  2940. ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
  2942. if (!InitGL()) // Initialize Our Newly Created GL Window
  2943. {
  2944. KillGLWindow(); // Reset The Display
  2945. MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  2946. return FALSE; // Return FALSE
  2947. }
  2949. return TRUE; // Success
  2950. }
  2952. LRESULT CALLBACK WndProc( HWND hWnd, // Handle For This Window
  2953. UINT uMsg, // Message For This Window
  2954. WPARAM wParam, // Additional Message Information
  2955. LPARAM lParam) // Additional Message Information
  2956. {
  2957. if (uMsg == WM_MOUSEMOVE)
  2958. {
  2959. if (LOWORD(lParam) > 370) SetCursorPos(10,(int)mouse_y), mouse_wrap_x--;
  2960. else if (LOWORD(lParam) < 10) SetCursorPos(370,(int)mouse_y), mouse_wrap_x++;
  2962. if (HIWORD(lParam) > 370) SetCursorPos((int)mouse_x,10), mouse_wrap_x--;
  2963. else if (HIWORD(lParam) < 10) SetCursorPos((int)mouse_x,370), mouse_wrap_x++;
  2965. if (ABS(mouse_x-LOWORD(lParam)) > 300)
  2966. {
  2967. if (mouse_x > 360/2)
  2968. mouse_3d_x += ((mouse_x-360)-LOWORD(lParam))/sensitivity;
  2969. else if (LOWORD(lParam) > 360/2)
  2970. mouse_3d_x += (mouse_x-(LOWORD(lParam)-360))/sensitivity;
  2971. }
  2972. else
  2973. { 
  2974. mouse_3d_x += (mouse_x-LOWORD(lParam))/sensitivity;
  2975. } 
  2977. if (mouse_3d_x > 360) mouse_3d_x = 0;
  2978. else if (mouse_3d_x < 0) mouse_3d_x = 360;
  2980. if (invert_mouse)
  2981. {
  2982. if (ABS(mouse_y-HIWORD(lParam)) > 300)
  2983. { 
  2984. if (mouse_y > 360/2)
  2985. mouse_3d_y -= (HIWORD(lParam)-(mouse_y-360))/sensitivity;
  2986. else if (LOWORD(lParam) > 360/2)
  2987. mouse_3d_y -= ((HIWORD(lParam)-360)-mouse_y)/sensitivity;
  2988. }
  2989. else
  2990. { 
  2991. mouse_3d_y -= (HIWORD(lParam)-mouse_y)/sensitivity;
  2992. } 
  2993. }
  2994. else
  2995. {
  2996. if (ABS(mouse_y-HIWORD(lParam)) > 300)
  2997. { 
  2998. if (mouse_y > 360/2)
  2999. mouse_3d_y -= ((mouse_y-360)-HIWORD(lParam))/sensitivity;
  3000. else if (LOWORD(lParam) > 360/2)
  3001. mouse_3d_y -= (mouse_y-(HIWORD(lParam)-360))/sensitivity;
  3002. }
  3003. else
  3004. { 
  3005. mouse_3d_y -= (mouse_y-HIWORD(lParam))/sensitivity;
  3006. } 
  3007. }
  3009. if (mouse_3d_x > 360) mouse_3d_x = 0;
  3010. else if (mouse_3d_x < 0) mouse_3d_x = 360;
  3012. if (mouse_3d_y > 85) mouse_3d_y = 85;
  3013. else if (mouse_3d_y < -85) mouse_3d_y = -85;
  3015. mouse_x = LOWORD(lParam);          
  3016. mouse_y = HIWORD(lParam);
  3017. }
  3019. else if (uMsg == WM_LBUTTONDOWN)
  3020. {     
  3021. isFire = true;
  3022. }
  3024. else if (uMsg == WM_ACTIVATE) // Watch For Window Activate Message
  3025. {
  3026. if (!HIWORD(wParam)) // Check Minimization State
  3027. {
  3028. active=TRUE; // Program Is Active
  3029. }
  3030. else
  3031. {
  3032. active=FALSE; // Program Is No Longer Active
  3033. }
  3035. }
  3036.         
  3037. else if (uMsg == WM_SYSCOMMAND) // Intercept System Commands
  3038. {
  3039. switch (wParam) // Check System Calls
  3040. {
  3041. case SC_SCREENSAVE: // Screensaver Trying To Start?
  3042. case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?
  3044. return 0; // Prevent From Happening
  3045. }
  3046. }
  3047.         
  3048. else if (uMsg == WM_CLOSE) // Did We Receive A Close Message?
  3049. {
  3050.  PostQuitMessage(0); // Send A Quit Message
  3051. }
  3052.         
  3053. else if (uMsg == WM_KEYDOWN) // Is A Key Being Held Down?
  3054. {
  3055. keys[wParam] = TRUE; // If So, Mark It As TRUE
  3056. }
  3057.         
  3058. else if (uMsg == WM_KEYUP) // Has A Key Been Released?
  3059. {
  3060. keys[wParam] = FALSE; // If So, Mark It As FALSE
  3061. }
  3062.         
  3063. else if (uMsg == WM_SIZE) // Resize The OpenGL Window
  3064. {
  3065. ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
  3066. }        
  3068. // Pass All Unhandled Messages To DefWindowProc
  3069. return DefWindowProc(hWnd,uMsg,wParam,lParam);
  3070. }
  3072. int is_Fired = 0; 
  3074. int WINAPI WinMain( HINSTANCE hInstance, // Instance
  3075. HINSTANCE hPrevInstance, // Previous Instance
  3076. LPSTR lpCmdLine, // Command Line Parameters
  3077. int nCmdShow) // Window Show State
  3078. {
  3079. MSG msg; // Windows Message Structure
  3080. BOOL done=FALSE; // Bool Variable To Exit Loop
  3082. // Ask The User Which Screen Mode They Prefer
  3083. if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode(Support Mouse Movement)?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
  3084. {
  3085. fullscreen=FALSE; // Windowed Mode
  3086. }
  3088. // Create Our OpenGL Window
  3089. if (!CreateGLWindow("First Person Shooter",640,480,16,fullscreen))
  3090. {
  3091. return 0; // Quit If Window Was Not Created
  3092. }
  3094. while(!done) // Loop That Runs While done=FALSE
  3095. {
  3096. if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
  3097. {
  3098. if (msg.message==WM_QUIT) // Have We Received A Quit Message?
  3099. {
  3100. done=TRUE; // If So done=TRUE
  3101. }
  3102. else // If Not, Deal With Window Messages
  3103. {
  3104. TranslateMessage(&msg); // Translate The Message
  3105. DispatchMessage(&msg); // Dispatch The Message
  3106. }
  3107. }
  3108. else // If There Are No Messages
  3109. {
  3110. // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
  3111. if ((active && !DrawGLScene()) || keys[VK_ESCAPE]) // Active?  Was There A Quit Received?
  3112. {
  3113. done=TRUE; // ESC or DrawGLScene Signalled A Quit
  3114. }
  3115. else // Not Time To Quit, Update Screen
  3116. {
  3117. SwapBuffers(hDC); // Swap Buffers (Double Buffering)
  3119. is_Fired--;
  3120. if (is_Fired < 0) is_Fired = 0;
  3122. if (keys[VK_UP])  // Move forwards
  3123.         {
  3124.           XP -= (GLdouble)sin(heading*piover180) * 10.0f;
  3125.           ZP -= (GLdouble)cos(heading*piover180) * 10.0f;
  3126.         }
  3127.         else if (keys['W'])  // Move forwards
  3128.         {
  3129.           XP -= (GLdouble)sin(heading*piover180) * 10.0f;
  3130.           ZP -= (GLdouble)cos(heading*piover180) * 10.0f;
  3131.         }
  3133.         if (keys[VK_DOWN]) // Move backwards
  3134.         {
  3135.           XP += (GLdouble)sin(heading*piover180) * 10.0f;
  3136.           ZP += (GLdouble)cos(heading*piover180) * 10.0f;
  3137.         }                
  3138.         else if (keys['S']) // Move backwards
  3139.         {
  3140.           XP += (GLdouble)sin(heading*piover180) * 10.0f;
  3141.           ZP += (GLdouble)cos(heading*piover180) * 10.0f;
  3142.         }
  3144.         if (keys['A'])  // strafe left
  3145.         {
  3146.           XP += (GLdouble)sin((heading-90)*piover180) * 10.0f;
  3147.           ZP += (GLdouble)cos((heading-90)*piover180) * 10.0f;
  3148.         }
  3150.         if (keys['D']) // strafe right
  3151.         {
  3152.           XP += (GLdouble)sin((heading+90)*piover180) * 10.0f;
  3153.           ZP += (GLdouble)cos((heading+90)*piover180) * 10.0f;
  3154.         }                
  3156.         if (keys[VK_LEFT]) // Turn left
  3157.         {
  3158.           zprot += .5f;
  3159.         }
  3160.         else if (keys[VK_RIGHT]) // Turn right
  3161.         {
  3162.           zprot -= .5f;
  3163.         }
  3165. if (keys['F'] && !fp) // Toggle Frame Per Second Counter
  3166.         {
  3167.           isFPS = !isFPS;
  3168.           fp = true;
  3169.         }
  3170.         else if (!keys['F'])
  3171.         {
  3172.           fp = false;
  3173.         }        
  3175. if (keys['I'] && !ip) // Invert y-axis for the mouse
  3176.         {
  3177.           invert_mouse = !invert_mouse;
  3178.           ip = true;
  3179.         }
  3180.         else if (!keys['I'])
  3181.         {
  3182.           ip = false;
  3183.         }
  3184.       }
  3185.     }
  3186.   }
  3188. // Shutdown
  3189. KillGLWindow(); // Kill The Window
  3190. return (msg.wParam); // Exit The Program
  3191. }