• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            天行健 君子當(dāng)自強(qiáng)而不息

            Putting Together a Full Game(11)

             

            game_frame:

            #define CLIENT_WIDTH        640
            #define CLIENT_HEIGHT       480

            #define MENU_BACK           1
            #define MENU_LOAD           2
            #define MENU_SAVE           4

            #define NEW_GAME            0
            #define RETURN_TO_GAME      1
            #define LOAD_GAME           2
            #define SAVE_GAME           3
            #define QUIT_GAME           4

            #define MAIN_MENU_TOP       126
            #define MAIN_MENU_HEIGHT    64

            #define BARTER_TOP_HEIGHT   128
            #define BARTER_MENU_HEIGHT  32

            #define STATUS_TOP_HEIGHT   128
            #define STATUS_MENU_HEIGHT  32

            const char* g_char_mesh_files[] = {
                "..\\Data\\Warrior1.x",     
                "..\\Data\\Warrior2.x",     
                "..\\Data\\Yodan1.x",       
                "..\\Data\\Yodan2.x",       
                "..\\Data\\Yodan3.x",       
                "..\\Data\\Yodan4.x"        
            };

            const sCharAnimInfo g_char_anims[] = {
                { "Idle",  
            true  },
                { "Walk",  
            true  },
                { "Swing", 
            false },
                { "Spell", 
            false },
                { "Swing", 
            false },
                { "Hurt",  
            false },
                { "Die",   
            false },
                { "Idle",  
            true  }
            };

            const char* g_spell_mesh_files[] = {
                "..\\Data\\Fireball.x",
                "..\\Data\\Explosion.x",
                "..\\Data\\Ice.x",
                "..\\Data\\Heal.x",
                "..\\Data\\Teleport.x",
                "..\\Data\\Groundball.x",
                "..\\Data\\Bomb.x",
                "..\\Data\\Force.x"     
            };

            const char* g_sound_files[] = {
                "..\\Data\\Attack1.wav",
                "..\\Data\\Attack2.wav",
                "..\\Data\\Fire.wav",
                "..\\Data\\Ice.wav",
                "..\\Data\\Heal.wav",
                "..\\Data\\Teleport.wav",
                "..\\Data\\Groundball.wav",
                "..\\Data\\Concussion.wav",
                "..\\Data\\Evil Force.wav",
                "..\\Data\\Roar.wav",
                "..\\Data\\Hurt1.wav",
                "..\\Data\\Hurt2.wav",
                "..\\Data\\Die1.wav",
                "..\\Data\\Die2.wav",
                "..\\Data\\Beep.wav"   
            };

            const char* g_music_files[] = {
                "..\\Data\\Cathedral_Sunrise.mid",
                "..\\Data\\Distant_tribe.mid",
                "..\\Data\\Escape.mid",
                "..\\Data\\Jungle1.mid",
                "..\\Data\\Magic_Harp.mid",
                "..\\Data\\Medi_Strings.mid",
                "..\\Data\\Medi_techno.mid",
                "..\\Data\\Song_of_the_sea.mid",
                "..\\Data\\Storm.mid"            
            };

            #define MAX_PLAYER_LEVEL        10
            #define LEARN_SPELL_TOP_LEVEL   7

            // max level 10, begin from level 2.
            const long g_level_up_exp[] = { 100, 200, 350, 600, 900, 1300, 1800, 2400, 3100};

            typedef 
            struct 
            {
                
            float x, y, z;
                
            float u, v;
            } sMenuVertex;

            #define MENU_FVF  (D3DFVF_XYZ | D3DFVF_TEX1)

            long        g_cur_music = -1;
            long        g_menu_options;
            sCharacter* g_player;
            char        g_barter_ics_file[MAX_PATH];

            const char* g_title_name = "The road of warrior";
             
            void game_frame(void* data, long purpose)
            {
                
            if(purpose != FRAME_PURPOSE)    // only process frame stats
                    return;

                cApp* app = (cApp*) data;

                
            // quit to menu screen if ESC pressed
                if(app->m_keyboard.get_key_state(KEY_ESC))
                {
                    g_menu_options = MENU_BACK | MENU_LOAD | MENU_SAVE;
                    app->m_state_manager.push(menu_frame, app);
                    
            return;
                }

                
            // If teleporting, then handle that first and return.
                if(app->m_teleport_map != -1)
                {
                    app->load_level(app->m_teleport_map);
                    app->m_teleport_map = -1;
                    
            return;     // no more processing this frame
                }

                
            bool is_monster_in_level = false;   // mark no monsters in level

                // See if any character are in level. 
                //
                // If any monsters, flag as such and change their AI to wander if their charge is less then 70, 
                // follow AI otherwise.
                //
                // Also, process whenever a character reaches a route point.
                for(sCharacter* character = app->m_game_chars.get_root_char(); character != NULL; character = character->next)
                {
                    
            if(character->type == CHAR_MONSTER)
                    {            
                        is_monster_in_level = 
            true;

                        
            // change AI based on charge
                        if(character->charge >= 70.0f)
                        {
                            character->ai          = CHAR_FOLLOW;
                            character->target_char = g_player;
                            character->distance    = 0.0f;
                        }
                        
            else
                            character->ai = CHAR_WANDER;
                    }
                    
            else if(character->type == CHAR_NPC && character->ai == CHAR_ROUTE)
                    {
                        
            // check if an NPC character has reached last route point
                        if(app->last_point_reached(character))
                        {
                            
            // process the route point script for character.

                            
            char filename[MAX_PATH];
                            sprintf(filename, "..\\Data\\EOR%lu.mls", character->id);

                            app->m_game_script.execute(filename);
                            
            return;     // do not process any more this frame
                        }
                    }
                }

                
            // handle start of combat stuff
                if(is_monster_in_level && !app->m_is_monster_last_frame)
                    app->start_of_combat();

                
            // handle end of combat stuff if combat over
                if(!is_monster_in_level && app->m_is_monster_last_frame)
                    app->end_of_combat();

                
            // remember if monsters where in this frame and reset player's charge to full if no monsters

                app->m_is_monster_last_frame = is_monster_in_level;

                
            if(! is_monster_in_level)
                    g_player->charge = 100.0f;

                app->m_game_chars.update(33);
                app->m_game_spells.update(33);

                
            long trigger_index = app->m_trigger.get_trigger(g_player->pos_x, g_player->pos_y, g_player->pos_z);

                
            // check for triggers and execute script
                if(trigger_index != 0)
                {
                    
            char filename[MAX_PATH];
                    sprintf(filename, "..\\Data\\Trig%lu.mls", trigger_index);

                    app->m_game_script.execute(filename);
                    
            return;     // do not process any more this frame
                }

                set_display_camera(&app->m_camera);

                
            // render everything

                clear_display_zbuffer(1.0f);
                begin_display_scene();
                app->render_frame(33);

                
            // render the player's charge bar, but only during combat.
                if(is_monster_in_level)
                {
                    D3DXMATRIX mat_world, mat_view, mat_proj;
                    D3DVIEWPORT9 viewport;
                    
                    
            // get the world, projection, view transformations, viewport.
                    D3DXMatrixIdentity(&mat_world);
                    get_display_view_matrix(&mat_view);
                    get_display_proj_matrix(&mat_proj);
                    get_display_viewport(&viewport);

                    
            // offset charge bar by character's height

                    
            float max_y;
                    g_player->
            object.get_bounds(NULL, NULL, NULL, NULL, &max_y, NULL, NULL);

                    
            // project coordinates to screen

                    D3DXVECTOR3 pos_screen;
                    D3DXVECTOR3 pos_3d(g_player->pos_x, g_player->pos_y + max_y, g_player->pos_z);

                    D3DXVec3Project(&pos_screen, &pos_3d, &viewport, &mat_proj, &mat_view, &mat_world);

                    pos_screen.x += 8.0f;

                    
            // display charge bar below player

                    disable_zbuffer();
                    begin_display_sprite();        

                    RECT rect;

                    calculate_texture_rect(app->m_charge_bar, 0, 0, 16, 4, &rect);
                    draw_texture(g_d3d_sprite, app->m_charge_bar, &rect, pos_screen.x, pos_screen.y, 1.0f, 1.0f, COLOR_WHITE);
                    
                    
            long width = g_player->charge / 100.0f * 16.0f;
                    calculate_texture_rect(app->m_charge_bar, 0, 4, width, 4, &rect);
                    draw_texture(g_d3d_sprite, app->m_charge_bar, &rect, pos_screen.x, pos_screen.y, 1.0f, 1.0f, COLOR_WHITE);

                    end_display_sprite();
                }

                
            // draw the player's stats at top-left

                
            char stats_text[256];

                sprintf(stats_text, "%ld/%ld HP\r\n%ld/%ld MP",
                        g_player->health_points, g_player->char_def.health_points,
                        g_player->mana_points, g_player->char_def.mana_points);

                app->m_text_stats.render(stats_text, COLOR_WHITE);

                end_display_scene();
                present_display();
            }

            Because this is a frame state, you can call the game_frame function for one of three
            purposes—the state being initialized, the frame being processed, and the state
            being shut down. The game_frame function uses only the update-frame purpose, so
            processing is returned if any other calling purpose is used.

            At the beginning of the game_frame function is a quick check to see whether the Esc
            key has been pressed. If so, the main menu state is pushed onto the stack.

            In order for the main menu to know which options to display, you declare a global
            variable at the beginning of the application. This global variable, g_menu_options, is
            bit-encoded and uses the following macros to define them—MENU_BACK to display the
            back to game option, MENU_SAVE to display the save game option, and MENU_LOAD to display
            the load game option. Once you define the options, the state is pushed.

            Whenever the player needs to move from one map to another (such as calling the
            teleport_player function with the map number and coordinates to which to move the
            player), you set a global variable called m_teleport_map to the correct map number for
            teleporting. The preceding bit of code checks each frame to see whether that vari-
            able has been set and teleports the player to the appropriate map.

            Now comes the real bulk of the game_frame function. At the start of the following
            block of code, you set a flag that records whether any monsters are in the map is
            cleared. From there, scan the entire list of loaded characters. If you find a monster
            character in the list, set the is_monster_in_level flag. Also, for each monster in the map,
            change its AI settings based on its action charge. For charges less than 70, set the
            monster’s AI to wander (to let the monster wander around the map). If the charge
            is over 70, set the monster’s AI type to follow the player (so that the monster is
            attempting to attack the player).

            If, on the other hand, an NPC is found on the map and that character has its AI set
            to follow a route, a separate function is called to determine whether that character
            has reached the last route point assigned. If the last point on the route has been
            touched, that character’s end-of-route script is executed.

            Once you are past the scan-for-characters phase of game_frame, you compare the
            is_monster_in_level flag to the same flag that was stored from the last frame. If they do
            not match, either combat has started or ended, and the appropriate script is called.

            Next comes the point at which all characters and spells are updated. Because the
            cApp::frame function is locked to update the game 30 times a second, all controllers
            use an update time of 33 milliseconds. Notice that before being updated, the
            player's charge meter is set to full if no monsters are in the level.

            After the characters are updated, the trigger object comes into play. If the player
            walks into an active trigger, the appropriate script is executed.

            From this point on, you render the scene by calling the render_frame function from
            the application class. The render_frame function renders only the backdrop and
            character in the map—it’s up to the rest of this function’s code to draw the status
            window and charge meter.

            void cApp::render_frame(long elapsed)
            {
                
            // render simplified scene mesh for z-values
                enable_zbuffer();
                m_scene_object.render();

                
            // draw the backdrop (composed of six textures)

                disable_zbuffer();

                begin_display_sprite();

                
            for(int i = 0; i < 2; i++)
                {
                    
            for(int j = 0; j < 3; j++)
                    {
                        IDirect3DTexture9* texture = m_scene_backdrops[i * 3 + j];

                        RECT rect;
                        calculate_texture_rect(texture, 0, 0, 0, 0, &rect);

                        draw_texture(g_d3d_sprite, texture, &rect, j * 256, i * 256, 1.0f, 1.0f, COLOR_WHITE);
                    }   
                }

                end_display_sprite();

                
            // draw characters and spells

                enable_zbuffer();

                m_game_chars.render(elapsed, NULL, 0.0f);
                m_game_spells.render(NULL, 0.0f);
            }

            Again, you first render the scene by using the render_frame function, which takes as
            an argument the amount of time (in milliseconds) that the animations should be
            updated. You then draw the player's charge meter, but only if monsters are present
            on the map.

            There are numerous matrix- and vector-related functions at work here—you use
            them to calculate the screen coordinates in which to draw the charge meter. To
            determine where to draw the meter, using the preceding D3DXVec3Project function,
            calculate the 2D coordinates based on the 3D world space coordinates of the player.

            During the game-play, you display the player's statistics at the upper-left corner of
            the screen—this includes the health and mana points, at their current levels and at
            their maximum level.

            The game_frame function ends up by calling end_display_scene and displaying the frame to the
            user.

            posted on 2007-12-29 22:24 lovedday 閱讀(447) 評論(0)  編輯 收藏 引用


            只有注冊用戶登錄后才能發(fā)表評論。
            網(wǎng)站導(dǎo)航: 博客園   IT新聞   BlogJava   博問   Chat2DB   管理


            公告

            導(dǎo)航

            統(tǒng)計(jì)

            常用鏈接

            隨筆分類(178)

            3D游戲編程相關(guān)鏈接

            搜索

            最新評論

            国产毛片欧美毛片久久久| 久久久久久亚洲AV无码专区| 91精品国产综合久久久久久| a级成人毛片久久| 久久最新免费视频| 免费久久人人爽人人爽av| 久久久精品2019免费观看| 91精品日韩人妻无码久久不卡| 久久精品国产99久久丝袜| 国产成人精品久久| 97精品伊人久久久大香线蕉 | 区久久AAA片69亚洲| 久久精品国产99国产精偷| 亚洲国产成人久久笫一页| 九九久久自然熟的香蕉图片| 久久天天躁狠狠躁夜夜2020老熟妇| 久久久久久伊人高潮影院| 久久久久夜夜夜精品国产| 久久强奷乱码老熟女| 亚洲AV无码久久精品成人| www.久久热| 久久久久久国产精品美女| 国产色综合久久无码有码| 久久国产精品成人免费| 婷婷久久综合| 久久亚洲综合色一区二区三区| 精品久久久久久国产牛牛app| 亚洲中文字幕伊人久久无码| 亚洲午夜久久久久妓女影院| 成人国内精品久久久久影院VR| 久久笫一福利免费导航 | 久久久久国产亚洲AV麻豆| 亚洲午夜久久久影院伊人| 丰满少妇人妻久久久久久| 久久久久综合网久久| 九九热久久免费视频| 久久久久久精品久久久久| 99久久亚洲综合精品成人| 精品久久久久久亚洲精品 | 婷婷久久香蕉五月综合加勒比| 久久精品人人做人人爽电影|