Controlling Players and Characters(33)

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).