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

            搜索

            最新評論

            久久久久亚洲av无码专区喷水 | 欧美久久一级内射wwwwww.| 麻豆精品久久久一区二区| 久久久久国产精品三级网| 男女久久久国产一区二区三区| 久久777国产线看观看精品| 久久国产色av免费看| 99久久国产综合精品成人影院| 久久久噜噜噜久久中文字幕色伊伊| 亚洲AV无码久久| 久久成人国产精品免费软件| 久久青青草原精品国产| 国产三级观看久久| AV色综合久久天堂AV色综合在| 久久久久亚洲国产| 久久精品夜色噜噜亚洲A∨| 亚洲级αV无码毛片久久精品| 99久久夜色精品国产网站| 色综合久久夜色精品国产| 91精品国产高清91久久久久久| 精品久久久久久久| 国产偷久久久精品专区| 色综合久久无码五十路人妻| 久久久久一级精品亚洲国产成人综合AV区 | 无码人妻少妇久久中文字幕| 国产精品久久久久天天影视| 久久精品国产亚洲AV蜜臀色欲| 国产成人精品久久一区二区三区av | 亚洲精品高清久久| 久久精品中文字幕无码绿巨人 | 久久精品无码一区二区无码| 亚洲欧美另类日本久久国产真实乱对白 | 久久久久无码国产精品不卡| 久久精品国产亚洲AV大全| 久久亚洲电影| 久久综合九色综合久99| 色综合久久久久网| 亚洲狠狠综合久久| 久久久久成人精品无码 | 久久AV无码精品人妻糸列| 性做久久久久久免费观看|