dudeview.cpp

一个三维打斗游戏

                if (tcdir < tmpdir)
                    Game->LevelPtr()->usercontrol->turnleft();
                else
                    Game->LevelPtr()->usercontrol->turnright();
            }
        }
    }
}

static float lightAmbient[] = {1.0f,1.0f,1.0f,0.0f};

int DudeView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
    if (CView::OnCreate(lpCreateStruct) == -1)
        return -1;
    
    PIXELFORMATDESCRIPTOR pfd;
    int         n;

    m_pDC = new CClientDC(this);

    ASSERT(m_pDC != NULL);

    Game->hdc = m_pDC->GetSafeHdc();
    if (!bSetupPixelFormat())
        return 1;

    n = ::GetPixelFormat(Game->hdc);
    ::DescribePixelFormat(Game->hdc, n, sizeof(pfd), &pfd);

    if (pfd.dwFlags & PFD_NEED_PALETTE)
        SetupLogicalPalette();

    Game->hrc = wglCreateContext(Game->hdc);

    wglMakeCurrent(Game->hdc, Game->hrc);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    //glDisable(GL_LIGHTING);
    glDepthFunc(GL_LEQUAL);
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_FASTEST);
    glHint(GL_POINT_SMOOTH_HINT,GL_FASTEST);
    glHint(GL_POLYGON_SMOOTH_HINT,GL_FASTEST);
    glHint(GL_LINE_SMOOTH_HINT,GL_FASTEST);
    glHint(GL_FOG_HINT,GL_FASTEST);
    glShadeModel(GL_FLAT);
    wglMakeCurrent(Game->hdc, NULL);
    Game->hwnd = m_hWnd;
    return 0;
}

void DudeView::OnDestroy() 
{

    KillTimer(1);

    Game->hrc = ::wglGetCurrentContext();

    ::wglMakeCurrent(NULL,  NULL);

    if (Game->hrc)
        ::wglDeleteContext(Game->hrc);

    if (m_pDC)
        delete m_pDC;
    CView::OnDestroy();
    
}

BOOL DudeView::bSetupPixelFormat()
{
    static PIXELFORMATDESCRIPTOR pfd = 
    {
        sizeof(PIXELFORMATDESCRIPTOR),  // size of this pfd
        1,                              // version number
        PFD_DRAW_TO_WINDOW |            // support window
          PFD_SUPPORT_OPENGL |          // support OpenGL
          PFD_DOUBLEBUFFER,             // double buffered
        PFD_TYPE_RGBA,                  // RGBA type
        24,                             // 24-bit color depth
        0, 0, 0, 0, 0, 0,               // color bits ignored
        0,                              // no alpha buffer
        0,                              // shift bit ignored
        0,                              // no accumulation buffer
        0, 0, 0, 0,                     // accum bits ignored
        32,                             // 32-bit z-buffer
        0,                              // no stencil buffer
        0,                              // no auxiliary buffer
        PFD_MAIN_PLANE,                 // main layer
        0,                              // reserved
        0, 0, 0                         // layer masks ignored
    };
    int pixelformat;

    if ( (pixelformat = ChoosePixelFormat(Game->hdc, &pfd)) == 0 )
    {
        MessageBox("ChoosePixelFormat failed");
        return FALSE;
    }

    if (SetPixelFormat(Game->hdc, pixelformat, &pfd) == FALSE)
    {
        MessageBox("SetPixelFormat failed");
        return FALSE;
    }

    return TRUE;
}



void DudeView::OnSize(UINT nType, int cx, int cy) 
{
    CView::OnSize(nType, cx, cy);
    
    if(cy > 0)
    {    
        wglMakeCurrent(Game->hdc, Game->hrc);
        glViewport(0, 0, cx, cy);

        if((m_oldRect.right > cx) || (m_oldRect.bottom > cy))
            RedrawWindow();

        m_oldRect.right = cx;
        m_oldRect.bottom = cy;

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45.0f, (GLdouble)cx/cy, 1.0f, 20.0f);
        glMatrixMode(GL_MODELVIEW);
        wglMakeCurrent(Game->hdc, NULL);
    }
    Game->SetCx     ((short)cx);
    Game->SetCy     ((short)cy);
    Game->SetCentx  ((short)(cx/2));
    Game->SetCenty  ((short)(cy/2));
}

