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

            天行健 君子當自強而不息

            Putting Together a Full Game(14)

             

            Controlling Characters

            The characters are the heart and soul of your game.

            You derive the character controller in order to
            control the player of the game and to collision-check a character's movements
            against the maps. For The Tower, you can use a derived character controller,
            to manage all your game's characters. The first step to
            using the character controller in a game is to derive your own class from cCharController:

            class cGameChars : public cCharController
            {
            private:
                cApp*   m_app;

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

            public:
                
            void attach_app(cApp* app)
                {
                    m_app = app;
                }

            private:
                
            virtual void drop_money(float x_pos, float y_pos, float z_pos, long quantity);
                
            virtual bool gain_exp(sCharacter* character, long amount);
                
            virtual bool pc_teleport(sCharacter* character, const sSpell* spell);

                
            virtual void pc_update(sCharacter* character, long elapsed,
                                       
            float* x_move, float* y_move, float* z_move);

                
            virtual bool validate_move(sCharacter* character, float* x_move, float* y_move, float* z_move);
                
            virtual void play_action_sound(const sCharacter* character);
            };

            The cGameChars class comes with only one public function, attach_app. You use the cGameChars
            function to set the application class pointer in the cGameChars class instance. In addition,
            the cGameChars class overrides only the functions used to move the player and to validate
            all character movements. The remaining functions come into play when the player
            gains experience points from combat or teleports the character with a spell, when
            the character controller plays a sound, when a monster drops some money, or
            when a monster drops an item after being killed.

            Because the derived character controller class requires access to the application
            class, you must precede all calls to the cGameChars class with a call to the attach_app function.
            The attach_app function takes one argument—the pointer to the application class.

            The other functions, such as gain_exp, drop_money, tell the game engine
            that a monster was killed and that the game needs to reward the player with experience,
            money from a dying monster. These rewards are pushed
            aside until combat ends, at which point, the application class's end_of_combat function
            processes them.

            void cGameChars::drop_money(float x_pos, float y_pos, float z_pos, long quantity)
            {
                m_app->m_combat_money += quantity;
            }

            bool cGameChars::gain_exp(sCharacter* character, long amount)
            {
                m_app->m_combat_exp += amount;

                
            return false;   // do not display message
            }

            bool cGameChars::pc_teleport(sCharacter* character, const sSpell* spell)
            {
                
            // teleport player to town
                m_app->teleport_player(1, 100.0f, 0.0f, -170.0f);

                
            return true;
            }

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

            bool cGameChars::validate_move(sCharacter* character, float* x_move, float* y_move, float* z_move)
            {
                
            float pos_x = character->pos_x;
                
            float pos_y = character->pos_y;
                
            float pos_z = character->pos_z;

                
            // check against terrain mesh for collision
                if(m_app->check_intersect(pos_x, pos_y + 8.0f, pos_z,
                                          pos_x + *x_move, pos_y + 8.0f + *y_move, pos_z + *z_move,
                                          NULL))
                    
            return false;

                
            // get new height
                float height = m_app->get_height_below(pos_x + *x_move, pos_y + 32.0f, pos_z + *z_move);
                *y_move = height - pos_y;

                
            // check against barriers and clear movement if any
                if(m_app->m_barrier.get_barrier(pos_x + *x_move, pos_y + *y_move, pos_z + *z_move))
                    (*x_move) = (*y_move) = (*z_move) = 0.0f;

                
            return true;
            }

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

            void cGameChars::play_action_sound(const sCharacter* character)
            {
                
            long sound = 0;

                
            // play sound based on character type and action
                switch(character->action)
                {
                
            case CHAR_ATTACK:
                    m_app->play_sound(character->id == ID_PLAYER ? SOUND_CHAR_ATTACK : SOUND_MONSTER_ATTACK);
                    
            break;

                
            case CHAR_SPELL:
                    
            if(character->spell_index == SPELL_FIREBALL)
                        sound = SOUND_FIREBALL;
                    
            else if(character->spell_index == SPELL_ICE)
                        sound = SOUND_ICE;
                    
            else if(character->spell_index == SPELL_HEAL)
                        sound = SOUND_HEAL;
                    
            else if(character->spell_index == SPELL_TELEPORT)
                        sound = SOUND_TELEPORT;
                    
            else if(character->spell_index == SPELL_GROUNDBALL)
                        sound = SOUND_GROUNDBALL;
                    
            else if(character->spell_index == SPELL_CONCUSSION)
                        sound = SOUND_CONCUSSION;
                    
            else if(character->spell_index == SPELL_EVIL_FORCE)
                        sound = SOUND_EVIL_FORCE;

                    m_app->play_sound(sound);
                    
            break;

                
            case CHAR_HURT:
                    m_app->play_sound(character->id == ID_PLAYER ? SOUND_CHAR_HURT : SOUND_MONSTER_HURT);
                    
            break;

                
            case CHAR_DIE:
                    m_app->play_sound(character->id == ID_PLAYER ? SOUND_CHAR_DIE : SOUND_MONSTER_DIE);
                    
            break;
                }
            }

            The pc_update is the main function of interest here. It determines which keys the
            player is pressing and what mouse button is being pressed. Now, take this function
            apart to see what makes it tick:


            void cGameChars::pc_update(sCharacter* character, long elapsed,
                                       
            float* x_move, float* y_move, float* z_move)
            {
                
            if(elapsed == 0)    // do not update if no elapsed time
                    return;

                
            // rotate character

                
            if(m_app->m_keyboard.get_key_state(KEY_LEFT) || m_app->m_keyboard.get_key_state(KEY_A))
                {
                    character->direction -= elapsed / 1000.0f * 4.0f;
                    character->action = CHAR_MOVE;
                }

                
            if(m_app->m_keyboard.get_key_state(KEY_RIGHT) || m_app->m_keyboard.get_key_state(KEY_D))
                {
                    character->direction += elapsed / 1000.0f * 4.0f;
                    character->action = CHAR_MOVE;
                }

                
            // calculate move length along x,z axis

                
            if(m_app->m_keyboard.get_key_state(KEY_UP) || m_app->m_keyboard.get_key_state(KEY_W))
                {
                    
            float speed = elapsed / 1000.0f * m_app->m_game_chars.get_speed(character);

                    *x_move = sin(character->direction) * speed;
                    *z_move = cos(character->direction) * speed;

                    character->action = CHAR_MOVE;
                }

                
            // process attack or talk action
                if(m_app->m_mouse.get_button_state(MOUSE_LBUTTON))
                {
                    
            // see which character is being pointed at and make sure if it is a monster.

                    sCharacter* target = m_app->get_char_at(m_app->m_mouse.get_x_pos(), m_app->m_mouse.get_y_pos());

                    
            if(target != NULL)
                    {
                        
            if(target->type == CHAR_NPC)    // handle talking to npcs
                        {
                            
            // no distance checks, just process their script.

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

                            m_app->m_game_script.execute(filename);
                            
            return// do not process anymore
                        }
                        
            else if(target->type == CHAR_MONSTER)   // handle attacking monsters
                        {
                            
            // get distance to target
                            float x_diff = fabs(target->pos_x - character->pos_x);
                            
            float y_diff = fabs(target->pos_y - character->pos_y);
                            
            float z_diff = fabs(target->pos_z - character->pos_z);

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

                            
            // offset dist by target's radius
                            float monster_radius = get_xz_radius(target);
                            dist -= (monster_radius * monster_radius);

                            
            float attack_range = get_xz_radius(character) + character->char_def.attack_range;

                            
            // only perform attack if target in range
                            if(dist <= (attack_range * attack_range))
                            {
                                target->attacker  = character;
                                character->victim = target;

                                
            // face victim
                                x_diff = target->pos_x - character->pos_x;
                                z_diff = target->pos_z - character->pos_z;
                                character->direction = atan2(x_diff, z_diff);

                                m_app->m_game_chars.set_char_action(character, CHAR_ATTACK, 0);
                            }
                        }
                    }
                }

                
            long spell_index = -1;

                
            // cast magic spll based on NUM key pressed

                
            if(m_app->m_keyboard.get_key_state(KEY_1))
                {
                    m_app->m_keyboard.m_locks[KEY_1] = 
            true;
                    spell_index = SPELL_FIREBALL;
                }
                
            else if(m_app->m_keyboard.get_key_state(KEY_2))
                {
                    m_app->m_keyboard.m_locks[KEY_2] = 
            true;
                    spell_index = SPELL_ICE;
                }
                
            else if(m_app->m_keyboard.get_key_state(KEY_3))
                {
                    m_app->m_keyboard.m_locks[KEY_3] = 
            true;
                    spell_index = SPELL_HEAL;
                }
                
            else if(m_app->m_keyboard.get_key_state(KEY_4))
                {
                    m_app->m_keyboard.m_locks[KEY_4] = 
            true;
                    spell_index = SPELL_TELEPORT;
                }
                
            else if(m_app->m_keyboard.get_key_state(KEY_5))
                {
                    m_app->m_keyboard.m_locks[KEY_5] = 
            true;
                    spell_index = SPELL_GROUNDBALL;
                }

                
            // cast spell if commanded
                if(spell_index != -1)
                {
                    sSpell* spell = m_app->m_game_spells.get_spell(spell_index);

                    
            // only cast if spell known and has enough mana points
                    if(char_can_spell(character, spell, spell_index))
                    {
                        
            // see which character is being pointed
                        sCharacter* target = m_app->get_char_at(m_app->m_mouse.get_x_pos(), m_app->m_mouse.get_y_pos());

                        
            if(target && target->type == CHAR_MONSTER)
                        {
                            
            // get distance to target

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

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

                            
            // offset dist by target's radius
                            float target_radius = get_xz_radius(target);
                            dist -= (target_radius * target_radius);

                            
            float spell_range = get_xz_radius(character) + spell->max_dist;
                    
                            
            // only perform spell if target in range
                            if(dist <= (spell_range * spell_range))
                            {
                                character->spell_index = spell_index;
                                character->target_type = CHAR_MONSTER;
                                character->target_x    = target->pos_x;
                                character->target_y    = target->pos_y;
                                character->target_z    = target->pos_z;

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

                                // face victim
                                x_diff = target->pos_x - character->pos_x;
                                z_diff = target->pos_z - character->pos_z;

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

                                set_char_action(character, CHAR_SPELL, 0);
                            }
                        }
                        
            else if(target == character)
                        {
                            
            if((spell_index == SPELL_HEAL && character->health_points < character->char_def.health_points) ||
                               (spell_index == SPELL_TELEPORT))
                            {
                                character->spell_index = spell_index;
                                character->target_type = CHAR_PC;
                                character->target_x    = target->pos_x;
                                character->target_y    = target->pos_y;
                                character->target_z    = target->pos_z;

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

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

                
            // enter status frame if right mouse buttom pressed
                if(m_app->m_mouse.get_button_state(MOUSE_RBUTTON))
                {
                    m_app->m_mouse.m_locks[MOUSE_RBUTTON] = 
            true;
                    m_app->m_state_manager.push(status_frame, m_app);
                }
            }

            pc_update starts by first determining whether an update is in order (based on
            whether any time has elapsed) and continues by determining which keys (if any)
            are pressed on the keyboard. If the up arrow key is pressed, the character moves
            forward, whereas if the left or right arrow keys are pressed, the character’s direction
            is modified.

            For each movement that the player performs, such as walking forward or turning
            left and right, you need to assign the CHAR_MOVE action to the player's character.
            Notice that even though pressing left or right immediately rotates the player’s character,
            the code does not immediately modify the character’s coordinates. Instead,
            you store the direction of travel in the x_move and z_move variables.

            You then determine whether the player has clicked the left mouse button. Remember
            from the design of the sample game that clicking the left mouse button on a nearby
            character either attacks the character (if the character is a monster) or speaks to the
            character (if the character is an NPC).

            The portion of code just shown calls upon the get_char_at function, which scans
            for the character that is positioned under the mouse cursor. If a character is found,
            you determine which type of character it is; if it is an NPC, you execute the appropriate
            character's script.

            On the other hand, if the character clicked is a monster and that monster is within
            attack range, you initiate an attack action.

            Coming up to the end of the pc_update function, the controller needs to determine
            whether a spell has been cast at a nearby character. In the game, positioning the
            mouse cursor over a character and pressing one of the number keys (from 1 through
            5) casts a spell.

            If a spell was cast, the controller determines whether the player knows the spell and
            has enough mana to cast the spell and whether the target character is in range.

            At this point, the controller has determined that the spell can be cast. You need
            to store the coordinates of the target, the number of the spell being cast, and the
            player's action in the structure pointed to by the Character pointer.

            To finish up the player character update, the controller determines whether the
            player clicked the right mouse button, which opens the character’s status window
            (by pushing the character-status state onto the state stack).

            posted on 2007-12-30 00:24 lovedday 閱讀(327) 評論(0)  編輯 收藏 引用

            公告

            導航

            統計

            常用鏈接

            隨筆分類(178)

            3D游戲編程相關鏈接

            搜索

            最新評論

            亚洲欧美成人综合久久久| 99久久精品免费看国产| 久久久久久久久波多野高潮| 中文字幕久久亚洲一区| 亚洲欧美日韩中文久久| 久久综合狠狠色综合伊人| 99久久精品免费看国产一区二区三区 | 午夜精品久久久久久| 亚洲日韩中文无码久久| 国产精品嫩草影院久久| 国产亚洲美女精品久久久2020| 久久99精品国产99久久| 中文字幕无码久久久| 久久精品免费观看| 中文精品久久久久人妻不卡| 国产精品免费久久久久久久久| 久久亚洲私人国产精品vA| 亚洲狠狠综合久久| 久久精品一本到99热免费| 伊人久久亚洲综合影院| 久久精品国产精品亚洲人人 | 日本久久中文字幕| 久久免费精品视频| avtt天堂网久久精品| 精品多毛少妇人妻AV免费久久| 激情五月综合综合久久69| 国产一区二区精品久久| 亚洲精品国产字幕久久不卡| 中文精品99久久国产| 久久男人中文字幕资源站| 国产香蕉97碰碰久久人人| 热99re久久国超精品首页| 99久久免费国产精精品| 精品久久久久香蕉网| 狠狠88综合久久久久综合网| 狼狼综合久久久久综合网| 性做久久久久久久| 久久久久亚洲av无码专区| 国产精品99精品久久免费| 久久国产精品久久| 狠狠久久综合伊人不卡|