• <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游戲編程相關鏈接

            搜索

            最新評論

            a级毛片无码兔费真人久久| 亚洲天堂久久久| 99久久99久久| 久久久中文字幕日本| 中文字幕无码av激情不卡久久| 久久久久久精品久久久久| 久久66热人妻偷产精品9| 久久久99精品一区二区| 偷偷做久久久久网站| 精品国产VA久久久久久久冰 | 久久人做人爽一区二区三区 | 国内精品久久久久久99蜜桃 | 合区精品久久久中文字幕一区| 久久AV高潮AV无码AV| 超级碰久久免费公开视频| 久久人妻无码中文字幕| 国产成人久久777777| 久久影院综合精品| 2021国内精品久久久久久影院| 久久免费美女视频| 久久人妻少妇嫩草AV无码专区 | 国产三级观看久久| 久久国产精品无码一区二区三区| 欧美久久天天综合香蕉伊| 久久ZYZ资源站无码中文动漫| 一本久久综合亚洲鲁鲁五月天亚洲欧美一区二区 | 91视频国产91久久久| 狠狠色婷婷久久综合频道日韩| 中文字幕久久欲求不满| 久久国产精品久久| 久久人人妻人人爽人人爽| 亚洲中文字幕无码久久综合网| 午夜精品久久影院蜜桃| 色婷婷综合久久久久中文字幕| 91精品国产91久久久久福利| 欧美va久久久噜噜噜久久| 日本强好片久久久久久AAA| 久久精品久久久久观看99水蜜桃| 亚洲伊人久久成综合人影院 | 污污内射久久一区二区欧美日韩 | 久久se精品一区精品二区|