void DudeView::OnLButtonUp(UINT nFlags, CPoint point) 
{
    CView::OnLButtonUp(nFlags, point);
    movebuttondown = FALSE;
    if (!Game->Motionless())
        Game->LevelPtr()->usercontrol->stopeverything();
#ifdef EDITOR
    selectmode = STOP;
#endif
}

void DudeView::OnRButtonUp(UINT nFlags, CPoint point) 
{
    CView::OnRButtonUp(nFlags, point);
#ifndef EDITOR
    short xtmpval = (short)((point.x * 100) / Game->Cx());
    short ytmpval = (short)((point.y * 100) / Game->Cx());
    if (!Game->Motionless())
    {
        if (ytmpval > 40 && ytmpval < 60)
            Game->LevelPtr()->usercontrol->selectpunch(xtmpval,Game->Hero()->punchlist());
        else
            Game->LevelPtr()->usercontrol->selectpunch(xtmpval,Game->Hero()->normalpunch());
    }
#else
    selectmode = STOP;
#endif
}

void DudeView::SetupLogicalPalette()
{
    PIXELFORMATDESCRIPTOR pfd;
    LOGPALETTE *pPal;
    int n, i;
    BYTE byRedMask, byGreenMask, byBlueMask;
    n = ::GetPixelFormat(Game->hdc);
    ::DescribePixelFormat(Game->hdc, n, sizeof(pfd), &pfd);

    if (pfd.dwFlags & PFD_NEED_PALETTE)
    {
        n = 1 << pfd.cColorBits;
        pPal = (PLOGPALETTE) new char[sizeof(LOGPALETTE) + n * sizeof(PALETTEENTRY)];

        ASSERT(pPal != NULL);

        pPal->palVersion = 0x300;
        pPal->palNumEntries = (ushort) n;
        byRedMask   = (uchar)((1<<pfd.cRedBits) -1);
        byGreenMask = (uchar)((1<<pfd.cGreenBits) -1);
        byBlueMask  = (uchar)((1<<pfd.cBlueBits) -1);
        for (i=0; i<n; i++)
        {
            pPal->palPalEntry[i].peRed =
                    (uchar)((((i>>pfd.cRedShift) & byRedMask) * 255) /byRedMask);
            pPal->palPalEntry[i].peGreen =
                    (uchar)((((i>>pfd.cGreenShift) & byGreenMask) * 255) /byGreenMask);
            pPal->palPalEntry[i].peBlue =
                    (uchar)((((i>>pfd.cBlueShift) & byBlueMask) * 255) /byBlueMask);
            pPal->palPalEntry[i].peFlags = 0;
        }

        m_cPalette.CreatePalette(pPal);
        delete pPal;

        m_pDC->SelectPalette(&m_cPalette, FALSE);
        m_pDC->RealizePalette();
    }
}

void DudeView::OnNewGame() 
{
    Game->NewGame();
#ifdef EDITOR
    Game->Landscapes()->CleanUp();
#endif
}

void DudeView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
    switch(nChar)
    {
    case 49:
        keyboardcontrol = V1;
        break;
    case 50:
        keyboardcontrol = V2;
        break;
    case 51:
        keyboardcontrol = V3;
        break;
    case 52:
        keyboardcontrol = V4;
        break;
    case 53:
        keyboardcontrol = V5;
        break;
    case 54:
        keyboardcontrol = V6;
        break;
    case 55:
        keyboardcontrol = V7;
        break;
    case 56:
        keyboardcontrol = V8;
        break;
    case 57:
        keyboardcontrol = V9;
        break;
    case 48:
        keyboardcontrol = V0;
        break;
    case 38:
        if (keyboardcontrol != FOWARD)
	        keyboardcontrol = FOWARD;
        break;
    case 40:
        if (keyboardcontrol != BACK)
	        keyboardcontrol = BACK;
        break;
    case 37:
        if (keyboardcontrol != LEFT)
	        keyboardcontrol = LEFT;
        break;
    case 39:
        if (keyboardcontrol != RIGHT)
	        keyboardcontrol = RIGHT;
        break;
    case 13:
        if (keyboardcontrol != HIT)
	        keyboardcontrol = HIT;
        break;
    case 32:
        if (keyboardcontrol != BLOCK)
	        keyboardcontrol = BLOCK;
        break;
    }
	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

void DudeView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
    keyboardcontrol = NOKEYHIT;
    Game->LevelPtr()->usercontrol->stopeverything();
	CView::OnKeyUp(nChar, nRepCnt, nFlags);
}