• <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(33)

            The next two functions to come along work in conjunction with the update functionality
            of the class. At every frame that a character needs updating, a specific
            function is called to update the character’s actions. This specific function is dependent
            on the type of character being updated; for PCs, that specific function is
            pc_update (which is overridden by you in order to control your player).

            virtual void pc_update(sCharacter* character, long elaspsed,
                                   float* x_move, float* y_move, float* z_move)
            {
            }

            For NPCs and monsters, the update function called is npc_monster_update. pc_update does
            nothing at this point because you need to write the code in the main application
            to control the player. Monsters and NPCs already have their AIs sets, and the controller
            knows how to handle them with npc_monster_update.

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

            static bool char_can_spell_health(const sCharacter* character, const sSpell* spell, int spell_index)
            {
                
            return spell->name[0] && spell->effect == ALTER_HEALTH && spell->value[0] > 0.0f &&
                       character->mana_points >= spell->cost &&
                       (character->char_def.magic_spell[spell_index / 32] & (1 << (spell_index & 31)));
            }

            static bool char_can_spell_dispel(const sCharacter* character, const sSpell* spell, int spell_index)
            {
                
            return spell->name[0] && spell->effect == DISPEL_MAGIC && character->mana_points >= spell->cost &&
                       (character->char_def.magic_spell[spell_index / 32] & (1 << (spell_index & 31)));
            }

            static bool char_can_spell_ailment(const sCharacter* character, const sSpell* spell, int spell_index)
            {
                
            return spell->name[0] && spell->effect == CAUSE_AILMENT && character->mana_points >= spell->cost &&
                       (character->char_def.magic_spell[spell_index / 32] & (1 << (spell_index & 31)));
            }

            static bool char_can_spell(const sCharacter* character, const sSpell* spell, int spell_index)
            {
                
            return spell->name[0] && character->mana_points >= spell->cost &&
                       (character->char_def.magic_spell[spell_index / 32] & (1 << (spell_index & 31)));
            }

            static bool is_char_ailment(const sCharacter* character)
            {
                
            return character->ailments & AILMENT_POISON ||
                       character->ailments & AILMENT_SLEEP ||             
                       character->ailments & AILMENT_PARALYZE ||          
                       character->ailments & AILMENT_ENCHANTED ||         
                       character->ailments & AILMENT_DUMBFOUNDED ||       
                       character->ailments & AILMENT_SLOW ||              
                       character->ailments & AILMENT_BLIND ||             
                       character->ailments & AILMENT_SILENCED;
            }

            static bool is_enhanced_ailment(long ailment)
            {
                
            return ailment & AILMENT_STRONG ||      
                       ailment & AILMENT_BARRIER ||     
                       ailment & AILMENT_SUREFOOTED ||  
                       ailment & AILMENT_FAST ||        
                       ailment & AILMENT_HAWKEYE;
            }

            ///////////////////////////////////////////////////////////////////////////////////////////////////
             
            void cCharController::npc_monster_update(sCharacter* character, long elapsed,
                                                     
            float* x_move, float* y_move, float* z_move)
            {
                
            if(character == NULL)
                    
            return;

                
            float move_x, move_y, move_z;
                move_x = move_y = move_z = 0.0f;

                
            float x_diff, y_diff, z_diff, dist, radius;

                
            float speed = elapsed/1000.0f * get_speed(character);

                
            // move character based on their type
                switch(character->ai)
                {
                
            case CHAR_STAND:
                    
            break;

                
            case CHAR_WANDER:
                    
            // calculate new distance and direction if needed

                    character->distance -= elapsed;

                    
            if(character->distance <= 0.0f)
                    {
                        character->distance  = rand()%2000 + 2000.0f;
                        character->direction = (rand()%360) * 0.01744444f;
                    }

                    
            // process walk or stand still
                    if(character->distance > 1000.0f)
                    {
                        move_x = sin(character->direction) * speed;
                        move_z = cos(character->direction) * speed;

                        character->action = CHAR_MOVE;
                    }
                    
            else
                    {
                        
            // stand still for one second
                        character->action = CHAR_IDLE;
                    }

                    
            break;

                
            case CHAR_ROUTE:
                  {
                    sRoutePoint* route = &character->route[character->cur_point];

                    
            // determine if character has reached point

                    x_diff = fabs(character->pos_x - route->pos_x);
                    y_diff = fabs(character->pos_y - route->pos_y);
                    z_diff = fabs(character->pos_z - route->pos_z);

                    dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
                    radius = get_xz_radius(character) * 0.25f;

                    
            // goto next point if reached
                    if(dist < (radius * radius))
                    {
                        
            if(++character->cur_point >= character->num_points)
                            character->cur_point = 0;

                        route = &character->route[character->cur_point];

                        
            // calculate new differences and distance 

                        x_diff = fabs(character->pos_x - route->pos_x);
                        y_diff = fabs(character->pos_y - route->pos_y);
                        z_diff = fabs(character->pos_z - route->pos_z);

                        dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
                    }

                    
            // setup movement towards target
                    dist = sqrt(dist);

                    
            if(speed > dist)
                        speed = dist;

                    move_x = (route->pos_x - character->pos_x) / dist * speed;
                    move_z = (route->pos_z - character->pos_z) / dist * speed;

                    character->direction = atan2(move_x, move_z);
                    character->action    = CHAR_MOVE;

                    
            break;
                  }

                
            case CHAR_FOLLOW:    
                    
            // check distance between characters

                    x_diff = fabs(character->pos_x - character->target_char->pos_x);
                    y_diff = fabs(character->pos_y - character->target_char->pos_y);
                    z_diff = fabs(character->pos_z - character->target_char->pos_z);

                    dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;

                    
            // update if further than target
                    if(dist > (character->distance * character->distance))
                    {
                        
            // setup movement towards target
                        dist = sqrt(dist);

                        
            if(speed > dist)
                            speed = dist;

                        move_x = (character->target_char->pos_x - character->pos_x) / dist * speed;
                        move_z = (character->target_char->pos_z - character->pos_z) / dist * speed;
                        
                        character->direction = atan2(move_x, move_z);
                        character->action    = CHAR_MOVE;
                    }

                    
            break;

                
            case CHAR_EVADE:
                    
            // check distance between characters

                    x_diff = fabs(character->pos_x - character->target_char->pos_x);
                    y_diff = fabs(character->pos_y - character->target_char->pos_y);
                    z_diff = fabs(character->pos_z - character->target_char->pos_z);

                    dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;

                    
            // update if closer than distance
                    if(dist < (character->distance * character->distance))
                    {
                        
            // setup movement away from target
                        dist = sqrt(dist);

                        
            if(speed > dist)
                            speed = dist;

                        move_x = -(character->target_char->pos_x - character->pos_x) / dist * speed;
                        move_z = -(character->target_char->pos_z - character->pos_z) / dist * speed;

                        character->direction = atan2(move_x, move_z);
                        character->action = CHAR_MOVE;
                    }

                    
            break;
                }

                sCharacter* char_ptr;

                
            // process monster actions if at full charge
                if(character->type == CHAR_MONSTER && character->charge >= 100.0f)
                {
                    
            // determine chance of attacking
                    if(rand()%100 <= character->char_def.to_attack)
                    {
                        
            // scan through list and pick a character
                        for(char_ptr = m_root_char; char_ptr != NULL; char_ptr = char_ptr->next)
                        {
                            
            // randomly pick update enabled PC, and make sure the target is not hurt or dead.
                            if(char_ptr != character && char_ptr->type == CHAR_PC && char_ptr->update_enable &&
                               char_ptr->action != CHAR_DIE && char_ptr->action != CHAR_HURT && rand()%100 < 50)
                            {
                                
            // get distance to target
                                x_diff = fabs(character->pos_x - char_ptr->pos_x);
                                y_diff = fabs(character->pos_y - char_ptr->pos_y);
                                z_diff = fabs(character->pos_z - char_ptr->pos_z);

                                dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;

                                
            // make sure in range to attack                    
                                radius = get_xz_radius(character) + character->char_def.attack_range;

                                
            // attack only in range
                                if((radius * radius) >= dist)
                                {                        
                                    character->victim  = char_ptr;
                                    char_ptr->attacker = character;

                                    
            // clear movement
                                    move_x = move_y = move_z = 0.0f;

                                    
            // point towards target character
                                    x_diff = char_ptr->pos_x - character->pos_x;
                                    z_diff = char_ptr->pos_z - character->pos_z;
                                    character->direction = atan2(x_diff, z_diff);

                                    set_char_action(character, CHAR_ATTACK, 0);
                                    
            break;
                                }
                            }
                        }
                    }   
                    
            else if(rand()%100 <= character->char_def.to_magic)
                    {
                        
            // determine chance of spell casting

                        
            bool is_spell_cast = false;
                        
            long spell_index;

                        
            // if health is less than half, then there is 50% chance of healing (if monster knows any heal spells).
                        if(character->health_points <= character->char_def.health_points / 2)
                        {
                            
            // search for a known heal spell
                            for(long i = 0; i < NUM_SPELL_DEF; i++)
                            {
                                
            // this is the spell, determine chance to heal.
                                if(char_can_spell_health(character, &m_msl[i], i) && rand()%100 < 50)
                                {                        
                                    character->victim      = character;
                                    character->attacker    = character;
                                    character->spell_index = i;
                                    character->target_type = CHAR_MONSTER;                     
                                    character->target_x    = character->pos_x;
                                    character->target_y    = character->pos_y;
                                    character->target_z    = character->pos_z;

                                    
            // clear movement
                                    move_x = move_y = move_z = 0.0f;
                                   
                                    set_char_action(character, CHAR_SPELL, 0);
                                    is_spell_cast = 
            true;
                                    
            break;
                                }
                            }
                        }

                        
            // if there are bad status ailments, then there is 50% chance of dispeling magic.
                        if(is_char_ailment(character) && !is_spell_cast)
                        {
                            
            // search for a known dispell spell
                            for(long i = 0; i < NUM_SPELL_DEF; i++)
                            {
                                
            // this is the spell, determine chance to dispel.
                                if(char_can_spell_dispel(character, &m_msl[i], i) && rand()%100 < 50)
                                {                        
                                    character->victim      = character;
                                    character->attacker    = character;
                                    character->spell_index = i;
                                    character->target_type = CHAR_MONSTER;                     
                                    character->target_x    = character->pos_x;
                                    character->target_y    = character->pos_y;
                                    character->target_z    = character->pos_z;

                                    
            // clear movement
                                    move_x = move_y = move_z = 0.0f;
                                   
                                    set_char_action(character, CHAR_SPELL, 0);
                                    is_spell_cast = 
            true;
                                    
            break;
                                }
                            }
                        }

                        
            // if no spells already cast, then pick a random spell to attack with.
                        if(!is_spell_cast)
                        {
                            spell_index = rand() % NUM_SPELL_DEF;

                            
            // scan through list until a spell is found that monster can cast.
                            for(long i = 0; i < NUM_SPELL_DEF; i++)
                            {
                                
            if(char_can_spell(character, &m_msl[spell_index], spell_index) && rand()%100 < 50)
                                {
                                    
            // scan through list and pick a character
                                    for(char_ptr = m_root_char; char_ptr != NULL; char_ptr = char_ptr->next)
                                    {
                                        
            // randomly pick an update enabled PC, and make sure the target is not hurt or dead.
                                        // also, do not cast self-targeting spells here.
                                        if(char_ptr != character && m_msl[spell_index].target != TARGET_SELF &&
                                            char_ptr->type == CHAR_PC && char_ptr->update_enable &&
                                            char_ptr->action != CHAR_DIE && char_ptr->action != CHAR_HURT &&
                                            rand()%100 < 50)
                                        {
                                            
            float y1, y2;

                                            
            // get heights of attacker and target for line of sight checking
                                            character->object.get_bounds(NULL, NULL, NULL, NULL, &y1, NULL, NULL);
                                            y1 = (y1 * 0.5f) + character->pos_y;

                                            char_ptr->
            object.get_bounds(NULL, NULL, NULL, NULL, &y2, NULL, NULL);
                                            y2 = (y2 * 0.5f) + char_ptr->pos_y;

                                            
            // get distance to target

                                            x_diff = fabs(character->pos_x - char_ptr->pos_x);
                                            y_diff = fabs(character->pos_y - char_ptr->pos_y);
                                            z_diff = fabs(character->pos_z - char_ptr->pos_z);
                            
                                            dist = x_diff * x_diff + y_diff * y_diff + z_diff * z_diff;
                                            dist = sqrt(dist) - get_xz_radius(char_ptr);
                                           
                                            
            bool in_line_sight = line_of_sight(character, char_ptr,
                                                                               character->pos_x, y1, character->pos_z,
                                                                               char_ptr->pos_x, y2, char_ptr->pos_z);

                                            
            // make sure target is in range and in line sight
                                            if(in_line_sight && dist <= m_msl[spell_index].max_dist)
                                            {
                                                character->victim      = char_ptr;
                                                char_ptr->attacker     = character;
                                                character->spell_index = spell_index;
                                                character->target_type = CHAR_PC;
                                                character->target_x    = char_ptr->pos_x;
                                                character->target_y    = char_ptr->pos_y;
                                                character->target_z    = char_ptr->pos_z;

                                                
            // face toward target (only if not self)
                                                x_diff = char_ptr->pos_x - character->pos_x;
                                                z_diff = char_ptr->pos_z - character->pos_z;

                                                character->direction = atan2(x_diff, z_diff);

                                                move_x = move_y = move_z = 0.0f;    
            // clear movement

                                                set_char_action(character, CHAR_SPELL, 0);
                                                is_spell_cast = 
            true;
                                                
            break;
                                            }
                                        }
                                    }

                                    
            break;
                                }

                                
            // go to next spelll
                                spell_index = (spell_index + 1) % NUM_SPELL_DEF;
                            }
                        }

                        
            // if still no spell cast, try casting a known self-enhancing ailment-effecting spell.
                        if(!is_spell_cast)
                        {
                            
            for(long i = 0; i < NUM_SPELL_DEF; i++)
                            {
                                
            // make sure it is self-enhancing
                                if(char_can_spell_ailment(character, &m_msl[i], i) && is_enhanced_ailment(m_msl[i].value[0]) &&
                                   rand()%100 < 10)
                                {
                                    
            // make sure ailment not already set
                                    if(!(character->ailments & (long)m_msl[i].value[0]))
                                    {
                                        character->victim      = character;
                                        character->attacker    = character;
                                        character->spell_index = i;
                                        character->target_type = CHAR_MONSTER;
                                        character->target_x    = character->pos_x;
                                        character->target_y    = character->pos_y;
                                        character->target_z    = character->pos_z;

                                        move_x = move_y = move_z = 0.0f;    
            // clear movement

                                        set_char_action(character, CHAR_SPELL, 0);
                                        
            break;
                                    }
                                }
                            }
                        }
                    }
                }

                
            // store movement
                *x_move = move_x;
                *y_move = move_y;
                *z_move = move_z;
            }

            The steps taken for initiating an update and processing all of a character’s actions
            is a long one. First, you iterate each character in the list of active characters. The
            appropriate character’s update function is called (pc_update or npc_monster_update).

            posted on 2007-12-04 16:29 lovedday 閱讀(303) 評論(0)  編輯 收藏 引用

            公告

            導航

            統計

            常用鏈接

            隨筆分類(178)

            3D游戲編程相關鏈接

            搜索

            最新評論

            四虎国产精品免费久久| 精品久久久久久无码不卡| 久久人人爽人人爽人人片AV东京热 | 日本久久久久亚洲中字幕| 18岁日韩内射颜射午夜久久成人| 久久久久亚洲av毛片大| 无码超乳爆乳中文字幕久久| 99久久精品免费看国产一区二区三区| 久久久久久免费一区二区三区| 狠狠综合久久综合88亚洲| 久久精品国产亚洲AV不卡| 亚洲精品高清国产一线久久| 精品一区二区久久久久久久网站| 少妇久久久久久被弄高潮| 久久黄视频| 中文字幕乱码人妻无码久久| 久久精品国产第一区二区三区| 热RE99久久精品国产66热| 久久精品免费一区二区| 亚洲嫩草影院久久精品| 久久精品国产色蜜蜜麻豆| 久久99久久无码毛片一区二区| 99久久精品国产综合一区| 国产精品成人久久久| 亚洲国产精品久久久久婷婷软件 | 成人精品一区二区久久| 久久久久久免费一区二区三区| 思思久久99热免费精品6| 久久精品亚洲精品国产欧美| 久久免费美女视频| 国产精品久久久久久影院| 久久久久夜夜夜精品国产| 亚洲精品无码专区久久久| 久久99热这里只有精品国产| 久久天天躁狠狠躁夜夜2020| 午夜精品久久久久久影视777| 久久夜色tv网站| 久久成人18免费网站| 精品无码人妻久久久久久| 久久无码一区二区三区少妇| 日本精品久久久久影院日本|