Controlling Players and Characters(37)

Controlling Players and Characters(37)

Whenever a character needs updating, rendering, or what have you, a pointer to
the linked list of characters is needed in order to iterate the list. Either that or
maybe your application needs access to the character data. Either way, the following
functions will help you out:

    sCharacter* get_root_char()
    {
         return  m_root_char;
    }

    sCharacter* get_char( long  id)
    {
         for (sCharacter* character = m_root_char; character != NULL; character = character->next)
        {
             if (id == character->id)
                 return  character;
        }

         return  NULL;
    }

During specific functions, it becomes necessary for characters (such as monsters)
to make sure that they can see another character before attacking or casting a spell.
A function of your design is required to verify that such a line of sight is clear.
Returning a value of true states that a character is in sight of another one:

    virtual   bool  line_of_sight(sCharacter* source, sCharacter* target,
                                float  source_x,  float  source_y,  float  source_z,
                                float  target_x,  float  target_y,  float  target_z)
    {
         // make sure there is a line of sight between characters.

         return   true ;
    }

When the character controller (or outside code) needs one of the character’s abilities,
it needs to retrieve it with the following group of functions. These functions
take into account the various modifiers such as status ailments and equipped items:

    long  get_to_hit( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         long  to_hit = character->char_def.to_hit;

         if (character->ailments & AILMENT_BLIND)
            to_hit *= 0.75f;

         if (character->ailments & AILMENT_HAWKEYE)
            to_hit *= 1.5f;

         return  to_hit;
    }

     long  get_agility( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         long  agility = character->char_def.agility;

         if (character->ailments & AILMENT_CLUMSY)
            agility *= 0.75f;

         if (character->ailments & AILMENT_SUREFOOTED)
            agility *= 1.5f;

         return  agility;
    }

     long  get_attack( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         long  attack = character->char_def.attack;

         // adjust attack based on item value
         if (character->char_def.weapon != -1 && m_mil)
            attack *= (m_mil[character->char_def.weapon].value / 100.0f + 1.0f);

         if (character->ailments & AILMENT_WEAK)
            attack *= 0.5f;

         if (character->ailments & AILMENT_STRONG)
            attack *= 1.5f;

         return  attack;
    }
    
     long  get_defense( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         long  defense = character->char_def.defense;

         if (character->char_def.armor != -1 && m_mil)
            defense *= (m_mil[character->char_def.armor].value / 100.0f + 1.0f);

         if (character->char_def.shield != -1 && m_mil)
            defense *= (m_mil[character->char_def.shield].value / 100.0f + 1.0f);

         if (character->ailments & AILMENT_WEAK)
            defense *= 0.5f;

         if (character->ailments & AILMENT_STRONG)
            defense *= 1.5f;

         if (defense < 0)      // boudns check
            defense = 0;

         return  defense;
    }

     long  get_resistance( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         long  resistance = character->char_def.resistance;

         if (character->ailments & AILMENT_ENCHANTED)
            resistance *= 0.5f;

         if (character->ailments & AILMENT_BARRIER)
            resistance *= 1.5f;

         return  resistance;
    }

     long  get_mental( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         long  mental = character->char_def.mental;

         if (character->ailments & AILMENT_DUMBFOUNDED)
            mental *= 0.5f;

         return  mental;
    }

     float  get_speed( const  sCharacter* character)
    {
         if (character == NULL)
             return  0.0f;

         float  speed = character->char_def.speed;

         if (character->ailments & AILMENT_SLOW)
            speed *= 0.5f;

         if (character->ailments & AILMENT_FAST)
            speed *= 1.5f;

         if (speed < 1.0f)     // bounds check
            speed = 1.0f;

         return  speed;
    }

     float  get_charge_rate( const  sCharacter* character)
    {
         if (character == NULL)
             return  0;

         float  charge_rate = character->char_def.charge_rate;

         if (character->ailments & AILMENT_SLOW)
            charge_rate *= 0.75f;

         if (character->ailments & AILMENT_FAST)
            charge_rate *= 1.5f;

         return  charge_rate;
    }