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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
DUDEVIEW.CPP
资源名称：tc3d.zip　[点击查看]
上传用户：abcdshs
上传日期：2007-01-07
资源大小：1858k
文件大小：16k
源码类别：

游戏

开发平台：

Visual C++

DUDEVIEW.CPP：源码内容
  1. // dudeView.cpp : implementation of the DudeView class
  2. //
  4. #include "stdafx.h"
  5. #include "dudes.h"
  7. #include "dudeDoc.h"
  8. #include "dudeView.h"
  9. #include "levels.h"
  11. KeyControl keyboardcontrol = NOKEYHIT;
  13. static char movebuttondown = FALSE;
  14. static char walkcount;
  15. static CPoint currpoint;
  17. #ifdef EDITOR
  18. enum selectmodetype
  19. {
  20.     STOP,
  21.     MOVING,
  22.     ROTATING
  23. };
  25. selectmodetype selectmode;
  27. #endif
  28. /////////////////////////////////////////////////////////////////////////////
  29. // DudeView
  31. IMPLEMENT_DYNCREATE(DudeView, CView)
  33. BEGIN_MESSAGE_MAP(DudeView, CView)
  34.     //{{AFX_MSG_MAP(DudeView)
  35.     ON_WM_LBUTTONDOWN()
  36.     ON_WM_MOUSEMOVE()
  37.     ON_WM_RBUTTONDOWN()
  38.     ON_WM_SIZE()
  39.     ON_WM_TIMER()
  40.     ON_WM_CREATE()
  41.     ON_WM_DESTROY()
  42.     ON_WM_LBUTTONUP()
  43.     ON_WM_RBUTTONUP()
  44. ON_COMMAND(ID_NEW_GAME, OnNewGame)
  45. ON_WM_KEYDOWN()
  46. ON_WM_KEYUP()
  47. //}}AFX_MSG_MAP
  48. END_MESSAGE_MAP()
  50. /////////////////////////////////////////////////////////////////////////////
  51. // DudeView construction/destruction
  53. DudeView::DudeView()
  54. {
  55.     hdc   = ::GetDC(m_hWnd);
  56.     Game = new DudesWrapper;
  57.     Game->InitLaunch();
  58. }
  60. DudeView::~DudeView()
  61. {
  62.     ::ReleaseDC(m_hWnd, hdc);
  63.     Game->CleanUp();
  64.     delete Game;
  65. }
  67. void DudeView::LaunchGame()
  68. {
  69.     wglMakeCurrent(Game->hdc, Game->hrc);
  70.     Game->Launch();
  71.     wglMakeCurrent(Game->hdc, NULL);
  72. }
  74. BOOL DudeView::PreCreateWindow(CREATESTRUCT& cs)
  75. {
  76.     cs.style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
  78.     return CView::PreCreateWindow(cs);
  79. }
  81. /////////////////////////////////////////////////////////////////////////////
  82. // DudeView 
  84. void DudeView::OnDraw(CDC* pDC)
  85. {
  86.     //DudeDoc* pDoc = GetDocument();
  87.     //ASSERT_VALID(pDoc);
  88.     pDC = pDC;
  90.     SetTimer(1, 1, NULL);
  91.     //::ReleaseDC(m_hWnd, hdc);
  92.     //hdc   = ::GetDC(m_hWnd);
  93.     //LaunchGame();
  94. }
  96. /////////////////////////////////////////////////////////////////////////////
  97. // DudeView diagnostics
  99. #ifdef _DEBUG
  100. void DudeView::AssertValid() const
  101. {
  102.     CView::AssertValid();
  103. }
  105. void DudeView::Dump(CDumpContext& dc) const
  106. {
  107.     CView::Dump(dc);
  108. }
  110. DudeDoc* DudeView::GetDocument() // non-debug version is inline
  111. {
  112.     ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(DudeDoc)));
  113.     return (DudeDoc*)m_pDocument;
  114. }
  115. #endif //_DEBUG
  117. /////////////////////////////////////////////////////////////////////////////
  118. // DudeView message handlers
  120. void DudeView::CalcWindowRect(LPRECT lpClientRect, UINT nAdjustType) 
  121. {
  122.     CView::CalcWindowRect(lpClientRect, nAdjustType);
  123. }
  125. LRESULT DudeView::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  126. {
  127.     return CView::DefWindowProc(message, wParam, lParam);
  128. }
  130. void DudeView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
  131. {
  132.     ::ReleaseDC(m_hWnd, hdc);
  133.     hdc   = ::GetDC(m_hWnd);
  134.     CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
  135. }
  137. BOOL DudeView::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) 
  138. {
  139.     
  140.     return CView::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  141. }
  143. BOOL DudeView::OnCommand(WPARAM wParam, LPARAM lParam) 
  144. {
  145.     
  146.     return CView::OnCommand(wParam, lParam);
  147. }
  149. LRESULT DudeView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  150. {
  151.     // TODO: Add your specialized code here and/or call the base class
  152.     return CView::WindowProc(message, wParam, lParam);
  153. }
  155. void DudeView::WinHelp(DWORD dwData, UINT nCmd) 
  156. {
  157.     // TODO: Add your specialized code here and/or call the base class
  158.     
  159.     CView::WinHelp(dwData, nCmd);
  160. }
  162. void DudeView::OnLButtonDown(UINT nFlags, CPoint point) 
  163. {
  164.     CView::OnLButtonDown(nFlags, point);
  165.     currpoint = point;
  166. #ifdef EDITOR
  167.     if (Game->LevelPtr()->selection)
  168.         selectmode = MOVING;
  169.     else
  170.         movebuttondown = TRUE;
  171. #else
  172.     movebuttondown = TRUE;
  173. #endif
  174. }
  176. void DudeView::OnMouseMove(UINT nFlags, CPoint point) 
  177. {
  178.     CView::OnMouseMove(nFlags, point);
  179. #ifdef EDITOR
  180.     if (Game->LevelPtr()->selection && selectmode != STOP)
  181.     {
  182.         view newloc = Game->LevelPtr()->selection->location();
  183.         float xdif = (float)(currpoint.x - point.x);
  184.         float zdif = (float)(currpoint.y - point.y);
  185.         if (selectmode == MOVING)
  186.         {
  187.             newloc.setx(newloc.x() + xdif/100.0f);
  188.             newloc.setz(newloc.z() + zdif/100.0f);
  189.         }
  190.         else if (selectmode == ROTATING)
  191.         {
  192.             newloc.setxdir(newloc.xdirection()+(direction)xdif);
  193.             newloc.setzdir(newloc.zdirection()+(direction)zdif);
  194.         }
  195.         Game->LevelPtr()->selection->setto(newloc);
  196.     }
  197. #endif
  198.     currpoint = point;
  199. }
  201. void DudeView::OnRButtonDown(UINT nFlags, CPoint point) 
  202. {
  203.     CView::OnRButtonDown(nFlags, point);
  204. #ifdef EDITOR
  205.     if (Game->LevelPtr()->selection)
  206.         selectmode = ROTATING;
  207. #else
  208.     if (!Game->Motionless())
  209.         Game->LevelPtr()->usercontrol->block();
  210. #endif
  211. }
  213. void DudeView::OnTimer(UINT nIDEvent) 
  214. {
  215.     static char turning;
  216.     LaunchGame();
  217.     
  218.     CView::OnTimer(nIDEvent);
  219.     char motion = (char) ((movebuttondown || keyboardcontrol != NOKEYHIT)
  220.                     && !Game->Motionless());
  222. #ifdef EDITOR
  223.     if (!Game->LevelPtr()->selection)
  224. #endif
  225.     if (motion)
  226.     {
  227.         if (keyboardcontrol != NOKEYHIT)
  228.         {
  229.             switch(keyboardcontrol)
  230.             {
  231.             case FOWARD:
  232.                 if (++walkcount > 7)
  233.                    Game->LevelPtr()->usercontrol->runfoward();
  234.                 else
  235.                    Game->LevelPtr()->usercontrol->stepfoward();
  236.                 break;
  237.             case BACK:
  238.                 walkcount = 0;
  239.                 Game->LevelPtr()->usercontrol->stepbackward();
  240.                 break;
  241.             case LEFT:
  242.                 walkcount = 0;
  243.                 Game->LevelPtr()->usercontrol->turnleft();
  244.                 break;
  245.             case RIGHT:
  246.                 walkcount = 0;
  247.                 Game->LevelPtr()->usercontrol->turnright();
  248.                 break;
  249.             case HIT:
  250.                 if (random(10) == 3)
  251.                     Game->LevelPtr()->usercontrol->selectpunch(random(100),Game->Hero()->punchlist());
  252.                 else
  253.                     Game->LevelPtr()->usercontrol->selectpunch(random(100),Game->Hero()->normalpunch());
  254.                 break;
  255.             case BLOCK:
  256.                 Game->LevelPtr()->usercontrol->block();
  257.                 break;
  258.             }
  259.             keyboardcontrol = NOKEYHIT;
  260.         }
  261.         else
  262.         {
  263.             direction tmpdir, tcdir, tmp;
  264.             tmpdir = getdirection((float)Game->Centx(),
  265.                                   (float)Game->Centy(),
  266.                                   (float)currpoint.x,
  267.                                   (float)currpoint.y) +
  268.                                   Game->Aim().ydirectionto(camera);
  269.             tcdir = Game->LevelPtr()->usercontrol->location().ydirection();
  270.             tmp = tmpdir - tcdir;
  271.             if (tmp < (direction) TC_PI_8 || tmp > (direction) -TC_PI_8)
  272.             {
  273.                 if (turning)
  274.                 {
  275.                     turning = FALSE;
  276.                     walkcount = 0;
  277.                     Game->LevelPtr()->usercontrol->stopeverything();
  278.                 }
  279.                 if (movebuttondown)
  280.                 {
  281.                     if (++walkcount > 7)
  282.                        Game->LevelPtr()->usercontrol->runfoward();
  283.                     else
  284.                        Game->LevelPtr()->usercontrol->stepfoward();
  285.                 }
  286.             }
  287.             else
  288.             {
  289.                 if (!turning)
  290.                 {
  291.                     turning = TRUE;
  292.                     Game->LevelPtr()->usercontrol->stopeverything();
  293.                 }
  294.                 if (tcdir < tmpdir)
  295.                     Game->LevelPtr()->usercontrol->turnleft();
  296.                 else
  297.                     Game->LevelPtr()->usercontrol->turnright();
  298.             }
  299.         }
  300.     }
  301. }
  303. static float lightAmbient[] = {1.0f,1.0f,1.0f,0.0f};
  305. int DudeView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  306. {
  307.     if (CView::OnCreate(lpCreateStruct) == -1)
  308.         return -1;
  309.     
  310.     PIXELFORMATDESCRIPTOR pfd;
  311.     int         n;
  313.     m_pDC = new CClientDC(this);
  315.     ASSERT(m_pDC != NULL);
  317.     Game->hdc = m_pDC->GetSafeHdc();
  318.     if (!bSetupPixelFormat())
  319.         return 1;
  321.     n = ::GetPixelFormat(Game->hdc);
  322.     ::DescribePixelFormat(Game->hdc, n, sizeof(pfd), &pfd);
  324.     if (pfd.dwFlags & PFD_NEED_PALETTE)
  325.         SetupLogicalPalette();
  327.     Game->hrc = wglCreateContext(Game->hdc);
  329.     wglMakeCurrent(Game->hdc, Game->hrc);
  330.     glEnable(GL_LIGHT0);
  331.     glEnable(GL_LIGHTING);
  332.     glEnable(GL_DEPTH_TEST);
  333.     //glDisable(GL_LIGHTING);
  334.     glDepthFunc(GL_LEQUAL);
  335.     glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
  336.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  337.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  338.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  339.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  340.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  341.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  342.     glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_FASTEST);
  343.     glHint(GL_POINT_SMOOTH_HINT,GL_FASTEST);
  344.     glHint(GL_POLYGON_SMOOTH_HINT,GL_FASTEST);
  345.     glHint(GL_LINE_SMOOTH_HINT,GL_FASTEST);
  346.     glHint(GL_FOG_HINT,GL_FASTEST);
  347.     glShadeModel(GL_FLAT);
  348.     wglMakeCurrent(Game->hdc, NULL);
  349.     Game->hwnd = m_hWnd;
  350.     return 0;
  351. }
  353. void DudeView::OnDestroy() 
  354. {
  356.     KillTimer(1);
  358.     Game->hrc = ::wglGetCurrentContext();
  360.     ::wglMakeCurrent(NULL,  NULL);
  362.     if (Game->hrc)
  363.         ::wglDeleteContext(Game->hrc);
  365.     if (m_pDC)
  366.         delete m_pDC;
  367.     CView::OnDestroy();
  368.     
  369. }
  371. BOOL DudeView::bSetupPixelFormat()
  372. {
  373.     static PIXELFORMATDESCRIPTOR pfd = 
  374.     {
  375.         sizeof(PIXELFORMATDESCRIPTOR),  // size of this pfd
  376.         1,                              // version number
  377.         PFD_DRAW_TO_WINDOW |            // support window
  378.           PFD_SUPPORT_OPENGL |          // support OpenGL
  379.           PFD_DOUBLEBUFFER,             // double buffered
  380.         PFD_TYPE_RGBA,                  // RGBA type
  381.         24,                             // 24-bit color depth
  382.         0, 0, 0, 0, 0, 0,               // color bits ignored
  383.         0,                              // no alpha buffer
  384.         0,                              // shift bit ignored
  385.         0,                              // no accumulation buffer
  386.         0, 0, 0, 0,                     // accum bits ignored
  387.         32,                             // 32-bit z-buffer
  388.         0,                              // no stencil buffer
  389.         0,                              // no auxiliary buffer
  390.         PFD_MAIN_PLANE,                 // main layer
  391.         0,                              // reserved
  392.         0, 0, 0                         // layer masks ignored
  393.     };
  394.     int pixelformat;
  396.     if ( (pixelformat = ChoosePixelFormat(Game->hdc, &pfd)) == 0 )
  397.     {
  398.         MessageBox("ChoosePixelFormat failed");
  399.         return FALSE;
  400.     }
  402.     if (SetPixelFormat(Game->hdc, pixelformat, &pfd) == FALSE)
  403.     {
  404.         MessageBox("SetPixelFormat failed");
  405.         return FALSE;
  406.     }
  408.     return TRUE;
  409. }
  413. void DudeView::OnSize(UINT nType, int cx, int cy) 
  414. {
  415.     CView::OnSize(nType, cx, cy);
  416.     
  417.     if(cy > 0)
  418.     {    
  419.         wglMakeCurrent(Game->hdc, Game->hrc);
  420.         glViewport(0, 0, cx, cy);
  422.         if((m_oldRect.right > cx) || (m_oldRect.bottom > cy))
  423.             RedrawWindow();
  425.         m_oldRect.right = cx;
  426.         m_oldRect.bottom = cy;
  428.         glMatrixMode(GL_PROJECTION);
  429.         glLoadIdentity();
  430.         gluPerspective(45.0f, (GLdouble)cx/cy, 1.0f, 20.0f);
  431.         glMatrixMode(GL_MODELVIEW);
  432.         wglMakeCurrent(Game->hdc, NULL);
  433.     }
  434.     Game->SetCx     ((short)cx);
  435.     Game->SetCy     ((short)cy);
  436.     Game->SetCentx  ((short)(cx/2));
  437.     Game->SetCenty  ((short)(cy/2));
  438. }
  440. void DudeView::OnLButtonUp(UINT nFlags, CPoint point) 
  441. {
  442.     CView::OnLButtonUp(nFlags, point);
  443.     movebuttondown = FALSE;
  444.     if (!Game->Motionless())
  445.         Game->LevelPtr()->usercontrol->stopeverything();
  446. #ifdef EDITOR
  447.     selectmode = STOP;
  448. #endif
  449. }
  451. void DudeView::OnRButtonUp(UINT nFlags, CPoint point) 
  452. {
  453.     CView::OnRButtonUp(nFlags, point);
  454. #ifndef EDITOR
  455.     short xtmpval = (short)((point.x * 100) / Game->Cx());
  456.     short ytmpval = (short)((point.y * 100) / Game->Cx());
  457.     if (!Game->Motionless())
  458.     {
  459.         if (ytmpval > 40 && ytmpval < 60)
  460.             Game->LevelPtr()->usercontrol->selectpunch(xtmpval,Game->Hero()->punchlist());
  461.         else
  462.             Game->LevelPtr()->usercontrol->selectpunch(xtmpval,Game->Hero()->normalpunch());
  463.     }
  464. #else
  465.     selectmode = STOP;
  466. #endif
  467. }
  469. void DudeView::SetupLogicalPalette()
  470. {
  471.     PIXELFORMATDESCRIPTOR pfd;
  472.     LOGPALETTE *pPal;
  473.     int n, i;
  474.     BYTE byRedMask, byGreenMask, byBlueMask;
  475.     n = ::GetPixelFormat(Game->hdc);
  476.     ::DescribePixelFormat(Game->hdc, n, sizeof(pfd), &pfd);
  478.     if (pfd.dwFlags & PFD_NEED_PALETTE)
  479.     {
  480.         n = 1 << pfd.cColorBits;
  481.         pPal = (PLOGPALETTE) new char[sizeof(LOGPALETTE) + n * sizeof(PALETTEENTRY)];
  483.         ASSERT(pPal != NULL);
  485.         pPal->palVersion = 0x300;
  486.         pPal->palNumEntries = (ushort) n;
  487.         byRedMask   = (uchar)((1<<pfd.cRedBits) -1);
  488.         byGreenMask = (uchar)((1<<pfd.cGreenBits) -1);
  489.         byBlueMask  = (uchar)((1<<pfd.cBlueBits) -1);
  490.         for (i=0; i<n; i++)
  491.         {
  492.             pPal->palPalEntry[i].peRed =
  493.                     (uchar)((((i>>pfd.cRedShift) & byRedMask) * 255) /byRedMask);
  494.             pPal->palPalEntry[i].peGreen =
  495.                     (uchar)((((i>>pfd.cGreenShift) & byGreenMask) * 255) /byGreenMask);
  496.             pPal->palPalEntry[i].peBlue =
  497.                     (uchar)((((i>>pfd.cBlueShift) & byBlueMask) * 255) /byBlueMask);
  498.             pPal->palPalEntry[i].peFlags = 0;
  499.         }
  501.         m_cPalette.CreatePalette(pPal);
  502.         delete pPal;
  504.         m_pDC->SelectPalette(&m_cPalette, FALSE);
  505.         m_pDC->RealizePalette();
  506.     }
  507. }
  509. void DudeView::OnNewGame() 
  510. {
  511.     Game->NewGame();
  512. #ifdef EDITOR
  513.     Game->Landscapes()->CleanUp();
  514. #endif
  515. }
  517. void DudeView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  518. {
  519.     switch(nChar)
  520.     {
  521.     case 49:
  522.         keyboardcontrol = V1;
  523.         break;
  524.     case 50:
  525.         keyboardcontrol = V2;
  526.         break;
  527.     case 51:
  528.         keyboardcontrol = V3;
  529.         break;
  530.     case 52:
  531.         keyboardcontrol = V4;
  532.         break;
  533.     case 53:
  534.         keyboardcontrol = V5;
  535.         break;
  536.     case 54:
  537.         keyboardcontrol = V6;
  538.         break;
  539.     case 55:
  540.         keyboardcontrol = V7;
  541.         break;
  542.     case 56:
  543.         keyboardcontrol = V8;
  544.         break;
  545.     case 57:
  546.         keyboardcontrol = V9;
  547.         break;
  548.     case 48:
  549.         keyboardcontrol = V0;
  550.         break;
  551.     case 38:
  552.         if (keyboardcontrol != FOWARD)
  553.         keyboardcontrol = FOWARD;
  554.         break;
  555.     case 40:
  556.         if (keyboardcontrol != BACK)
  557.         keyboardcontrol = BACK;
  558.         break;
  559.     case 37:
  560.         if (keyboardcontrol != LEFT)
  561.         keyboardcontrol = LEFT;
  562.         break;
  563.     case 39:
  564.         if (keyboardcontrol != RIGHT)
  565.         keyboardcontrol = RIGHT;
  566.         break;
  567.     case 13:
  568.         if (keyboardcontrol != HIT)
  569.         keyboardcontrol = HIT;
  570.         break;
  571.     case 32:
  572.         if (keyboardcontrol != BLOCK)
  573.         keyboardcontrol = BLOCK;
  574.         break;
  575.     }
  576. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  577. }
  579. void DudeView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
  580. {
  581.     keyboardcontrol = NOKEYHIT;
  582.     Game->LevelPtr()->usercontrol->stopeverything();
  583. CView::OnKeyUp(nChar, nRepCnt, nFlags);
  584. }