• <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>

            天行健 君子當自強而不息

            Controlling Players and Characters(36)

            Notice that I keep talking about removing characters from the list. What about all
            the hard work you’ve put into your PCs—how are you ever going to store their
            achievements for later loading? With the following set of saving and loading functions,
            of course!

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

            bool cCharController::save_char(long id, const char* filename)
            {
                sCharacter* character = get_char(id);
                
            if(character == NULL)
                    
            return false;

                FILE* fp = fopen(filename, "wb");
                
            if(fp == NULL)
                    
            return false;

                
            // output character data
                fwrite(&character->char_def,      1, sizeof(character->char_def),      fp);
                fwrite(&character->health_points, 1, 
            sizeof(character->health_points), fp);
                fwrite(&character->mana_points,   1, 
            sizeof(character->mana_points),   fp);
                fwrite(&character->ailments,      1, 
            sizeof(character->ailments),      fp);
                fwrite(&character->pos_x,         1, 
            sizeof(character->pos_x),         fp);
                fwrite(&character->pos_y,         1, 
            sizeof(character->pos_y),         fp);
                fwrite(&character->pos_z,         1, 
            sizeof(character->pos_z),         fp);
                fwrite(&character->direction,     1, 
            sizeof(character->direction),     fp);

                fclose(fp);

                
            // save inventory
                if(character->char_ics)
                {
                    
            char ics_file[MAX_PATH];
                    sprintf(ics_file, "ICS%s", filename);
                    character->char_ics->save(ics_file);
                }

                
            return true;
            }

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

            bool cCharController::load_char(long id, const char* filename)
            {
                sCharacter* character = get_char(id);
                
            if(character == NULL)
                    
            return false;

                FILE* fp = fopen(filename, "rb");
                
            if(fp == NULL)
                    
            return false;

                
            // read in character data
                fread(&character->char_def,      1, sizeof(character->char_def),      fp);
                fread(&character->health_points, 1, 
            sizeof(character->health_points), fp);
                fread(&character->mana_points,   1, 
            sizeof(character->mana_points),   fp);
                fread(&character->ailments,      1, 
            sizeof(character->ailments),      fp);
                fread(&character->pos_x,         1, 
            sizeof(character->pos_x),         fp);
                fread(&character->pos_y,         1, 
            sizeof(character->pos_y),         fp);
                fread(&character->pos_z,         1, 
            sizeof(character->pos_z),         fp);
                fread(&character->direction,     1, 
            sizeof(character->direction),     fp);

                fclose(fp);

                
            // load inventory
                if(character->char_ics)
                {
                    
            char ics_file[MAX_PATH];
                    sprintf(ics_file, "ICS%s", filename);
                    character->char_ics->load(ics_file);
                }

                
            return true;
            }

            Both of the two preceding functions take the character’s identification number to
            save or load, as well as the filename to use.

            That about rounds up the functions used to prepare, add, and remove the characters
            from the game. Now it’s time to get them all moving around performing their actions.
            Previously you saw the functions used to update the individual character types; now
            comes the single function you’ll call to update all characters at once:

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

            void cCharController::update(long elapsed)
            {    
                
            if(m_root_char == NULL)
                    
            return;

                
            static long effect_counter = 0;
                effect_counter += elapsed;

                
            float x_move, y_move, z_move;
                sCharacter* next_char;

                
            // loop through all characters
                for(sCharacter* char_ptr = m_root_char; char_ptr != NULL; char_ptr = next_char)
                {
                    next_char = char_ptr->next;     
            // remember next character

                    // only update if enabled, not asleep or paralyzed.
                    if(! char_ptr->update_enable)
                        
            continue;

                    
            // update action timer if in use
                    if(char_ptr->action_timer != 0)
                    {
                        char_ptr->action_timer -= elapsed;

                        
            if(char_ptr->action_timer < 0)
                            char_ptr->action_timer = 0;
                    }

                    
            if(char_ptr->msg_timer > 0)
                        char_ptr->msg_timer -= elapsed;

                    
            // reset charge counter if attacking, spell, or item.
                    if(char_ptr->action == CHAR_ATTACK || char_ptr->action == CHAR_SPELL || char_ptr->action == CHAR_ITEM)
                        char_ptr->charge = 0.0f;

                    
            // kill character if no health left
                    if(char_ptr->health_points <= 0 && char_ptr->action != CHAR_DIE)
                        set_char_action(char_ptr, CHAR_DIE, 0);

                    
            bool to_process = true;     // mark that processing can continue later on
                    bool dead_char  = false;    // mark character as still alive

                    // do not allow on update if asleep or paralyzed
                    if((char_ptr->ailments & AILMENT_SLEEP) || (char_ptr->ailments & AILMENT_PARALYZE))
                        to_process = 
            false;

                    
            // process actions
                    if(char_ptr->action_timer == 0)
                    {
                        
            switch(char_ptr->action)
                        {
                        
            case CHAR_ATTACK:
                            
            if(to_process)
                                attack(char_ptr, char_ptr->victim);

                            
            break;

                        
            case CHAR_SPELL:
                            
            if(to_process)
                                m_spell_controller->add(char_ptr);

                            
            break;

                        
            case CHAR_ITEM:
                            
            if(to_process)
                                use_item(char_ptr, char_ptr, char_ptr->item_index, char_ptr->char_item);

                            
            break;

                        
            case CHAR_DIE:
                            death(char_ptr->attacker, char_ptr);
                            dead_char  = 
            true;
                            to_process = 
            false;
                            
            break;
                        }
                    }

                    
            // clear movement
                    x_move = y_move = z_move = 0.0f;

                    
            // only continue if allowed (in case character died)
                    if(to_process)
                    {
                        
            // only allow updates if lock/timer not in use
                        if(char_ptr->action_timer == 0 && !char_ptr->is_lock)
                        {                    
                            char_ptr->action = CHAR_IDLE;   
            // reset action

                            
            if(char_ptr->type == CHAR_PC)
                                pc_update(char_ptr, elapsed, &x_move, &y_move, &z_move);
                            
            else
                                npc_monster_update(char_ptr, elapsed, &x_move, &y_move, &z_move);

                            
            // check for validity of movement (clear if invalid)
                            if(!check_move(char_ptr, &x_move, &y_move, &z_move))
                            {
                                x_move = y_move = z_move = 0.0f;
                                char_ptr->action = CHAR_IDLE;
                            }
                        }

                        process_update(char_ptr, x_move, y_move, z_move);

                        char_ptr->charge += (elapsed/1000.0f * get_charge_rate(char_ptr));

                        
            if(char_ptr->charge > 100.0f)
                            char_ptr->charge = 100.0f;
                    }

                    
            // process timed ailments (only in live characters)
                    if(!dead_char && char_ptr->ailments)
                    {
                        
            // sleeping characters have 4% to wake up
                        if((char_ptr->ailments & AILMENT_SLEEP) && rand()%100 < 4)
                            char_ptr->ailments &= ~AILMENT_SLEEP;

                        
            // paralyzed character have 2% chance to recover
                        if((char_ptr->ailments & AILMENT_PARALYZE) && rand()%100 < 2)
                            char_ptr->ailments &= ~AILMENT_PARALYZE;

                        
            // poison removes 2 hp every 4 seconds
                        if((char_ptr->ailments & AILMENT_POISON) && effect_counter >= 4000)
                        {
                            char_ptr->health_points -= 2;
                            set_char_msg(char_ptr, "Poison -2 HP", 500, D3DCOLOR_RGBA(0, 255, 64, 255));
                        }
                    }
                }

                
            // reset effect counter (after 4 seconds)
                if(effect_counter >= 4000)
                    effect_counter = 0;
            }

            The Update function is called once every frame. Taking a single argument (the time
            elapsed since the last update), the Update function calls upon each character’s
            respective update function, validates each character’s movements and actions, and
            wraps up by processing the actions. Then a call to Render is in order to display all
            characters visible within the specified frustum.
            ///////////////////////////////////////////////////////////////////////////////////////////////////

            void cCharController::render(long elapsed, cFrustum* frustum, float z_dist)
            {
                m_frustum = frustum;

                
            // construct the viewing frustum (if none passed)
                if(m_frustum == NULL)
                {
                    cFrustum view_frustum;
                    view_frustum.create(z_dist);
                    m_frustum = &view_frustum;
                }

                DWORD time = 0;

                
            // get time to update animations (30fps) if elapsed value passed == -1
                if(elapsed == -1)
                    time = timeGetTime() / 30;

                
            // variables for printing messages
                bool got_matrices = false;
                D3DXMATRIX mat_world, mat_view, mat_proj;
                D3DVIEWPORT9 viewport;

                
            // loop through each character and draw
                for(sCharacter* char_ptr = m_root_char; char_ptr != NULL; char_ptr = char_ptr->next)
                {
                    
            // update animation based on elapsed time passed
                    if(elapsed != -1)
                    {
                        char_ptr->last_anim_time += elapsed/30;
                        time = char_ptr->last_anim_time;
                    }

                    
            float max_y, radius;
                    cObject& 
            object = char_ptr->object;
                    
            object.get_bounds(NULL, NULL, NULL, NULL, &max_y, NULL, &radius);

                    
            // draw character if in viewing frustum
                    if(! m_frustum->is_sphere_in(object.get_x_pos(), object.get_y_pos(), object.get_z_pos(), radius))
                        
            continue;

                    
            object.update_anim(time, true);
                    
            object.render();
                    
                    
            if(char_ptr->char_def.weapon != -1)
                        char_ptr->weapon_object.render();

                    
            // draw message if needed
                    if(char_ptr->msg_timer > 0)
                    {
                        
            // get the matrices and viewport if not done already
                        if(!got_matrices)
                        {
                            got_matrices = 
            true;

                            
            // get the world, projection, and view transformations.
                            D3DXMatrixIdentity(&mat_world);
                            get_display_view_matrix(&mat_view);
                            get_display_proj_matrix(&mat_proj);
                            get_display_viewport(&viewport);
                        }

                        D3DXVECTOR3 pos;
                        D3DXVECTOR3 src_pos(char_ptr->pos_x, char_ptr->pos_y + (max_y * 0.5f), char_ptr->pos_z);

                        
            // project a 3D vector from object space into screen space
                        D3DXVec3Project(&pos, &src_pos, &viewport, &mat_proj, &mat_view, &mat_world);

                        draw_font(m_font, char_ptr->msg, pos.x, pos.y, 0, 0, char_ptr->msg_color, DT_LEFT);
                    }
                }
            }

            With render, you have a few optional arguments. You use the first one to control
            the animation timing of the characters. In a task-switchable environment such as
            Windows, merely using the time elapsed from the last processed frame is unacceptable;
            you must instead specify a fixed amount of time passed and ensure that your
            game engine sticks to updates at that rate.

            As for the viewing frustum pointer, the application can provide its own pre-created
            object, or pass NULL (and an optional Z-distance) to create its own frustum.

             

            posted on 2007-12-04 18:55 lovedday 閱讀(297) 評論(0)  編輯 收藏 引用

            公告

            導航

            統計

            常用鏈接

            隨筆分類(178)

            3D游戲編程相關鏈接

            搜索

            最新評論

            国产精品99久久久精品无码| 久久精品www人人爽人人| 久久免费大片| 国产精品99久久久精品无码| 国产精品久久午夜夜伦鲁鲁| 久久久久久噜噜精品免费直播| 一本色道久久88综合日韩精品| 久久夜色精品国产欧美乱| 国产亚洲美女精品久久久| 中文国产成人精品久久不卡| 国产精品永久久久久久久久久| 久久国产欧美日韩精品| 亚洲国产精品成人AV无码久久综合影院 | 久久精品亚洲精品国产色婷| 岛国搬运www久久| 久久久无码人妻精品无码| 久久国产AVJUST麻豆| 久久男人中文字幕资源站| 亚洲天堂久久精品| 996久久国产精品线观看| 久久精品国产亚洲AV影院| 久久本道综合久久伊人| 国产精品视频久久久| 久久久久亚洲精品天堂| 久久久无码精品亚洲日韩按摩| 久久这里都是精品| 一本综合久久国产二区| 久久综合久久鬼色| 久久久久国产| 四虎影视久久久免费| 久久精品成人| 久久国产成人精品国产成人亚洲| 狠狠综合久久综合中文88| 久久精品国产99国产电影网| 国产精品久久久久久久久鸭| 国产∨亚洲V天堂无码久久久| 久久亚洲精品中文字幕| 国产亚洲综合久久系列| 26uuu久久五月天| 亚洲欧洲久久av| 久久综合国产乱子伦精品免费|