raiders3d.cpp

游戏经典书 3D游戏编程大师技巧 源代码,本书是游戏编程畅销书作者Andre LaMothe的扛鼎之作

// enable CTRL-ALT_DEL, ALT_TAB, comment this line out 
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, FALSE, NULL, 0);

// return to Windows like this
return(msg.wParam);

} // end WinMain

// T3D II GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////

int Game_Init(void *parms)
{
    // this function is where you do all the initialization 
    // for your game

    int index; // used for looping

    Open_Error_File("error.txt");

    // start up DirectDraw (replace the parms as you desire)
    DDraw_Init(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BPP, WINDOWED_APP);

    // initialize directinput
    DInput_Init();

    // acquire the keyboard 
    DInput_Init_Keyboard();

    // initialize directsound
    DSound_Init();

    // load in sound fx
    explosion_id = DSound_Load_WAV("exp1.wav");
    laser_id     = DSound_Load_WAV("shocker.wav");

    // initialize directmusic
    DMusic_Init();

    // load and start main music track
    main_track_id = DMusic_Load_MIDI("midifile2.mid");
    DMusic_Play(main_track_id);

    // add calls to acquire other directinput devices here...

    // hide the mouse
    if (!WINDOWED_APP)
    ShowCursor(FALSE);

    // seed random number generator
    srand(Start_Clock());

    // all your initialization code goes here...

    // create system colors
    rgb_green = RGB16Bit(0,255,0);
    rgb_white = RGB16Bit(255,255,255);
    rgb_blue  = RGB16Bit(0,0,255);
    rgb_red   = RGB16Bit(255,0,0);

// create the starfield
for (index=0; index < NUM_STARS; index++)
    {
        // randomly position stars in an elongated cylinder stretching from
        // the viewpoint 0,0,-d to the yon clipping plane 0,0,far_z
        stars[index].x = -WINDOW_WIDTH/2  + rand()%WINDOW_WIDTH;
        stars[index].y = -WINDOW_HEIGHT/2 + rand()%WINDOW_HEIGHT;
        stars[index].z = NEAR_Z + rand()%(FAR_Z - NEAR_Z);

        // set color of stars
        stars[index].color = rgb_white;
    } // end for index

// create the tie fighter model

// the vertex list for the tie fighter
POINT3D temp_tie_vlist[NUM_TIE_VERTS] = 
// color, x,y,z
{ 
    {rgb_white,-40,40,0},    // p0
    {rgb_white,-40,0,0},    // p1
    {rgb_white,-40,-40,0},   // p2
    {rgb_white,-10,0,0},    // p3
    {rgb_white,0,20,0},     // p4
    {rgb_white,10,0,0},     // p5
    {rgb_white,0,-20,0},    // p6
    {rgb_white,40,40,0},     // p7
    {rgb_white,40,0,0},     // p8
    {rgb_white,40,-40,0}};   // p9

    // copy the model into the real global arrays
    for (index=0; index<NUM_TIE_VERTS; index++)
        tie_vlist[index] = temp_tie_vlist[index];
  
    // the edge list for the tie fighter
    LINE3D temp_tie_shape[NUM_TIE_EDGES] = 
    // color, vertex 1, vertex 2
    { 
        {rgb_green,0,2      },    // l0
        {rgb_green,1,3      },    // l1
        {rgb_green,3,4      },    // l2
        {rgb_green,4,5      },    // l3
        {rgb_green,5,6      },    // l4
        {rgb_green,6,3      },    // l5
        {rgb_green,5,8      },    // l6
        {rgb_green,7,9      } 
    };  // l7

    // copy the model into the real global arrays
    for (index=0; index<NUM_TIE_EDGES; index++)
        tie_shape[index] = temp_tie_shape[index];

    // initialize the position of each tie fighter and it's velocity
    for (index=0; index<NUM_TIES; index++)
        {
            // initialize this tie fighter
            Init_Tie(index);

        } // end for index

    // return success
    return(1);

} // end Game_Init

///////////////////////////////////////////////////////////

int Game_Shutdown(void *parms)
{
    // this function is where you shutdown your game and
    // release all resources that you allocated

    // shut everything down

    // release all your resources created for the game here....

    // now directsound
    DSound_Stop_All_Sounds();
    DSound_Shutdown();

    // directmusic
    DMusic_Delete_All_MIDI();
    DMusic_Shutdown();

    // shut down directinput
    DInput_Shutdown();

    // shutdown directdraw last
    DDraw_Shutdown();

    // return success
    return(1);
} // end Game_Shutdown

//////////////////////////////////////////////////////////

void Start_Explosion(int tie)
{
// this starts an explosion based on the sent tie fighter

// first hunt and see if an explosion is free
for (int index=0; index < NUM_EXPLOSIONS; index++)
    {
    if (explosions[index].state==0)
       {
       // start this explosion up using the properties
       // if the tie figther index sent

       explosions[index].state   = 1; // enable state of explosion
       explosions[index].counter = 0; // reset counter for explosion 

       // set color of explosion
       explosions[index].color = rgb_green;

       // make copy of of edge list, so we can blow it up
       for (int edge=0; edge < NUM_TIE_EDGES; edge++)
           {
           // start point of edge
           explosions[index].p1[edge].x = ties[tie].x+tie_vlist[tie_shape[edge].v1].x;
           explosions[index].p1[edge].y = ties[tie].y+tie_vlist[tie_shape[edge].v1].y;
           explosions[index].p1[edge].z = ties[tie].z+tie_vlist[tie_shape[edge].v1].z;
 
           // end point of edge
           explosions[index].p2[edge].x = ties[tie].x+tie_vlist[tie_shape[edge].v2].x;
           explosions[index].p2[edge].y = ties[tie].y+tie_vlist[tie_shape[edge].v2].y;
           explosions[index].p2[edge].z = ties[tie].z+tie_vlist[tie_shape[edge].v2].z;

           // compute trajectory vector for edges
           explosions[index].vel[edge].x = ties[tie].xv - 8+rand()%16;
           explosions[index].vel[edge].y = ties[tie].yv - 8+rand()%16;
           explosions[index].vel[edge].z = -3+rand()%4;

           } // end for edge
     
       // done, so return
       return;
       } // end if found

    } // end for index

} // end Start_Explosion

///////////////////////////////////////////////////////////

void Process_Explosions(void)
{
// this processes all the explosions

// loop thro all the explosions and render them
for (int index=0; index<NUM_EXPLOSIONS; index++)
    {
    // test if this explosion is active?
    if (explosions[index].state==0)
       continue;

    for (int edge=0; edge<NUM_TIE_EDGES; edge++)
        {
        // must be exploding, update edges (shrapel)
        explosions[index].p1[edge].x+=explosions[index].vel[edge].x;
        explosions[index].p1[edge].y+=explosions[index].vel[edge].y;
        explosions[index].p1[edge].z+=explosions[index].vel[edge].z;

        explosions[index].p2[edge].x+=explosions[index].vel[edge].x;
        explosions[index].p2[edge].y+=explosions[index].vel[edge].y;
        explosions[index].p2[edge].z+=explosions[index].vel[edge].z;
        } // end for edge

    // test for terminatation of explosion?
    if (++explosions[index].counter > 100)
       explosions[index].state = explosions[index].counter = 0;            

    } // end for index

} // end Process_Explosions

///////////////////////////////////////////////////////////

void Draw_Explosions(void)
{
// this draws all the explosions

// loop thro all the explosions and render them
for (int index=0; index<NUM_EXPLOSIONS; index++)
    {
    // test if this explosion is active?
    if (explosions[index].state==0)
       continue;

    // render this explosion
    // each explosion is made of a number of edges
    for (int edge=0; edge < NUM_TIE_EDGES; edge++)
    {
        POINT3D p1_per, p2_per; // used to hold perspective endpoints
        
        // test if edge if beyond near clipping plane
        if (explosions[index].p1[edge].z < NEAR_Z && 
            explosions[index].p2[edge].z < NEAR_Z)
        continue;
       
        // step 1: perspective transform each end point
        p1_per.x = VIEW_DISTANCE*explosions[index].p1[edge].x/explosions[index].p1[edge].z;
        p1_per.y = VIEW_DISTANCE*explosions[index].p1[edge].y/explosions[index].p1[edge].z;
        p2_per.x = VIEW_DISTANCE*explosions[index].p2[edge].x/explosions[index].p2[edge].z;
        p2_per.y = VIEW_DISTANCE*explosions[index].p2[edge].y/explosions[index].p2[edge].z;

        // step 2: compute screen coords
        int p1_screen_x = WINDOW_WIDTH/2  + p1_per.x;
        int p1_screen_y = WINDOW_HEIGHT/2 - p1_per.y;
        int p2_screen_x = WINDOW_WIDTH/2  + p2_per.x;
        int p2_screen_y = WINDOW_HEIGHT/2 - p2_per.y;

        // step 3: draw the edge
        Draw_Clip_Line16(p1_screen_x, p1_screen_y, p2_screen_x, p2_screen_y,
                        explosions[index].color,back_buffer, back_lpitch);    

    } // end for edge

    } // end for index

} // end Draw_Explosions

//////////////////////////////////////////////////////////

void Move_Starfield(void)
{
    // move the stars

    int index; // looping var

    // the stars are technically stationary,but we are going
    // to move them to simulate motion of the viewpoint
    for (index=0; index<NUM_STARS; index++)
    {
        // move the next star
        stars[index].z-=player_z_vel;

        // test for past near clipping plane
        if (stars[index].z <= NEAR_Z)
            stars[index].z = FAR_Z;

    } // end for index

} // end Move_Starfield

/////////////////////////////////////////////////////////

void Draw_Starfield(void)
{
// draw the stars in 3D using perspective transform

int index; // looping var

for (index=0; index<NUM_STARS; index++)
    {
    // draw the next star
    // step 1: perspective transform
    float x_per = VIEW_DISTANCE*stars[index].x/stars[index].z;
    float y_per = VIEW_DISTANCE*stars[index].y/stars[index].z;
    
    // step 2: compute screen coords
    int x_screen = WINDOW_WIDTH/2  + x_per;
    int y_screen = WINDOW_HEIGHT/2 - y_per;

    // clip to screen coords
    if (x_screen>=WINDOW_WIDTH || x_screen < 0 || 
        y_screen >= WINDOW_HEIGHT || y_screen < 0)
       {
       // continue to next star
       continue; 
       } // end if
    else
       {
       // else render to buffer
       ((USHORT *)back_buffer)[x_screen + y_screen*(back_lpitch >> 1)] 
                              = stars[index].color;
       } // end else

    } // end for index

}  // Draw_Starfield

/////////////////////////////////////////////////////////

void Init_Tie(int index)
{
    // this function starts a tie fighter up at the far end
    // of the universe and sends it our way!

    // position each tie in the viewing volume
    ties[index].x = -WINDOW_WIDTH  + rand()%(2*WINDOW_WIDTH);
    ties[index].y = -WINDOW_HEIGHT + rand()%(2*WINDOW_HEIGHT);
    ties[index].z =  4*FAR_Z;

    // initialize velocity of tie fighter
    ties[index].xv = -4+rand()%8;