path: root/src/map/mob.c

// $Id: mob.c,v 1.7 2004/09/25 05:32:18 MouseJstr Exp $
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#include "timer.h"
#include "socket.h"
#include "db.h"
#include "nullpo.h"
#include "malloc.h"
#include "map.h"
#include "clif.h"
#include "intif.h"
#include "pc.h"
#include "mob.h"
#include "guild.h"
#include "itemdb.h"
#include "skill.h"
#include "battle.h"
#include "party.h"
#include "npc.h"

#ifdef MEMWATCH
#include "memwatch.h"
#endif

#ifndef max
#define max( a, b ) ( ((a) > (b)) ? (a) : (b) )
#endif

#define MIN_MOBTHINKTIME 100

#define MOB_LAZYMOVEPERC 50     // Move probability in the negligent mode MOB (rate of 1000 minute)
#define MOB_LAZYWARPPERC 20     // Warp probability in the negligent mode MOB (rate of 1000 minute)

struct mob_db mob_db[2001];

/*==========================================
 * Local prototype declaration   (only required thing)
 *------------------------------------------
 */
static int distance (int, int, int, int);
static int mob_makedummymobdb (int);
static int mob_timer (int, unsigned int, int, int);
int  mobskill_use (struct mob_data *md, unsigned int tick, int event);
int  mobskill_deltimer (struct mob_data *md);
int  mob_skillid2skillidx (int class, int skillid);
int  mobskill_use_id (struct mob_data *md, struct block_list *target,
                      int skill_idx);
static int mob_unlocktarget (struct mob_data *md, int tick);

/*==========================================
 * Mob is searched with a name.
 *------------------------------------------
 */
int mobdb_searchname (const char *str)
{
    int  i;

    for (i = 0; i < sizeof (mob_db) / sizeof (mob_db[0]); i++)
    {
        if (strcmpi (mob_db[i].name, str) == 0
            || strcmp (mob_db[i].jname, str) == 0
            || memcmp (mob_db[i].name, str, 24) == 0
            || memcmp (mob_db[i].jname, str, 24) == 0)
            return i;
    }

    return 0;
}

/*==========================================
 * Id Mob is checked.
 *------------------------------------------
 */
int mobdb_checkid (const int id)
{
    if (id <= 0 || id >= (sizeof (mob_db) / sizeof (mob_db[0]))
        || mob_db[id].name[0] == '\0')
        return 0;

    return id;
}

static void mob_init (struct mob_data *md);

/*==========================================
 * The minimum data set for MOB spawning
 *------------------------------------------
 */
int mob_spawn_dataset (struct mob_data *md, const char *mobname, int class)
{
    nullpo_retr (0, md);

    if (strcmp (mobname, "--en--") == 0)
        memcpy (md->name, mob_db[class].name, 24);
    else if (strcmp (mobname, "--ja--") == 0)
        memcpy (md->name, mob_db[class].jname, 24);
    else
        memcpy (md->name, mobname, 24);

    md->bl.prev = NULL;
    md->bl.next = NULL;
    md->n = 0;
    md->base_class = md->class = class;
    md->bl.id = npc_get_new_npc_id ();

    memset (&md->state, 0, sizeof (md->state));
    md->timer = -1;
    md->target_id = 0;
    md->attacked_id = 0;

    mob_init (md);

    return 0;
}

// Mutation values indicate how `valuable' a change to each stat is, XP wise.
// For one 256th of change, we give out that many 1024th fractions of XP change
// (i.e., 1024 means a 100% XP increase for a single point of adjustment, 4 means 100% XP bonus for doubling the value)
static int mutation_value[MOB_XP_BONUS] = {
    2,                          // MOB_LV
    3,                          // MOB_MAX_HP
    1,                          // MOB_STR
    2,                          // MOB_AGI
    1,                          // MOB_VIT
    0,                          // MOB_INT
    2,                          // MOB_DEX
    2,                          // MOB_LUK
    1,                          // MOB_ATK1
    1,                          // MOB_ATK2
    2,                          // MOB_ADELAY
    2,                          // MOB_DEF
    2,                          // MOB_MDEF
    2,                          // MOB_SPEED
};

// The mutation scale indicates how far `up' we can go, with 256 indicating 100%  Note that this may stack with multiple
// calls to `mutate'.
static int mutation_scale[MOB_XP_BONUS] = {
    16,                         // MOB_LV
    256,                        // MOB_MAX_HP
    32,                         // MOB_STR
    48,                         // MOB_AGI
    48,                         // MOB_VIT
    48,                         // MOB_INT
    48,                         // MOB_DEX
    64,                         // MOB_LUK
    48,                         // MOB_ATK1
    48,                         // MOB_ATK2
    80,                         // MOB_ADELAY
    48,                         // MOB_DEF
    48,                         // MOB_MDEF
    80,                         // MOB_SPEED
};

// The table below indicates the `average' value for each of the statistics, or -1 if there is none.
// This average is used to determine XP modifications for mutations.  The experience point bonus is
// based on mutation_value and mutation_base as follows:
// (1) first, compute the percentage change of the attribute (p0)
// (2) second, determine the absolute stat change
// (3) third, compute the percentage stat change relative to mutation_base (p1)
// (4) fourth, compute the XP mofication based on the smaller of (p0, p1).
static int mutation_base[MOB_XP_BONUS] = {
    30,                         // MOB_LV
    -1,                         // MOB_MAX_HP
    20,                         // MOB_STR
    20,                         // MOB_AGI
    20,                         // MOB_VIT
    20,                         // MOB_INT
    20,                         // MOB_DEX
    20,                         // MOB_LUK
    -1,                         // MOB_ATK1
    -1,                         // MOB_ATK2
    -1,                         // MOB_ADELAY
    -1,                         // MOB_DEF
    20,                         // MOB_MDEF
    -1,                         // MOB_SPEED
};

/*========================================
 * Mutates a MOB.  For large `direction' values, calling this multiple times will give bigger XP boni.
 *----------------------------------------
 */
static void mob_mutate (struct mob_data *md, int stat, int intensity)   // intensity: positive: strengthen, negative: weaken.  256 = 100%.
{
    int  old_stat;
    int  new_stat;
    int  real_intensity;        // relative intensity 
    const int mut_base = mutation_base[stat];
    int  sign = 1;

    if (!md || stat < 0 || stat >= MOB_XP_BONUS || intensity == 0)
        return;

    while (intensity > mutation_scale[stat])
    {
        mob_mutate (md, stat, mutation_scale[stat]);    // give better XP assignments
        intensity -= mutation_scale[stat];
    }
    while (intensity < -mutation_scale[stat])
    {
        mob_mutate (md, stat, mutation_scale[stat]);    // give better XP assignments
        intensity += mutation_scale[stat];
    }

    if (!intensity)
        return;

    // MOB_ADELAY and MOB_SPEED are special because going DOWN is good here.
    if (stat == MOB_ADELAY || stat == MOB_SPEED)
        sign = -1;

    // Now compute the new stat
    old_stat = md->stats[stat];
    new_stat = old_stat + ((old_stat * sign * intensity) / 256);

    if (new_stat < 0)
        new_stat = 0;

    if (old_stat == 0)
        real_intensity = 0;
    else
        real_intensity = (((new_stat - old_stat) << 8) / old_stat);

    if (mut_base != -1)
    {
        // Now compute the mutation intensity relative to an absolute value.
        // Take the lesser of the two effects.
        int  real_intensity2 = (((new_stat - old_stat) << 8) / mut_base);

        if (real_intensity < 0)
            if (real_intensity2 > real_intensity)
                real_intensity = real_intensity2;

        if (real_intensity > 0)
            if (real_intensity2 < real_intensity)
                real_intensity = real_intensity2;
    }

    real_intensity *= sign;

    md->stats[stat] = new_stat;

    // Adjust XP value
    md->stats[MOB_XP_BONUS] += mutation_value[stat] * real_intensity;
    if (md->stats[MOB_XP_BONUS] <= 0)
        md->stats[MOB_XP_BONUS] = 1;

    // Sanitise
    if (md->stats[MOB_ATK1] > md->stats[MOB_ATK2])
    {
        int  swap = md->stats[MOB_ATK2];
        md->stats[MOB_ATK2] = md->stats[MOB_ATK1];
        md->stats[MOB_ATK1] = swap;
    }
}

// This calculates the exp of a given mob
int mob_gen_exp (struct mob_db *mob)
{
    if (mob->max_hp <= 1)
        return 1;
    double mod_def = 100 - mob->def;
    if (mod_def == 0)
        mod_def = 1;
    double effective_hp =
        ((50 - mob->luk) * mob->max_hp / 50.0) +
        (2 * mob->luk * mob->max_hp / mod_def);
    double attack_factor =
        (mob->atk1 + mob->atk2 + mob->str / 3.0 + mob->dex / 2.0 +
         mob->luk) * (1872.0 / mob->adelay) / 4;
    double dodge_factor =
        pow (mob->lv + mob->agi + mob->luk / 2.0, 4.0 / 3.0);
    double persuit_factor =
        (3 + mob->range) * (mob->mode % 2) * 1000 / mob->speed;
    double aggression_factor = (mob->mode & 4) == 4 ? 10.0 / 9.0 : 1.0;
    int  xp =
        (int) floor (effective_hp *
                     pow (sqrt (attack_factor) + sqrt (dodge_factor) +
                          sqrt (persuit_factor) + 55,
                          3) * aggression_factor / 2000000.0 *
                     (double) battle_config.base_exp_rate / 100.);
    if (xp < 1)
        xp = 1;
    printf ("Exp for mob '%s' generated: %d\n", mob->name, xp);
    return xp;
}

static void mob_init (struct mob_data *md)
{
    int  i;
    const int class = md->class;
    const int mutations_nr = mob_db[class].mutations_nr;
    const int mutation_power = mob_db[class].mutation_power;

    md->stats[MOB_LV] = mob_db[class].lv;
    md->stats[MOB_MAX_HP] = mob_db[class].max_hp;
    md->stats[MOB_STR] = mob_db[class].str;
    md->stats[MOB_AGI] = mob_db[class].agi;
    md->stats[MOB_VIT] = mob_db[class].vit;
    md->stats[MOB_INT] = mob_db[class].int_;
    md->stats[MOB_DEX] = mob_db[class].dex;
    md->stats[MOB_LUK] = mob_db[class].luk;
    md->stats[MOB_ATK1] = mob_db[class].atk1;
    md->stats[MOB_ATK2] = mob_db[class].atk2;
    md->stats[MOB_ADELAY] = mob_db[class].adelay;
    md->stats[MOB_DEF] = mob_db[class].def;
    md->stats[MOB_MDEF] = mob_db[class].mdef;
    md->stats[MOB_SPEED] = mob_db[class].speed;
    md->stats[MOB_XP_BONUS] = MOB_XP_BONUS_BASE;

    for (i = 0; i < mutations_nr; i++)
    {
        int  stat_nr = MRAND (MOB_XP_BONUS + 1);
        int  strength;

        if (stat_nr >= MOB_XP_BONUS)
            stat_nr = MOB_MAX_HP;

        strength =
            ((MRAND ((mutation_power >> 1)) +
              (MRAND ((mutation_power >> 1))) +
              2) * mutation_scale[stat_nr]) / 100;

        strength = MRAND (2) ? strength : -strength;

        if (strength < -240)
            strength = -240;    /* Don't go too close to zero */

        mob_mutate (md, stat_nr, strength);
    }
}

/*==========================================
 * The MOB appearance for one time (for scripts)
 *------------------------------------------
 */
int mob_once_spawn (struct map_session_data *sd, char *mapname,
                    int x, int y, const char *mobname, int class, int amount,
                    const char *event)
{
    struct mob_data *md = NULL;
    int  m, count, lv = 255, r = class;

    if (sd)
        lv = sd->status.base_level;

    if (sd && strcmp (mapname, "this") == 0)
        m = sd->bl.m;
    else
        m = map_mapname2mapid (mapname);

    if (m < 0 || amount <= 0 || (class >= 0 && class <= 1000) || class > 2000)  // �l���ُ�Ȃ珢�����~�߂�
        return 0;

    if (class < 0)
    {                           // �����_���ɏ���
        int  i = 0;
        int  j = -class - 1;
        int  k;
        if (j >= 0 && j < MAX_RANDOMMONSTER)
        {
            do
            {
                class = MPRAND (1001, 1000);
                k = MRAND (1000000);
            }
            while ((mob_db[class].max_hp <= 0
                    || mob_db[class].summonper[j] <= k
                    || (lv < mob_db[class].lv
                        && battle_config.random_monster_checklv == 1))
                   && (i++) < 2000);
            if (i >= 2000)
            {
                class = mob_db[0].summonper[j];
            }
        }
        else
        {
            return 0;
        }
//      if(battle_config.etc_log==1)
//          printf("mobclass=%d try=%d\n",class,i);
    }
    if (sd)
    {
        if (x <= 0)
            x = sd->bl.x;
        if (y <= 0)
            y = sd->bl.y;
    }
    else if (x <= 0 || y <= 0)
    {
        printf ("mob_once_spawn: ??\n");
    }

    for (count = 0; count < amount; count++)
    {
        md = (struct mob_data *) aCalloc (1, sizeof (struct mob_data));
        memset (md, '\0', sizeof *md);
        if (mob_db[class].mode & 0x02)
            md->lootitem =
                (struct item *) aCalloc (LOOTITEM_SIZE, sizeof (struct item));
        else
            md->lootitem = NULL;

        mob_spawn_dataset (md, mobname, class);
        md->bl.m = m;
        md->bl.x = x;
        md->bl.y = y;
        if (r < 0 && battle_config.dead_branch_active == 1)
            md->mode = 0x1 + 0x4 + 0x80;    //�ړ����ăA�N�e�B�u�Ŕ�������
        md->m = m;
        md->x0 = x;
        md->y0 = y;
        md->xs = 0;
        md->ys = 0;
        md->spawndelay1 = -1;   // Only once is a flag.
        md->spawndelay2 = -1;   // Only once is a flag.

        memcpy (md->npc_event, event, sizeof (md->npc_event));

        md->bl.type = BL_MOB;
        map_addiddb (&md->bl);
        mob_spawn (md->bl.id);

        if (class == 1288)
        {                       // emperium hp based on defense level [Valaris]
            struct guild_castle *gc = guild_mapname2gc (map[md->bl.m].name);
            if (gc)
            {
                mob_db[class].max_hp += 2000 * gc->defense;
                md->hp = mob_db[class].max_hp;
            }
        }                       // end addition [Valaris]

    }
    return (amount > 0) ? md->bl.id : 0;
}

/*==========================================
 * The MOB appearance for one time (& area specification for scripts)
 *------------------------------------------
 */
int mob_once_spawn_area (struct map_session_data *sd, char *mapname,
                         int x0, int y0, int x1, int y1,
                         const char *mobname, int class, int amount,
                         const char *event)
{
    int  x, y, i, c, max, lx = -1, ly = -1, id = 0;
    int  m;

    if (strcmp (mapname, "this") == 0)
        m = sd->bl.m;
    else
        m = map_mapname2mapid (mapname);

    max = (y1 - y0 + 1) * (x1 - x0 + 1) * 3;
    if (max > 1000)
        max = 1000;

    if (m < 0 || amount <= 0 || (class >= 0 && class <= 1000) || class > 2000)  // A summon is stopped if a value is unusual
        return 0;

    for (i = 0; i < amount; i++)
    {
        int  j = 0;
        do
        {
            x = MPRAND (x0, (x1 - x0 + 1));
            y = MPRAND (y0, (y1 - y0 + 1));
        }
        while (((c = map_getcell (m, x, y)) == 1 || c == 5) && (++j) < max);
        if (j >= max)
        {
            if (lx >= 0)
            {                   // Since reference went wrong, the place which boiled before is used.
                x = lx;
                y = ly;
            }
            else
                return 0;       // Since reference of the place which boils first went wrong, it stops.
        }
        id = mob_once_spawn (sd, mapname, x, y, mobname, class, 1, event);
        lx = x;
        ly = y;
    }
    return id;
}

/*==========================================
 * Summoning Guardians [Valaris]
 *------------------------------------------
 */
int mob_spawn_guardian (struct map_session_data *sd, char *mapname,
                        int x, int y, const char *mobname, int class,
                        int amount, const char *event, int guardian)
{
    struct mob_data *md = NULL;
    int  m, count = 1, lv = 255;

    if (sd)
        lv = sd->status.base_level;

    if (sd && strcmp (mapname, "this") == 0)
        m = sd->bl.m;
    else
        m = map_mapname2mapid (mapname);

    if (m < 0 || amount <= 0 || (class >= 0 && class <= 1000) || class > 2000)  // �l���ُ�Ȃ珢�����~�߂�
        return 0;

    if (class < 0)
        return 0;

    if (sd)
    {
        if (x <= 0)
            x = sd->bl.x;
        if (y <= 0)
            y = sd->bl.y;
    }

    else if (x <= 0 || y <= 0)
        printf ("mob_spawn_guardian: ??\n");

    for (count = 0; count < amount; count++)
    {
        struct guild_castle *gc;
        md = calloc (sizeof (struct mob_data), 1);
        if (md == NULL)
        {
            printf ("mob_spawn_guardian: out of memory !\n");
            exit (1);
        }
        memset (md, '\0', sizeof *md);

        mob_spawn_dataset (md, mobname, class);
        md->bl.m = m;
        md->bl.x = x;
        md->bl.y = y;
        md->m = m;
        md->x0 = x;
        md->y0 = y;
        md->xs = 0;
        md->ys = 0;
        md->spawndelay1 = -1;   // Only once is a flag.
        md->spawndelay2 = -1;   // Only once is a flag.

        memcpy (md->npc_event, event, sizeof (md->npc_event));

        md->bl.type = BL_MOB;
        map_addiddb (&md->bl);
        mob_spawn (md->bl.id);

        gc = guild_mapname2gc (map[md->bl.m].name);
        if (gc)
        {
            mob_db[class].max_hp += 2000 * gc->defense;
            if (guardian == 0)
            {
                md->hp = gc->Ghp0;
                gc->GID0 = md->bl.id;
            }
            if (guardian == 1)
            {
                md->hp = gc->Ghp1;
                gc->GID1 = md->bl.id;
            }
            if (guardian == 2)
            {
                md->hp = gc->Ghp2;
                gc->GID2 = md->bl.id;
            }
            if (guardian == 3)
            {
                md->hp = gc->Ghp3;
                gc->GID3 = md->bl.id;
            }
            if (guardian == 4)
            {
                md->hp = gc->Ghp4;
                gc->GID4 = md->bl.id;
            }
            if (guardian == 5)
            {
                md->hp = gc->Ghp5;
                gc->GID5 = md->bl.id;
            }
            if (guardian == 6)
            {
                md->hp = gc->Ghp6;
                gc->GID6 = md->bl.id;
            }
            if (guardian == 7)
            {
                md->hp = gc->Ghp7;
                gc->GID7 = md->bl.id;
            }

        }
    }

    return (amount > 0) ? md->bl.id : 0;
}

/*==========================================
 * Appearance income of mob
 *------------------------------------------
 */
int mob_get_viewclass (int class)
{
    return mob_db[class].view_class;
}

int mob_get_sex (int class)
{
    return mob_db[class].sex;
}

short mob_get_hair (int class)
{
    return mob_db[class].hair;
}

short mob_get_hair_color (int class)
{
    return mob_db[class].hair_color;
}

short mob_get_weapon (int class)
{
    return mob_db[class].weapon;
}

short mob_get_shield (int class)
{
    return mob_db[class].shield;
}

short mob_get_head_top (int class)
{
    return mob_db[class].head_top;
}

short mob_get_head_mid (int class)
{
    return mob_db[class].head_mid;
}

short mob_get_head_buttom (int class)
{
    return mob_db[class].head_buttom;
}

short mob_get_clothes_color (int class) // Add for player monster dye - Valaris
{
    return mob_db[class].clothes_color; // End
}

int mob_get_equip (int class)   // mob equip [Valaris]
{
    return mob_db[class].equip;
}

/*==========================================
 * Is MOB in the state in which the present movement is possible or not?
 *------------------------------------------
 */
int mob_can_move (struct mob_data *md)
{
    nullpo_retr (0, md);

    if (md->canmove_tick > gettick () || (md->opt1 > 0 && md->opt1 != 6)
        || md->option & 2)
        return 0;
    // �A���N�����œ����Ȃ��Ƃ�
    if (md->sc_data[SC_ANKLE].timer != -1 ||    //�A���N���X�l�A
        md->sc_data[SC_AUTOCOUNTER].timer != -1 ||  //�I�[�g�J�E���^�[
        md->sc_data[SC_BLADESTOP].timer != -1 ||    //���n���
        md->sc_data[SC_SPIDERWEB].timer != -1   //�X�p�C�_�[�E�F�b�u
        )
        return 0;

    return 1;
}

/*==========================================
 * Time calculation concerning one step next to mob
 *------------------------------------------
 */
static int calc_next_walk_step (struct mob_data *md)
{
    nullpo_retr (0, md);

    if (md->walkpath.path_pos >= md->walkpath.path_len)
        return -1;
    if (md->walkpath.path[md->walkpath.path_pos] & 1)
        return battle_get_speed (&md->bl) * 14 / 10;
    return battle_get_speed (&md->bl);
}

static int mob_walktoxy_sub (struct mob_data *md);

/*==========================================
 * Mob Walk processing
 *------------------------------------------
 */
static int mob_walk (struct mob_data *md, unsigned int tick, int data)
{
    int  moveblock;
    int  i, ctype;
    static int dirx[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
    static int diry[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
    int  x, y, dx, dy;

    nullpo_retr (0, md);

    md->state.state = MS_IDLE;
    if (md->walkpath.path_pos >= md->walkpath.path_len
        || md->walkpath.path_pos != data)
        return 0;

    md->walkpath.path_half ^= 1;
    if (md->walkpath.path_half == 0)
    {
        md->walkpath.path_pos++;
        if (md->state.change_walk_target)
        {
            mob_walktoxy_sub (md);
            return 0;
        }
    }
    else
    {
        if (md->walkpath.path[md->walkpath.path_pos] >= 8)
            return 1;

        x = md->bl.x;
        y = md->bl.y;
        ctype = map_getcell (md->bl.m, x, y);
        if (ctype == 1 || ctype == 5)
        {
            mob_stop_walking (md, 1);
            return 0;
        }
        md->dir = md->walkpath.path[md->walkpath.path_pos];
        dx = dirx[md->dir];
        dy = diry[md->dir];

        ctype = map_getcell (md->bl.m, x + dx, y + dy);
        if (ctype == 1 || ctype == 5)
        {
            mob_walktoxy_sub (md);
            return 0;
        }

        moveblock = (x / BLOCK_SIZE != (x + dx) / BLOCK_SIZE
                     || y / BLOCK_SIZE != (y + dy) / BLOCK_SIZE);

        md->state.state = MS_WALK;
        map_foreachinmovearea (clif_moboutsight, md->bl.m, x - AREA_SIZE,
                               y - AREA_SIZE, x + AREA_SIZE, y + AREA_SIZE,
                               dx, dy, BL_PC, md);

        x += dx;
        y += dy;
        if (md->min_chase > 13)
            md->min_chase--;

        if (moveblock)
            map_delblock (&md->bl);
        md->bl.x = x;
        md->bl.y = y;
        if (moveblock)
            map_addblock (&md->bl);

        map_foreachinmovearea (clif_mobinsight, md->bl.m, x - AREA_SIZE,
                               y - AREA_SIZE, x + AREA_SIZE, y + AREA_SIZE,
                               -dx, -dy, BL_PC, md);
        md->state.state = MS_IDLE;

        if (md->option & 4)
            skill_check_cloaking (&md->bl);

        skill_unit_move (&md->bl, tick, 1); // Inspection of a skill unit
    }
    if ((i = calc_next_walk_step (md)) > 0)
    {
        i = i >> 1;
        if (i < 1 && md->walkpath.path_half == 0)
            i = 1;
        md->timer =
            add_timer (tick + i, mob_timer, md->bl.id, md->walkpath.path_pos);
        md->state.state = MS_WALK;

        if (md->walkpath.path_pos >= md->walkpath.path_len)
            clif_fixmobpos (md);    // When mob stops, retransmission current of a position.
    }
    return 0;
}

/*==========================================
 * Check if mob should be attempting to attack
 *------------------------------------------
 */
static int mob_check_attack (struct mob_data *md)
{
    struct block_list *tbl = NULL;
    struct map_session_data *tsd = NULL;
    struct mob_data *tmd = NULL;

    int  mode, race, range;

    nullpo_retr (0, md);

    md->min_chase = 13;
    md->state.state = MS_IDLE;
    md->state.skillstate = MSS_IDLE;

    if (md->skilltimer != -1)
        return 0;

    if (md->opt1 > 0 || md->option & 2)
        return 0;

    if (md->sc_data[SC_AUTOCOUNTER].timer != -1)
        return 0;

    if (md->sc_data[SC_BLADESTOP].timer != -1)
        return 0;

    if ((tbl = map_id2bl (md->target_id)) == NULL)
    {
        md->target_id = 0;
        md->state.targettype = NONE_ATTACKABLE;
        return 0;
    }

    if (tbl->type == BL_PC)
        tsd = (struct map_session_data *) tbl;
    else if (tbl->type == BL_MOB)
        tmd = (struct mob_data *) tbl;
    else
        return 0;

    if (tsd)
    {
        if (pc_isdead (tsd) || tsd->invincible_timer != -1
            || pc_isinvisible (tsd) || md->bl.m != tbl->m || tbl->prev == NULL
            || distance (md->bl.x, md->bl.y, tbl->x, tbl->y) >= 13)
        {
            md->target_id = 0;
            md->state.targettype = NONE_ATTACKABLE;
            return 0;
        }
    }
    if (tmd)
    {
        if (md->bl.m != tbl->m || tbl->prev == NULL
            || distance (md->bl.x, md->bl.y, tbl->x, tbl->y) >= 13)
        {
            md->target_id = 0;
            md->state.targettype = NONE_ATTACKABLE;
            return 0;
        }
    }

    if (!md->mode)
        mode = mob_db[md->class].mode;
    else
        mode = md->mode;

    race = mob_db[md->class].race;
    if (!(mode & 0x80))
    {
        md->target_id = 0;
        md->state.targettype = NONE_ATTACKABLE;
        return 0;
    }
    if (tsd && !(mode & 0x20) && (tsd->sc_data[SC_TRICKDEAD].timer != -1 ||
                                  ((pc_ishiding (tsd)
                                    || tsd->state.gangsterparadise)
                                   && race != 4 && race != 6)))
    {
        md->target_id = 0;
        md->state.targettype = NONE_ATTACKABLE;
        return 0;
    }

    range = mob_db[md->class].range;
    if (mode & 1)
        range++;
    if (distance (md->bl.x, md->bl.y, tbl->x, tbl->y) > range)
        return 0;

    return 1;
}

/*==========================================
 * Attack processing of mob
 *------------------------------------------
 */
static int mob_attack (struct mob_data *md, unsigned int tick, int data)
{
    struct block_list *tbl = NULL;

    nullpo_retr (0, md);

    if ((tbl = map_id2bl (md->target_id)) == NULL)
        return 0;

    if (!mob_check_attack (md))
        return 0;

    if (battle_config.monster_attack_direction_change)
        md->dir = map_calc_dir (&md->bl, tbl->x, tbl->y);   // �����ݒ�

    //clif_fixmobpos(md);

    md->state.skillstate = MSS_ATTACK;
    if (mobskill_use (md, tick, -2))    // �X�L���g�p
        return 0;

    md->target_lv = battle_weapon_attack (&md->bl, tbl, tick, 0);

    if (!(battle_config.monster_cloak_check_type & 2)
        && md->sc_data[SC_CLOAKING].timer != -1)
        skill_status_change_end (&md->bl, SC_CLOAKING, -1);

    md->attackabletime = tick + battle_get_adelay (&md->bl);

    md->timer = add_timer (md->attackabletime, mob_timer, md->bl.id, 0);
    md->state.state = MS_ATTACK;

    return 0;
}

/*==========================================
 * The attack of PC which is attacking id is stopped.
 * The callback function of clif_foreachclient
 *------------------------------------------
 */
int mob_stopattacked (struct map_session_data *sd, va_list ap)
{
    int  id;

    nullpo_retr (0, sd);
    nullpo_retr (0, ap);

    id = va_arg (ap, int);
    if (sd->attacktarget == id)
        pc_stopattack (sd);
    return 0;
}

/*==========================================
 * The timer in which the mob's states changes
 *------------------------------------------
 */
int mob_changestate (struct mob_data *md, int state, int type)
{
    unsigned int tick;
    int  i;

    nullpo_retr (0, md);

    if (md->timer != -1)
        delete_timer (md->timer, mob_timer);
    md->timer = -1;
    md->state.state = state;

    switch (state)
    {
        case MS_WALK:
            if ((i = calc_next_walk_step (md)) > 0)
            {
                i = i >> 2;
                md->timer =
                    add_timer (gettick () + i, mob_timer, md->bl.id, 0);
            }
            else
                md->state.state = MS_IDLE;
            break;
        case MS_ATTACK:
            tick = gettick ();
            i = DIFF_TICK (md->attackabletime, tick);
            if (i > 0 && i < 2000)
                md->timer =
                    add_timer (md->attackabletime, mob_timer, md->bl.id, 0);
            else if (type)
            {
                md->attackabletime = tick + battle_get_amotion (&md->bl);
                md->timer =
                    add_timer (md->attackabletime, mob_timer, md->bl.id, 0);
            }
            else
            {
                md->attackabletime = tick + 1;
                md->timer =
                    add_timer (md->attackabletime, mob_timer, md->bl.id, 0);
            }
            break;
        case MS_DELAY:
            md->timer =
                add_timer (gettick () + type, mob_timer, md->bl.id, 0);
            break;
        case MS_DEAD:
            skill_castcancel (&md->bl, 0);
//      mobskill_deltimer(md);
            md->state.skillstate = MSS_DEAD;
            md->last_deadtime = gettick ();
            // Since it died, all aggressors' attack to this mob is stopped.
            clif_foreachclient (mob_stopattacked, md->bl.id);
            skill_unit_out_all (&md->bl, gettick (), 1);
            skill_status_change_clear (&md->bl, 2); // The abnormalities in status are canceled.
            skill_clear_unitgroup (&md->bl);    // All skill unit groups are deleted.
            skill_cleartimerskill (&md->bl);
            if (md->deletetimer != -1)
                delete_timer (md->deletetimer, mob_timer_delete);
            md->deletetimer = -1;
            md->hp = md->target_id = md->attacked_id = 0;
            md->state.targettype = NONE_ATTACKABLE;
            break;
    }

    return 0;
}

/*==========================================
 * timer processing of mob (timer function)
 * It branches to a walk and an attack.
 *------------------------------------------
 */
static int mob_timer (int tid, unsigned int tick, int id, int data)
{
    struct mob_data *md;
    struct block_list *bl;

    if ((bl = map_id2bl (id)) == NULL)
    {                           //�U�����Ă����G���������Ȃ��̂͐���̂悤��
        return 1;
    }

    if (!bl || !bl->type || bl->type != BL_MOB)
        return 1;

    nullpo_retr (1, md = (struct mob_data *) bl);

    if (!md->bl.type || md->bl.type != BL_MOB)
        return 1;

    if (md->timer != tid)
    {
        if (battle_config.error_log == 1)
            printf ("mob_timer %d != %d\n", md->timer, tid);
        return 0;
    }
    md->timer = -1;
    if (md->bl.prev == NULL || md->state.state == MS_DEAD)
        return 1;

    map_freeblock_lock ();
    switch (md->state.state)
    {
        case MS_WALK:
            mob_check_attack (md);
            mob_walk (md, tick, data);
            break;
        case MS_ATTACK:
            mob_attack (md, tick, data);
            break;
        case MS_DELAY:
            mob_changestate (md, MS_IDLE, 0);
            break;
        default:
            if (battle_config.error_log == 1)
                printf ("mob_timer : %d ?\n", md->state.state);
            break;
    }
    map_freeblock_unlock ();
    return 0;
}

/*==========================================
 *
 *------------------------------------------
 */
static int mob_walktoxy_sub (struct mob_data *md)
{
    struct walkpath_data wpd;

    nullpo_retr (0, md);

    if (path_search
        (&wpd, md->bl.m, md->bl.x, md->bl.y, md->to_x, md->to_y,
         md->state.walk_easy))
        return 1;
    memcpy (&md->walkpath, &wpd, sizeof (wpd));

    md->state.change_walk_target = 0;
    mob_changestate (md, MS_WALK, 0);
    clif_movemob (md);

    return 0;
}

/*==========================================
 * mob move start
 *------------------------------------------
 */
int mob_walktoxy (struct mob_data *md, int x, int y, int easy)
{
    struct walkpath_data wpd;

    nullpo_retr (0, md);

    if (md->state.state == MS_WALK
        && path_search (&wpd, md->bl.m, md->bl.x, md->bl.y, x, y, easy))
        return 1;

    md->state.walk_easy = easy;
    md->to_x = x;
    md->to_y = y;
    if (md->state.state == MS_WALK)
    {
        md->state.change_walk_target = 1;
    }
    else
    {
        return mob_walktoxy_sub (md);
    }

    return 0;
}

/*==========================================
 * mob spawn with delay (timer function)
 *------------------------------------------
 */
static int mob_delayspawn (int tid, unsigned int tick, int m, int n)
{
    mob_spawn (m);
    return 0;
}

/*==========================================
 * spawn timing calculation
 *------------------------------------------
 */
int mob_setdelayspawn (int id)
{
    unsigned int spawntime, spawntime1, spawntime2, spawntime3;
    struct mob_data *md;
    struct block_list *bl;

    if ((bl = map_id2bl (id)) == NULL)
        return -1;

    if (!bl || !bl->type || bl->type != BL_MOB)
        return -1;

    nullpo_retr (-1, md = (struct mob_data *) bl);

    if (!md || md->bl.type != BL_MOB)
        return -1;

    // Processing of MOB which is not revitalized
    if (md->spawndelay1 == -1 && md->spawndelay2 == -1 && md->n == 0)
    {
        map_deliddb (&md->bl);
        if (md->lootitem)
        {
            map_freeblock (md->lootitem);
            md->lootitem = NULL;
        }
        map_freeblock (md);     // Instead of [ of free ]
        return 0;
    }

    spawntime1 = md->last_spawntime + md->spawndelay1;
    spawntime2 = md->last_deadtime + md->spawndelay2;
    spawntime3 = gettick () + 5000;
    // spawntime = max(spawntime1,spawntime2,spawntime3);
    if (DIFF_TICK (spawntime1, spawntime2) > 0)
    {
        spawntime = spawntime1;
    }
    else
    {
        spawntime = spawntime2;
    }
    if (DIFF_TICK (spawntime3, spawntime) > 0)
    {
        spawntime = spawntime3;
    }

    add_timer (spawntime, mob_delayspawn, id, 0);
    return 0;
}

/*==========================================
 * Mob spawning. Initialization is also variously here.
 *------------------------------------------
 */
int mob_spawn (int id)
{
    int  x = 0, y = 0, i = 0, c;
    unsigned int tick = gettick ();
    struct mob_data *md;
    struct block_list *bl;

    nullpo_retr (-1, bl = map_id2bl (id));

    if (!bl || !bl->type || bl->type != BL_MOB)
        return -1;

    nullpo_retr (-1, md = (struct mob_data *) bl);

    if (!md || !md->bl.type || md->bl.type != BL_MOB)
        return -1;

    md->last_spawntime = tick;
    if (md->bl.prev != NULL)
    {
//      clif_clearchar_area(&md->bl,3);
        skill_unit_out_all (&md->bl, gettick (), 1);
        map_delblock (&md->bl);
    }
    else
        md->class = md->base_class;

    md->bl.m = md->m;
    do
    {
        if (md->x0 == 0 && md->y0 == 0)
        {
            x = MPRAND (1, (map[md->bl.m].xs - 2));
            y = MPRAND (1, (map[md->bl.m].ys - 2));
        }
        else
        {
            x = MPRAND (md->x0, (md->xs + 1)) - md->xs / 2;
            y = MPRAND (md->y0, (md->ys + 1)) - md->ys / 2;
        }
        i++;
    }
    while (((c = map_getcell (md->bl.m, x, y)) == 1 || c == 5) && i < 50);

    if (i >= 50)
    {
//      if(battle_config.error_log==1)
//          printf("MOB spawn error %d @ %s\n",id,map[md->bl.m].name);
        add_timer (tick + 5000, mob_delayspawn, id, 0);
        return 1;
    }

    md->to_x = md->bl.x = x;
    md->to_y = md->bl.y = y;
    md->dir = 0;

    map_addblock (&md->bl);

    memset (&md->state, 0, sizeof (md->state));
    md->attacked_id = 0;
    md->target_id = 0;
    md->move_fail_count = 0;
    mob_init (md);

    if (!md->stats[MOB_SPEED])
        md->stats[MOB_SPEED] = mob_db[md->class].speed;
    md->def_ele = mob_db[md->class].element;
    md->master_id = 0;
    md->master_dist = 0;

    md->state.state = MS_IDLE;
    md->state.skillstate = MSS_IDLE;
    md->timer = -1;
    md->last_thinktime = tick;
    md->next_walktime = tick + MPRAND (5000, 50);
    md->attackabletime = tick;
    md->canmove_tick = tick;

    md->sg_count = 0;
    md->deletetimer = -1;

    md->skilltimer = -1;
    for (i = 0, c = tick - 1000 * 3600 * 10; i < MAX_MOBSKILL; i++)
        md->skilldelay[i] = c;
    md->skillid = 0;
    md->skilllv = 0;

    memset (md->dmglog, 0, sizeof (md->dmglog));
    if (md->lootitem)
        memset (md->lootitem, 0, sizeof (md->lootitem));
    md->lootitem_count = 0;

    for (i = 0; i < MAX_MOBSKILLTIMERSKILL; i++)
        md->skilltimerskill[i].timer = -1;

    for (i = 0; i < MAX_STATUSCHANGE; i++)
    {
        md->sc_data[i].timer = -1;
        md->sc_data[i].val1 = md->sc_data[i].val2 = md->sc_data[i].val3 =
            md->sc_data[i].val4 = 0;
    }
    md->sc_count = 0;
    md->opt1 = md->opt2 = md->opt3 = md->option = 0;

    memset (md->skillunit, 0, sizeof (md->skillunit));
    memset (md->skillunittick, 0, sizeof (md->skillunittick));

    md->hp = battle_get_max_hp (&md->bl);
    if (md->hp <= 0)
    {
        mob_makedummymobdb (md->class);
        md->hp = battle_get_max_hp (&md->bl);
    }

    clif_spawnmob (md);

    return 0;
}

/*==========================================
 * Distance calculation between two points
 *------------------------------------------
 */
static int distance (int x0, int y0, int x1, int y1)
{
    int  dx, dy;

    dx = abs (x0 - x1);
    dy = abs (y0 - y1);
    return dx > dy ? dx : dy;
}

/*==========================================
 * The stop of MOB's attack
 *------------------------------------------
 */
int mob_stopattack (struct mob_data *md)
{
    md->target_id = 0;
    md->state.targettype = NONE_ATTACKABLE;
    md->attacked_id = 0;
    return 0;
}

/*==========================================
 * The stop of MOB's walking
 *------------------------------------------
 */
int mob_stop_walking (struct mob_data *md, int type)
{
    nullpo_retr (0, md);

    if (md->state.state == MS_WALK || md->state.state == MS_IDLE)
    {
        int  dx = 0, dy = 0;

        md->walkpath.path_len = 0;
        if (type & 4)
        {
            dx = md->to_x - md->bl.x;
            if (dx < 0)
                dx = -1;
            else if (dx > 0)
                dx = 1;
            dy = md->to_y - md->bl.y;
            if (dy < 0)
                dy = -1;
            else if (dy > 0)
                dy = 1;
        }
        md->to_x = md->bl.x + dx;
        md->to_y = md->bl.y + dy;
        if (dx != 0 || dy != 0)
        {
            mob_walktoxy_sub (md);
            return 0;
        }
        mob_changestate (md, MS_IDLE, 0);
    }
    if (type & 0x01)
        clif_fixmobpos (md);
    if (type & 0x02)
    {
        int  delay = battle_get_dmotion (&md->bl);
        unsigned int tick = gettick ();
        if (md->canmove_tick < tick)
            md->canmove_tick = tick + delay;
    }

    return 0;
}

/*==========================================
 * Reachability to a Specification ID existence place
 *------------------------------------------
 */
int mob_can_reach (struct mob_data *md, struct block_list *bl, int range)
{
    int  dx, dy;
    struct walkpath_data wpd;
    int  i;

    nullpo_retr (0, md);
    nullpo_retr (0, bl);

    dx = abs (bl->x - md->bl.x);
    dy = abs (bl->y - md->bl.y);

    //=========== guildcastle guardian no search start===========
    //when players are the guild castle member not attack them !
    if (md->class == 1285 || md->class == 1286 || md->class == 1287)
    {
        struct map_session_data *sd;
        struct guild *g = NULL;
        struct guild_castle *gc = guild_mapname2gc (map[bl->m].name);

        if (gc && agit_flag == 0)   // Guardians will not attack during non-woe time [Valaris]
            return 0;           // end addition [Valaris]

        if (bl && bl->type == BL_PC)
        {
            if ((sd = (struct map_session_data *) bl) == NULL)
            {
                printf ("mob_can_reach nullpo\n");
                return 0;
            }

            if (gc && sd && sd->status.guild_id && sd->status.guild_id > 0)
            {
                g = guild_search (sd->status.guild_id); // don't attack guild members [Valaris]
                if (g && g->guild_id > 0 && g->guild_id == gc->guild_id)
                    return 0;
                if (g && gc && guild_isallied (g, gc))
                    return 0;

            }
        }
    }
    //========== guildcastle guardian no search eof==============

    if (bl && bl->type == BL_PC && battle_config.monsters_ignore_gm == 1)
    {                           // option to have monsters ignore GMs [Valaris]
        struct map_session_data *sd;
        if ((sd = (struct map_session_data *) bl) != NULL && pc_isGM (sd))
            return 0;
    }

    if (md->bl.m != bl->m)      // �Ⴄ��b�v
        return 0;

    if (range > 0 && range < ((dx > dy) ? dx : dy)) // ��������
        return 0;

    if (md->bl.x == bl->x && md->bl.y == bl->y) // ������X
        return 1;

    // Obstacle judging
    wpd.path_len = 0;
    wpd.path_pos = 0;
    wpd.path_half = 0;
    if (path_search (&wpd, md->bl.m, md->bl.x, md->bl.y, bl->x, bl->y, 0) !=
        -1)
        return 1;

    if (bl->type != BL_PC && bl->type != BL_MOB)
        return 0;

    // It judges whether it can adjoin or not.
    dx = (dx > 0) ? 1 : ((dx < 0) ? -1 : 0);
    dy = (dy > 0) ? 1 : ((dy < 0) ? -1 : 0);
    if (path_search
        (&wpd, md->bl.m, md->bl.x, md->bl.y, bl->x - dx, bl->y - dy, 0) != -1)
        return 1;
    for (i = 0; i < 9; i++)
    {
        if (path_search
            (&wpd, md->bl.m, md->bl.x, md->bl.y, bl->x - 1 + i / 3,
             bl->y - 1 + i % 3, 0) != -1)
            return 1;
    }
    return 0;
}

/*==========================================
 * Determination for an attack of a monster
 *------------------------------------------
 */
int mob_target (struct mob_data *md, struct block_list *bl, int dist)
{
    struct map_session_data *sd;
    struct status_change *sc_data;
    short *option;
    int  mode, race;

    nullpo_retr (0, md);
    nullpo_retr (0, bl);

    sc_data = battle_get_sc_data (bl);
    option = battle_get_option (bl);
    race = mob_db[md->class].race;

    if (!md->mode)
    {
        mode = mob_db[md->class].mode;
    }
    else
    {
        mode = md->mode;
    }
    if (!(mode & 0x80))
    {
        md->target_id = 0;
        return 0;
    }
    // Nothing will be carried out if there is no mind of changing TAGE by TAGE ending.
    if ((md->target_id > 0 && md->state.targettype == ATTACKABLE)
        && (!(mode & 0x04) || MRAND (100) > 25))
        return 0;

    if (mode & 0x20 ||          // Coercion is exerted if it is MVPMOB.
        (sc_data && sc_data[SC_TRICKDEAD].timer == -1 &&
         ((option && !(*option & 0x06)) || race == 4 || race == 6)))
    {
        if (bl->type == BL_PC)
        {
            nullpo_retr (0, sd = (struct map_session_data *) bl);
            if (sd->invincible_timer != -1 || pc_isinvisible (sd))
                return 0;
            if (!(mode & 0x20) && race != 4 && race != 6
                && sd->state.gangsterparadise)
                return 0;
        }

        md->target_id = bl->id; // Since there was no disturbance, it locks on to target.
        if (bl->type == BL_PC || bl->type == BL_MOB)
            md->state.targettype = ATTACKABLE;
        else
            md->state.targettype = NONE_ATTACKABLE;
        md->min_chase = dist + 13;
        if (md->min_chase > 26)
            md->min_chase = 26;
    }
    return 0;
}

/*==========================================
 * The ?? routine of an active monster
 *------------------------------------------
 */
static int mob_ai_sub_hard_activesearch (struct block_list *bl, va_list ap)
{
    struct map_session_data *tsd = NULL;
    struct mob_data *smd, *tmd = NULL;
    int  mode, race, dist, *pcc;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, smd = va_arg (ap, struct mob_data *));
    nullpo_retr (0, pcc = va_arg (ap, int *));

    if (bl->type == BL_PC)
        tsd = (struct map_session_data *) bl;
    else if (bl->type == BL_MOB)
        tmd = (struct mob_data *) bl;
    else
        return 0;

    //�G��������
    if (battle_check_target (&smd->bl, bl, BCT_ENEMY) == 0)
        return 0;

    if (!smd->mode)
        mode = mob_db[smd->class].mode;
    else
        mode = smd->mode;

    // �A�N�e�B�u�Ń^�[�Q�b�g�˒����ɂ���Ȃ�A���b�N����
    if (mode & 0x04)
    {
        race = mob_db[smd->class].race;
        //�Ώۂ�PC�̏ꍇ
        if (tsd &&
            !pc_isdead (tsd) &&
            tsd->bl.m == smd->bl.m &&
            tsd->invincible_timer == -1 &&
            !pc_isinvisible (tsd) &&
            (dist =
             distance (smd->bl.x, smd->bl.y, tsd->bl.x, tsd->bl.y)) < 9)
        {
            if (mode & 0x20 ||
                (tsd->sc_data[SC_TRICKDEAD].timer == -1 &&
                 ((!pc_ishiding (tsd) && !tsd->state.gangsterparadise)
                  || race == 4 || race == 6)))
            {                   // �W�Q���Ȃ�������
                if (mob_can_reach (smd, bl, 12) &&  // ���B�”\������
                    MRAND (1000) < 1000 / (++(*pcc)))
                {               // �͈͓�PC�œ��m���ɂ���
                    smd->target_id = tsd->bl.id;
                    smd->state.targettype = ATTACKABLE;
                    smd->min_chase = 13;
                }
            }
        }
        //�Ώۂ�Mob�̏ꍇ
        else if (tmd &&
                 tmd->bl.m == smd->bl.m &&
                 (dist =
                  distance (smd->bl.x, smd->bl.y, tmd->bl.x, tmd->bl.y)) < 9)
        {
            if (mob_can_reach (smd, bl, 12) &&  // ���B�”\������
                MRAND (1000) < 1000 / (++(*pcc)))
            {                   // �͈͓��œ��m���ɂ���
                smd->target_id = bl->id;
                smd->state.targettype = ATTACKABLE;
                smd->min_chase = 13;
            }
        }
    }
    return 0;
}

/*==========================================
 * loot monster item search
 *------------------------------------------
 */
static int mob_ai_sub_hard_lootsearch (struct block_list *bl, va_list ap)
{
    struct mob_data *md;
    int  mode, dist, *itc;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, md = va_arg (ap, struct mob_data *));
    nullpo_retr (0, itc = va_arg (ap, int *));

    if (!md->mode)
    {
        mode = mob_db[md->class].mode;
    }
    else
    {
        mode = md->mode;
    }

    if (!md->target_id && mode & 0x02)
    {
        if (!md->lootitem
            || (battle_config.monster_loot_type == 1
                && md->lootitem_count >= LOOTITEM_SIZE))
            return 0;
        if (bl->m == md->bl.m
            && (dist = distance (md->bl.x, md->bl.y, bl->x, bl->y)) < 9)
        {
            if (mob_can_reach (md, bl, 12) &&   // Reachability judging
                MRAND (1000) < 1000 / (++(*itc)))
            {                   // It is made a probability, such as within the limits PC.
                md->target_id = bl->id;
                md->state.targettype = NONE_ATTACKABLE;
                md->min_chase = 13;
            }
        }
    }
    return 0;
}

/*==========================================
 * The ?? routine of a link monster
 *------------------------------------------
 */
static int mob_ai_sub_hard_linksearch (struct block_list *bl, va_list ap)
{
    struct mob_data *tmd;
    struct mob_data *md;
    struct block_list *target;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, tmd = (struct mob_data *) bl);
    nullpo_retr (0, md = va_arg (ap, struct mob_data *));
    nullpo_retr (0, target = va_arg (ap, struct block_list *));

    // same family free in a range at a link monster -- it will be made to lock if MOB is
/*	if( (md->target_id > 0 && md->state.targettype == ATTACKABLE) && mob_db[md->class].mode&0x08){
		if( tmd->class==md->class && (!tmd->target_id || md->state.targettype == NONE_ATTACKABLE) && tmd->bl.m == md->bl.m){
			if( mob_can_reach(tmd,target,12) ){	// Reachability judging
				tmd->target_id=md->target_id;
				tmd->state.targettype = ATTACKABLE;
				tmd->min_chase=13;
			}
		}
	}*/
    if (md->attacked_id > 0 && mob_db[md->class].mode & 0x08)
    {
        if (tmd->class == md->class && tmd->bl.m == md->bl.m
            && (!tmd->target_id || md->state.targettype == NONE_ATTACKABLE))
        {
            if (mob_can_reach (tmd, target, 12))
            {                   // Reachability judging
                tmd->target_id = md->attacked_id;
                tmd->state.targettype = ATTACKABLE;
                tmd->min_chase = 13;
            }
        }
    }

    return 0;
}

/*==========================================
 * Processing of slave monsters
 *------------------------------------------
 */
static int mob_ai_sub_hard_slavemob (struct mob_data *md, unsigned int tick)
{
    struct mob_data *mmd = NULL;
    struct block_list *bl;
    int  mode, race, old_dist;

    nullpo_retr (0, md);

    if ((bl = map_id2bl (md->master_id)) != NULL)
        mmd = (struct mob_data *) bl;

    mode = mob_db[md->class].mode;

    // It is not main monster/leader.
    if (!mmd || mmd->bl.type != BL_MOB || mmd->bl.id != md->master_id)
        return 0;

    // Since it is in the map on which the master is not, teleport is carried out and it pursues.
    if (mmd->bl.m != md->bl.m)
    {
        mob_warp (md, mmd->bl.m, mmd->bl.x, mmd->bl.y, 3);
        md->state.master_check = 1;
        return 0;
    }

    // Distance with between slave and master is measured.
    old_dist = md->master_dist;
    md->master_dist = distance (md->bl.x, md->bl.y, mmd->bl.x, mmd->bl.y);

    // Since the master was in near immediately before, teleport is carried out and it pursues.
    if (old_dist < 10 && md->master_dist > 18)
    {
        mob_warp (md, -1, mmd->bl.x, mmd->bl.y, 3);
        md->state.master_check = 1;
        return 0;
    }

    // Although there is the master, since it is somewhat far, it approaches.
    if ((!md->target_id || md->state.targettype == NONE_ATTACKABLE)
        && mob_can_move (md)
        && (md->walkpath.path_pos >= md->walkpath.path_len
            || md->walkpath.path_len == 0) && md->master_dist < 15)
    {
        int  i = 0, dx, dy, ret;
        if (md->master_dist > 4)
        {
            do
            {
                if (i <= 5)
                {
                    dx = mmd->bl.x - md->bl.x;
                    dy = mmd->bl.y - md->bl.y;
                    if (dx < 0)
                        dx += (MPRAND (1, ((dx < -3) ? 3 : -dx)));
                    else if (dx > 0)
                        dx -= (MPRAND (1, ((dx > 3) ? 3 : dx)));
                    if (dy < 0)
                        dy += (MPRAND (1, ((dy < -3) ? 3 : -dy)));
                    else if (dy > 0)
                        dy -= (MPRAND (1, ((dy > 3) ? 3 : dy)));
                }
                else
                {
                    dx = mmd->bl.x - md->bl.x + MRAND (7) - 3;
                    dy = mmd->bl.y - md->bl.y + MRAND (7) - 3;
                }

                ret = mob_walktoxy (md, md->bl.x + dx, md->bl.y + dy, 0);
                i++;
            }
            while (ret && i < 10);
        }
        else
        {
            do
            {
                dx = MRAND (9) - 5;
                dy = MRAND (9) - 5;
                if (dx == 0 && dy == 0)
                {
                    dx = (MRAND (1)) ? 1 : -1;
                    dy = (MRAND (1)) ? 1 : -1;
                }
                dx += mmd->bl.x;
                dy += mmd->bl.y;

                ret = mob_walktoxy (md, mmd->bl.x + dx, mmd->bl.y + dy, 0);
                i++;
            }
            while (ret && i < 10);
        }

        md->next_walktime = tick + 500;
        md->state.master_check = 1;
    }

    // There is the master, the master locks a target and he does not lock.
    if ((mmd->target_id > 0 && mmd->state.targettype == ATTACKABLE)
        && (!md->target_id || md->state.targettype == NONE_ATTACKABLE))
    {
        struct map_session_data *sd = map_id2sd (mmd->target_id);
        if (sd != NULL && !pc_isdead (sd) && sd->invincible_timer == -1
            && !pc_isinvisible (sd))
        {

            race = mob_db[md->class].race;
            if (mode & 0x20 ||
                (sd->sc_data[SC_TRICKDEAD].timer == -1 &&
                 ((!pc_ishiding (sd) && !sd->state.gangsterparadise)
                  || race == 4 || race == 6)))
            {                   // �W�Q���Ȃ�������

                md->target_id = sd->bl.id;
                md->state.targettype = ATTACKABLE;
                md->min_chase =
                    5 + distance (md->bl.x, md->bl.y, sd->bl.x, sd->bl.y);
                md->state.master_check = 1;
            }
        }
    }

    // There is the master, the master locks a target and he does not lock.
/*	if( (md->target_id>0 && mmd->state.targettype == ATTACKABLE) && (!mmd->target_id || mmd->state.targettype == NONE_ATTACKABLE) ){
		struct map_session_data *sd=map_id2sd(md->target_id);
		if(sd!=NULL && !pc_isdead(sd) && sd->invincible_timer == -1 && !pc_isinvisible(sd)){

			race=mob_db[mmd->class].race;
			if(mode&0x20 ||
				(sd->sc_data[SC_TRICKDEAD].timer == -1 &&
				(!(sd->status.option&0x06) || race==4 || race==6)
				) ){	// It judges whether there is any disturbance.

				mmd->target_id=sd->bl.id;
				mmd->state.targettype = ATTACKABLE;
				mmd->min_chase=5+distance(mmd->bl.x,mmd->bl.y,sd->bl.x,sd->bl.y);
			}
		}
	}*/

    return 0;
}

/*==========================================
 * A lock of target is stopped and mob moves to a standby state.
 *------------------------------------------
 */
static int mob_unlocktarget (struct mob_data *md, int tick)
{
    nullpo_retr (0, md);

    md->target_id = 0;
    md->state.targettype = NONE_ATTACKABLE;
    md->state.skillstate = MSS_IDLE;
    md->next_walktime = tick + MPRAND (3000, 3000);
    return 0;
}

/*==========================================
 * Random walk
 *------------------------------------------
 */
static int mob_randomwalk (struct mob_data *md, int tick)
{
    const int retrycount = 20;
    int  speed;

    nullpo_retr (0, md);

    speed = battle_get_speed (&md->bl);
    if (DIFF_TICK (md->next_walktime, tick) < 0)
    {
        int  i, x, y, c, d = 12 - md->move_fail_count;
        if (d < 5)
            d = 5;
        for (i = 0; i < retrycount; i++)
        {                       // Search of a movable place
            int  r = mt_random ();
            x = md->bl.x + r % (d * 2 + 1) - d;
            y = md->bl.y + r / (d * 2 + 1) % (d * 2 + 1) - d;
            if ((c = map_getcell (md->bl.m, x, y)) != 1 && c != 5
                && mob_walktoxy (md, x, y, 1) == 0)
            {
                md->move_fail_count = 0;
                break;
            }
            if (i + 1 >= retrycount)
            {
                md->move_fail_count++;
                if (md->move_fail_count > 1000)
                {
                    if (battle_config.error_log == 1)
                        printf
                            ("MOB cant move. random spawn %d, class = %d\n",
                             md->bl.id, md->class);
                    md->move_fail_count = 0;
                    mob_spawn (md->bl.id);
                }
            }
        }
        for (i = c = 0; i < md->walkpath.path_len; i++)
        {                       // The next walk start time is calculated.
            if (md->walkpath.path[i] & 1)
                c += speed * 14 / 10;
            else
                c += speed;
        }
        md->next_walktime = tick + MPRAND (3000, 3000) + c;
        md->state.skillstate = MSS_WALK;
        return 1;
    }
    return 0;
}

/*==========================================
 * AI of MOB whose is near a Player
 *------------------------------------------
 */
static int mob_ai_sub_hard (struct block_list *bl, va_list ap)
{
    struct mob_data *md, *tmd = NULL;
    struct map_session_data *tsd = NULL;
    struct block_list *tbl = NULL;
    struct flooritem_data *fitem;
    unsigned int tick;
    int  i, dx, dy, ret, dist;
    int  attack_type = 0;
    int  mode, race;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, md = (struct mob_data *) bl);

    tick = va_arg (ap, unsigned int);

    if (DIFF_TICK (tick, md->last_thinktime) < MIN_MOBTHINKTIME)
        return 0;
    md->last_thinktime = tick;

    if (md->skilltimer != -1 || md->bl.prev == NULL)
    {                           // Under a skill aria and death
        if (DIFF_TICK (tick, md->next_walktime) > MIN_MOBTHINKTIME)
            md->next_walktime = tick;
        return 0;
    }

    if (!md->mode)
        mode = mob_db[md->class].mode;
    else
        mode = md->mode;

    race = mob_db[md->class].race;

    // Abnormalities
    if ((md->opt1 > 0 && md->opt1 != 6) || md->state.state == MS_DELAY
        || md->sc_data[SC_BLADESTOP].timer != -1)
        return 0;

    if (!(mode & 0x80) && md->target_id > 0)
        md->target_id = 0;

    if (md->attacked_id > 0 && mode & 0x08)
    {                           // Link monster
        struct map_session_data *asd = map_id2sd (md->attacked_id);
        if (asd)
        {
            if (asd->invincible_timer == -1 && !pc_isinvisible (asd))
            {
                map_foreachinarea (mob_ai_sub_hard_linksearch, md->bl.m,
                                   md->bl.x - 13, md->bl.y - 13,
                                   md->bl.x + 13, md->bl.y + 13,
                                   BL_MOB, md, &asd->bl);
            }
        }
    }

    // It checks to see it was attacked first (if active, it is target change at 25% of probability).
    if (mode > 0 && md->attacked_id > 0
        && (!md->target_id || md->state.targettype == NONE_ATTACKABLE
            || (mode & 0x04 && MRAND (100) < 25)))
    {
        struct block_list *abl = map_id2bl (md->attacked_id);
        struct map_session_data *asd = NULL;
        if (abl)
        {
            if (abl->type == BL_PC)
                asd = (struct map_session_data *) abl;
            if (asd == NULL || md->bl.m != abl->m || abl->prev == NULL
                || asd->invincible_timer != -1 || pc_isinvisible (asd)
                || (dist =
                    distance (md->bl.x, md->bl.y, abl->x, abl->y)) >= 32
                || battle_check_target (bl, abl, BCT_ENEMY) == 0)
                md->attacked_id = 0;
            else
            {
                md->target_id = md->attacked_id;    // set target
                md->state.targettype = ATTACKABLE;
                attack_type = 1;
                md->attacked_id = 0;
                md->min_chase = dist + 13;
                if (md->min_chase > 26)
                    md->min_chase = 26;
            }
        }
    }

    md->state.master_check = 0;
    // Processing of slave monster
    if (md->master_id > 0 && md->state.special_mob_ai == 0)
        mob_ai_sub_hard_slavemob (md, tick);

    // �A�N�e�B�������X�^�[�̍��G (?? of a bitter taste TIVU monster)
    if ((!md->target_id || md->state.targettype == NONE_ATTACKABLE)
        && mode & 0x04 && !md->state.master_check
        && battle_config.monster_active_enable == 1)
    {
        i = 0;
        if (md->state.special_mob_ai)
        {
            map_foreachinarea (mob_ai_sub_hard_activesearch, md->bl.m,
                               md->bl.x - AREA_SIZE * 2,
                               md->bl.y - AREA_SIZE * 2,
                               md->bl.x + AREA_SIZE * 2,
                               md->bl.y + AREA_SIZE * 2, 0, md, &i);
        }
        else
        {
            map_foreachinarea (mob_ai_sub_hard_activesearch, md->bl.m,
                               md->bl.x - AREA_SIZE * 2,
                               md->bl.y - AREA_SIZE * 2,
                               md->bl.x + AREA_SIZE * 2,
                               md->bl.y + AREA_SIZE * 2, BL_PC, md, &i);
        }
    }

    // The item search of a route monster
    if (!md->target_id && mode & 0x02 && !md->state.master_check)
    {
        i = 0;
        map_foreachinarea (mob_ai_sub_hard_lootsearch, md->bl.m,
                           md->bl.x - AREA_SIZE * 2, md->bl.y - AREA_SIZE * 2,
                           md->bl.x + AREA_SIZE * 2, md->bl.y + AREA_SIZE * 2,
                           BL_ITEM, md, &i);
    }

    // It will attack, if the candidate for an attack is.
    if (md->target_id > 0)
    {
        if ((tbl = map_id2bl (md->target_id)))
        {
            if (tbl->type == BL_PC)
                tsd = (struct map_session_data *) tbl;
            else if (tbl->type == BL_MOB)
                tmd = (struct mob_data *) tbl;
            if (tsd || tmd)
            {
                if (tbl->m != md->bl.m || tbl->prev == NULL
                    || (dist =
                        distance (md->bl.x, md->bl.y, tbl->x,
                                  tbl->y)) >= md->min_chase)
                    mob_unlocktarget (md, tick);    // �ʃ}�b�v���A���E�O
                else if (tsd && !(mode & 0x20)
                         && (tsd->sc_data[SC_TRICKDEAD].timer != -1
                             ||
                             ((pc_ishiding (tsd)
                               || tsd->state.gangsterparadise) && race != 4
                              && race != 6)))
                    mob_unlocktarget (md, tick);    // �X�L���Ȃǂɂ����G�W�Q
                else if (!battle_check_range
                         (&md->bl, tbl, mob_db[md->class].range))
                {
                    // �U���͈͊O�Ȃ̂ňړ�
                    if (!(mode & 1))
                    {           // �ړ����Ȃ����[�h
                        mob_unlocktarget (md, tick);
                        return 0;
                    }
                    if (!mob_can_move (md)) // �����Ȃ���Ԃɂ���
                        return 0;
                    md->state.skillstate = MSS_CHASE;   // �ˌ����X�L��
                    mobskill_use (md, tick, -1);
//                  if(md->timer != -1 && (DIFF_TICK(md->next_walktime,tick)<0 || distance(md->to_x,md->to_y,tsd->bl.x,tsd->bl.y)<2) )
                    if (md->timer != -1 && md->state.state != MS_ATTACK
                        && (DIFF_TICK (md->next_walktime, tick) < 0
                            || distance (md->to_x, md->to_y, tbl->x,
                                         tbl->y) < 2))
                        return 0;   // ���Ɉړ���
                    if (!mob_can_reach
                        (md, tbl, (md->min_chase > 13) ? md->min_chase : 13))
                        mob_unlocktarget (md, tick);    // �ړ��ł��Ȃ��̂Ń^�Q�����iIW�Ƃ��H�j
                    else
                    {
                        // �ǐ�
                        md->next_walktime = tick + 500;
                        i = 0;
                        do
                        {
                            if (i == 0)
                            {   // �ŏ���AEGIS�Ɠ������@�Ō���
                                dx = tbl->x - md->bl.x;
                                dy = tbl->y - md->bl.y;
                                if (dx < 0)
                                    dx++;
                                else if (dx > 0)
                                    dx--;
                                if (dy < 0)
                                    dy++;
                                else if (dy > 0)
                                    dy--;
                            }
                            else
                            {   // ���߂Ȃ�Athena��(�����_��)
                                dx = tbl->x - md->bl.x + MRAND (3) - 1;
                                dy = tbl->y - md->bl.y + MRAND (3) - 1;
                            }
                            /*                      if(path_search(&md->walkpath,md->bl.m,md->bl.x,md->bl.y,md->bl.x+dx,md->bl.y+dy,0)){
                             * dx=tsd->bl.x - md->bl.x;
                             * dy=tsd->bl.y - md->bl.y;
                             * if(dx<0) dx--;
                             * else if(dx>0) dx++;
                             * if(dy<0) dy--;
                             * else if(dy>0) dy++;
                             * } */
                            ret =
                                mob_walktoxy (md, md->bl.x + dx,
                                              md->bl.y + dy, 0);
                            i++;
                        }
                        while (ret && i < 5);

                        if (ret)
                        {       // �ړ��s�”\�ȏ�����̍U���Ȃ�2������
                            if (dx < 0)
                                dx = 2;
                            else if (dx > 0)
                                dx = -2;
                            if (dy < 0)
                                dy = 2;
                            else if (dy > 0)
                                dy = -2;
                            mob_walktoxy (md, md->bl.x + dx, md->bl.y + dy,
                                          0);
                        }
                    }
                }
                else
                {               // �U���˒��͈͓�
                    md->state.skillstate = MSS_ATTACK;
                    if (md->state.state == MS_WALK)
                        mob_stop_walking (md, 1);   // ���s���Ȃ��~
                    if (md->state.state == MS_ATTACK)
                        return 0;   // ���ɍU����
                    mob_changestate (md, MS_ATTACK, attack_type);

/*					if(mode&0x08){	// �����N�����X�^�[
					map_foreachinarea(mob_ai_sub_hard_linksearch,md->bl.m,
						md->bl.x-13,md->bl.y-13,
						md->bl.x+13,md->bl.y+13,
							BL_MOB,md,&tsd->bl);
				}*/
                }
                return 0;
            }
            else
            {                   // ���[�g�����X�^�[����
                if (tbl == NULL || tbl->type != BL_ITEM || tbl->m != md->bl.m
                    || (dist =
                        distance (md->bl.x, md->bl.y, tbl->x,
                                  tbl->y)) >= md->min_chase || !md->lootitem)
                {
                    // �������邩�A�C�e�����Ȃ��Ȃ���
                    mob_unlocktarget (md, tick);
                    if (md->state.state == MS_WALK)
                        mob_stop_walking (md, 1);   // ���s���Ȃ��~
                }
                else if (dist)
                {
                    if (!(mode & 1))
                    {           // �ړ����Ȃ����[�h
                        mob_unlocktarget (md, tick);
                        return 0;
                    }
                    if (!mob_can_move (md)) // �����Ȃ���Ԃɂ���
                        return 0;
                    md->state.skillstate = MSS_LOOT;    // ���[�g���X�L���g�p
                    mobskill_use (md, tick, -1);
//                  if(md->timer != -1 && (DIFF_TICK(md->next_walktime,tick)<0 || distance(md->to_x,md->to_y,tbl->x,tbl->y)<2) )
                    if (md->timer != -1 && md->state.state != MS_ATTACK
                        && (DIFF_TICK (md->next_walktime, tick) < 0
                            || distance (md->to_x, md->to_y, tbl->x,
                                         tbl->y) <= 0))
                        return 0;   // ���Ɉړ���
                    md->next_walktime = tick + 500;
                    dx = tbl->x - md->bl.x;
                    dy = tbl->y - md->bl.y;
/*				if(path_search(&md->walkpath,md->bl.m,md->bl.x,md->bl.y,md->bl.x+dx,md->bl.y+dy,0)){
						dx=tbl->x - md->bl.x;
						dy=tbl->y - md->bl.y;
				}*/
                    ret = mob_walktoxy (md, md->bl.x + dx, md->bl.y + dy, 0);
                    if (ret)
                        mob_unlocktarget (md, tick);    // �ړ��ł��Ȃ��̂Ń^�Q�����iIW�Ƃ��H�j
                }
                else
                {               // �A�C�e���܂ł��ǂ蒅����
                    if (md->state.state == MS_ATTACK)
                        return 0;   // �U����
                    if (md->state.state == MS_WALK)
                        mob_stop_walking (md, 1);   // ���s���Ȃ��~
                    fitem = (struct flooritem_data *) tbl;
                    if (md->lootitem_count < LOOTITEM_SIZE)
                        memcpy (&md->lootitem[md->lootitem_count++],
                                &fitem->item_data, sizeof (md->lootitem[0]));
                    else if (battle_config.monster_loot_type == 1
                             && md->lootitem_count >= LOOTITEM_SIZE)
                    {
                        mob_unlocktarget (md, tick);
                        return 0;
                    }
                    else
                    {
                        for (i = 0; i < LOOTITEM_SIZE - 1; i++)
                            memcpy (&md->lootitem[i], &md->lootitem[i + 1],
                                    sizeof (md->lootitem[0]));
                        memcpy (&md->lootitem[LOOTITEM_SIZE - 1],
                                &fitem->item_data, sizeof (md->lootitem[0]));
                    }
                    map_clearflooritem (tbl->id);
                    mob_unlocktarget (md, tick);
                }
                return 0;
            }
        }
        else
        {
            mob_unlocktarget (md, tick);
            if (md->state.state == MS_WALK)
                mob_stop_walking (md, 4);   // ���s���Ȃ��~
            return 0;
        }
    }

    // It is skill use at the time of /standby at the time of a walk.
    if (mobskill_use (md, tick, -1))
        return 0;

    // ���s����
    if (mode & 1 && mob_can_move (md) &&    // �ړ��”\MOB&�������Ԃɂ���
        (md->master_id == 0 || md->state.special_mob_ai
         || md->master_dist > 10))
    {                           //��芪��MOB����Ȃ�

        if (DIFF_TICK (md->next_walktime, tick) > +7000 &&
            (md->walkpath.path_len == 0
             || md->walkpath.path_pos >= md->walkpath.path_len))
        {
            md->next_walktime = tick + 3000 * MRAND (2000);
        }

        // Random movement
        if (mob_randomwalk (md, tick))
            return 0;
    }

    // Since he has finished walking, it stands by.
    if (md->walkpath.path_len == 0
        || md->walkpath.path_pos >= md->walkpath.path_len)
        md->state.skillstate = MSS_IDLE;
    return 0;
}

/*==========================================
 * Serious processing for mob in PC field of view (foreachclient)
 *------------------------------------------
 */
static int mob_ai_sub_foreachclient (struct map_session_data *sd, va_list ap)
{
    unsigned int tick;
    nullpo_retr (0, sd);
    nullpo_retr (0, ap);

    tick = va_arg (ap, unsigned int);
    map_foreachinarea (mob_ai_sub_hard, sd->bl.m,
                       sd->bl.x - AREA_SIZE * 2, sd->bl.y - AREA_SIZE * 2,
                       sd->bl.x + AREA_SIZE * 2, sd->bl.y + AREA_SIZE * 2,
                       BL_MOB, tick);

    return 0;
}

/*==========================================
 * Serious processing for mob in PC field of view   (interval timer function)
 *------------------------------------------
 */
static int mob_ai_hard (int tid, unsigned int tick, int id, int data)
{
    clif_foreachclient (mob_ai_sub_foreachclient, tick);

    return 0;
}

/*==========================================
 * Negligent mode MOB AI (PC is not in near)
 *------------------------------------------
 */
static int mob_ai_sub_lazy (void *key, void *data, va_list app)
{
    struct mob_data *md = data;
    unsigned int tick;
    va_list ap;

    nullpo_retr (0, md);
    nullpo_retr (0, app);
    nullpo_retr (0, ap = va_arg (app, va_list));

    if (md == NULL)
        return 0;

    if (!md->bl.type || md->bl.type != BL_MOB)
        return 0;

    tick = va_arg (ap, unsigned int);

    if (DIFF_TICK (tick, md->last_thinktime) < MIN_MOBTHINKTIME * 10)
        return 0;
    md->last_thinktime = tick;

    if (md->bl.prev == NULL || md->skilltimer != -1)
    {
        if (DIFF_TICK (tick, md->next_walktime) > MIN_MOBTHINKTIME * 10)
            md->next_walktime = tick;
        return 0;
    }

    if (DIFF_TICK (md->next_walktime, tick) < 0 &&
        (mob_db[md->class].mode & 1) && mob_can_move (md))
    {

        if (map[md->bl.m].users > 0)
        {
            // Since PC is in the same map, somewhat better negligent processing is carried out.

            // It sometimes moves.
            if (MRAND (1000) < MOB_LAZYMOVEPERC)
                mob_randomwalk (md, tick);

            // MOB which is not not the summons MOB but BOSS, either sometimes reboils.
            else if (MRAND (1000) < MOB_LAZYWARPPERC && md->x0 <= 0
                     && md->master_id != 0 && mob_db[md->class].mexp <= 0
                     && !(mob_db[md->class].mode & 0x20))
                mob_spawn (md->bl.id);

        }
        else
        {
            // Since PC is not even in the same map, suitable processing is carried out even if it takes.

            // MOB which is not BOSS which is not Summons MOB, either -- a case -- sometimes -- leaping
            if (MRAND (1000) < MOB_LAZYWARPPERC && md->x0 <= 0
                && md->master_id != 0 && mob_db[md->class].mexp <= 0
                && !(mob_db[md->class].mode & 0x20))
                mob_warp (md, -1, -1, -1, -1);
        }

        md->next_walktime = tick + MPRAND (5000, 10000);
    }
    return 0;
}

/*==========================================
 * Negligent processing for mob outside PC field of view   (interval timer function)
 *------------------------------------------
 */
static int mob_ai_lazy (int tid, unsigned int tick, int id, int data)
{
    map_foreachiddb (mob_ai_sub_lazy, tick);

    return 0;
}

/*==========================================
 * The structure object for item drop with delay
 * Since it is only two being able to pass [ int ] a timer function
 * Data is put in and passed to this structure object.
 *------------------------------------------
 */
struct delay_item_drop
{
    int  m, x, y;
    int  nameid, amount;
    struct map_session_data *first_sd, *second_sd, *third_sd;
};

struct delay_item_drop2
{
    int  m, x, y;
    struct item item_data;
    struct map_session_data *first_sd, *second_sd, *third_sd;
};

/*==========================================
 * item drop with delay (timer function)
 *------------------------------------------
 */
static int mob_delay_item_drop (int tid, unsigned int tick, int id, int data)
{
    struct delay_item_drop *ditem;
    struct item temp_item;
    int  flag;

    nullpo_retr (0, ditem = (struct delay_item_drop *) id);

    memset (&temp_item, 0, sizeof (temp_item));
    temp_item.nameid = ditem->nameid;
    temp_item.amount = ditem->amount;
    temp_item.identify = !itemdb_isequip3 (temp_item.nameid);

    if (battle_config.item_auto_get == 1)
    {
        if (ditem->first_sd
            && (flag =
                pc_additem (ditem->first_sd, &temp_item, ditem->amount)))
        {
            clif_additem (ditem->first_sd, 0, 0, flag);
            map_addflooritem (&temp_item, 1, ditem->m, ditem->x, ditem->y,
                              ditem->first_sd, ditem->second_sd,
                              ditem->third_sd, 0);
        }
        free (ditem);
        return 0;
    }

    map_addflooritem (&temp_item, 1, ditem->m, ditem->x, ditem->y,
                      ditem->first_sd, ditem->second_sd, ditem->third_sd, 0);

    free (ditem);
    return 0;
}

/*==========================================
 * item drop (timer function)-lootitem with delay
 *------------------------------------------
 */
static int mob_delay_item_drop2 (int tid, unsigned int tick, int id, int data)
{
    struct delay_item_drop2 *ditem;
    int  flag;

    nullpo_retr (0, ditem = (struct delay_item_drop2 *) id);

    if (battle_config.item_auto_get == 1)
    {
        if (ditem->first_sd
            && (flag =
                pc_additem (ditem->first_sd, &ditem->item_data,
                            ditem->item_data.amount)))
        {
            clif_additem (ditem->first_sd, 0, 0, flag);
            map_addflooritem (&ditem->item_data, ditem->item_data.amount,
                              ditem->m, ditem->x, ditem->y, ditem->first_sd,
                              ditem->second_sd, ditem->third_sd, 0);
        }
        free (ditem);
        return 0;
    }

    map_addflooritem (&ditem->item_data, ditem->item_data.amount, ditem->m,
                      ditem->x, ditem->y, ditem->first_sd, ditem->second_sd,
                      ditem->third_sd, 0);

    free (ditem);
    return 0;
}

/*==========================================
 * mob data is erased.
 *------------------------------------------
 */
int mob_delete (struct mob_data *md)
{
    nullpo_retr (1, md);

    if (md->bl.prev == NULL)
        return 1;
    mob_changestate (md, MS_DEAD, 0);
    clif_clearchar_area (&md->bl, 1);
    map_delblock (&md->bl);
    if (mob_get_viewclass (md->class) <= 1000)
        clif_clearchar_delay (gettick () + 3000, &md->bl, 0);
    mob_deleteslave (md);
    mob_setdelayspawn (md->bl.id);
    return 0;
}

int mob_catch_delete (struct mob_data *md, int type)
{
    nullpo_retr (1, md);

    if (md->bl.prev == NULL)
        return 1;
    mob_changestate (md, MS_DEAD, 0);
    clif_clearchar_area (&md->bl, type);
    map_delblock (&md->bl);
    mob_setdelayspawn (md->bl.id);
    return 0;
}

int mob_timer_delete (int tid, unsigned int tick, int id, int data)
{
    struct block_list *bl = map_id2bl (id);
    struct mob_data *md;

    nullpo_retr (0, bl);

    md = (struct mob_data *) bl;
    mob_catch_delete (md, 3);
    return 0;
}

/*==========================================
 *
 *------------------------------------------
 */
int mob_deleteslave_sub (struct block_list *bl, va_list ap)
{
    struct mob_data *md;
    int  id;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, md = (struct mob_data *) bl);

    id = va_arg (ap, int);
    if (md->master_id > 0 && md->master_id == id)
        mob_damage (NULL, md, md->hp, 1);
    return 0;
}

/*==========================================
 *
 *------------------------------------------
 */
int mob_deleteslave (struct mob_data *md)
{
    nullpo_retr (0, md);

    map_foreachinarea (mob_deleteslave_sub, md->bl.m,
                       0, 0, map[md->bl.m].xs, map[md->bl.m].ys,
                       BL_MOB, md->bl.id);
    return 0;
}

#define DAMAGE_BONUS_COUNT 6    // max. number of players to account for
const static double damage_bonus_factor[DAMAGE_BONUS_COUNT + 1] = {
    1.0, 1.0, 2.0, 2.5, 2.75, 2.9, 3.0
};

/*==========================================
 * It is the damage of sd to damage to md.
 *------------------------------------------
 */
int mob_damage (struct block_list *src, struct mob_data *md, int damage,
                int type)
{
    int  i, count, minpos, mindmg;
    struct map_session_data *sd = NULL, *tmpsd[DAMAGELOG_SIZE];
    struct
    {
        struct party *p;
        int  id, base_exp, job_exp;
    } pt[DAMAGELOG_SIZE];
    int  pnum = 0;
    int  mvp_damage, max_hp;
    unsigned int tick = gettick ();
    struct map_session_data *mvp_sd = NULL, *second_sd = NULL, *third_sd =
        NULL;
    double dmg_rate, tdmg, temp;
    struct item item;
    int  ret;
    int  drop_rate;
    int  skill, sp;

    nullpo_retr (0, md);        //src��NULL�ŌĂ΂��ꍇ������̂ŁA���Ń`�F�b�N

    if (src && src->id == md->master_id
        && md->mode & MOB_MODE_TURNS_AGAINST_BAD_MASTER)
    {
        /* If the master hits a monster, have the monster turn against him */
        md->master_id = 0;
        md->mode = 0x85;        /* Regular war mode */
        md->target_id = src->id;
        md->attacked_id = src->id;
    }

    max_hp = battle_get_max_hp (&md->bl);

    if (src && src->type == BL_PC)
    {
        sd = (struct map_session_data *) src;
        mvp_sd = sd;
    }

//  if(battle_config.battle_log)
//      printf("mob_damage %d %d %d\n",md->hp,max_hp,damage);
    if (md->bl.prev == NULL)
    {
        if (battle_config.error_log == 1)
            printf ("mob_damage : BlockError!!\n");
        return 0;
    }

    if (md->state.state == MS_DEAD || md->hp <= 0)
    {
        if (md->bl.prev != NULL)
        {
            mob_changestate (md, MS_DEAD, 0);
            mobskill_use (md, tick, -1);    // It is skill at the time of death.
            clif_clearchar_area (&md->bl, 1);
            map_delblock (&md->bl);
            mob_setdelayspawn (md->bl.id);
        }
        return 0;
    }

    if (md->sc_data[SC_ENDURE].timer == -1)
        mob_stop_walking (md, 3);
    if (damage > max_hp >> 2)
        skill_stop_dancing (&md->bl, 0);

    if (md->hp > max_hp)
        md->hp = max_hp;

    // The amount of overkill rounds to hp.
    if (damage > md->hp)
        damage = md->hp;

    if (!(type & 2))
    {
        if (sd != NULL)
        {
            for (i = 0, minpos = 0, mindmg = 0x7fffffff; i < DAMAGELOG_SIZE;
                 i++)
            {
                if (md->dmglog[i].id == sd->bl.id)
                    break;
                if (md->dmglog[i].id == 0)
                {
                    minpos = i;
                    mindmg = 0;
                }
                else if (md->dmglog[i].dmg < mindmg)
                {
                    minpos = i;
                    mindmg = md->dmglog[i].dmg;
                }
            }
            if (i < DAMAGELOG_SIZE)
                md->dmglog[i].dmg += damage;
            else
            {
                md->dmglog[minpos].id = sd->bl.id;
                md->dmglog[minpos].dmg = damage;
            }

            if (md->attacked_id <= 0 && md->state.special_mob_ai == 0)
                md->attacked_id = sd->bl.id;
        }
        if (src && src->type == BL_MOB
            && ((struct mob_data *) src)->state.special_mob_ai)
        {
            struct mob_data *md2 = (struct mob_data *) src;
            struct block_list *master_bl = map_id2bl (md2->master_id);
            if (master_bl && master_bl->type == BL_PC)
            {
                MAP_LOG_PC (((struct map_session_data *) master_bl),
                            "MOB-TO-MOB-DMG FROM MOB%d %d TO MOB%d %d FOR %d",
                            md2->bl.id, md2->class, md->bl.id, md->class,
                            damage);
            }

            nullpo_retr (0, md2);
            for (i = 0, minpos = 0, mindmg = 0x7fffffff; i < DAMAGELOG_SIZE;
                 i++)
            {
                if (md->dmglog[i].id == md2->master_id)
                    break;
                if (md->dmglog[i].id == 0)
                {
                    minpos = i;
                    mindmg = 0;
                }
                else if (md->dmglog[i].dmg < mindmg)
                {
                    minpos = i;
                    mindmg = md->dmglog[i].dmg;
                }
            }
            if (i < DAMAGELOG_SIZE)
                md->dmglog[i].dmg += damage;
            else
            {
                md->dmglog[minpos].id = md2->master_id;
                md->dmglog[minpos].dmg = damage;

                if (md->attacked_id <= 0 && md->state.special_mob_ai == 0)
                    md->attacked_id = md2->master_id;
            }
        }

    }

    md->hp -= damage;

    if (md->class >= 1285 && md->class <= 1287)
    {                           // guardian hp update [Valaris]
        struct guild_castle *gc = guild_mapname2gc (map[md->bl.m].name);
        if (gc)
        {

            if (md->bl.id == gc->GID0)
            {
                gc->Ghp0 = md->hp;
                if (gc->Ghp0 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 10, 0);
                    guild_castledatasave (gc->castle_id, 18, 0);
                }
            }
            if (md->bl.id == gc->GID1)
            {
                gc->Ghp1 = md->hp;
                if (gc->Ghp1 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 11, 0);
                    guild_castledatasave (gc->castle_id, 19, 0);
                }
            }
            if (md->bl.id == gc->GID2)
            {
                gc->Ghp2 = md->hp;
                if (gc->Ghp2 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 12, 0);
                    guild_castledatasave (gc->castle_id, 20, 0);
                }
            }
            if (md->bl.id == gc->GID3)
            {
                gc->Ghp3 = md->hp;
                if (gc->Ghp3 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 13, 0);
                    guild_castledatasave (gc->castle_id, 21, 0);
                }
            }
            if (md->bl.id == gc->GID4)
            {
                gc->Ghp4 = md->hp;
                if (gc->Ghp4 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 14, 0);
                    guild_castledatasave (gc->castle_id, 22, 0);
                }
            }
            if (md->bl.id == gc->GID5)
            {
                gc->Ghp5 = md->hp;
                if (gc->Ghp5 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 15, 0);
                    guild_castledatasave (gc->castle_id, 23, 0);
                }
            }
            if (md->bl.id == gc->GID6)
            {
                gc->Ghp6 = md->hp;
                if (gc->Ghp6 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 16, 0);
                    guild_castledatasave (gc->castle_id, 24, 0);
                }
            }
            if (md->bl.id == gc->GID7)
            {
                gc->Ghp7 = md->hp;
                if (gc->Ghp7 <= 0)
                {
                    guild_castledatasave (gc->castle_id, 17, 0);
                    guild_castledatasave (gc->castle_id, 25, 0);

                }
            }
        }
    }                           // end addition [Valaris]

    if (md->option & 2)
        skill_status_change_end (&md->bl, SC_HIDING, -1);
    if (md->option & 4)
        skill_status_change_end (&md->bl, SC_CLOAKING, -1);

    if (md->state.special_mob_ai == 2)
    {                           //�X�t�B�A�[�}�C��
        int  skillidx = 0;

        if ((skillidx =
             mob_skillid2skillidx (md->class, NPC_SELFDESTRUCTION2)) >= 0)
        {
            md->mode |= 0x1;
            md->next_walktime = tick;
            mobskill_use_id (md, &md->bl, skillidx);    //�����r���J�n
            md->state.special_mob_ai++;
        }
    }

    if (md->hp > 0)
    {
        return 0;
    }

    MAP_LOG ("MOB%d DEAD", md->bl.id);

    // ----- �������玀�S���� -----

    map_freeblock_lock ();
    mob_changestate (md, MS_DEAD, 0);
    mobskill_use (md, tick, -1);    // ���S���X�L��

    memset (tmpsd, 0, sizeof (tmpsd));
    memset (pt, 0, sizeof (pt));

    max_hp = battle_get_max_hp (&md->bl);

    if (src && src->type == BL_MOB)
        mob_unlocktarget ((struct mob_data *) src, tick);

    /* �\�E���h���C�� */
    if (sd && (skill = pc_checkskill (sd, HW_SOULDRAIN)) > 0)
    {
        clif_skill_nodamage (src, &md->bl, HW_SOULDRAIN, skill, 1);
        sp = (battle_get_lv (&md->bl)) * (65 + 15 * skill) / 100;
        if (sd->status.sp + sp > sd->status.max_sp)
            sp = sd->status.max_sp - sd->status.sp;
        sd->status.sp += sp;
        clif_heal (sd->fd, SP_SP, sp);
    }

    // map�O�ɏ������l�͌v�Z���珜���̂�
    // overkill���͖�������sum��max_hp�Ƃ͈Ⴄ

    tdmg = 0;
    for (i = 0, count = 0, mvp_damage = 0; i < DAMAGELOG_SIZE; i++)
    {
        if (md->dmglog[i].id == 0)
            continue;
        tmpsd[i] = map_id2sd (md->dmglog[i].id);
        if (tmpsd[i] == NULL)
            continue;
        count++;
        if (tmpsd[i]->bl.m != md->bl.m || pc_isdead (tmpsd[i]))
            continue;

        tdmg += (double) md->dmglog[i].dmg;
        if (mvp_damage < md->dmglog[i].dmg)
        {
            third_sd = second_sd;
            second_sd = mvp_sd;
            mvp_sd = tmpsd[i];
            mvp_damage = md->dmglog[i].dmg;
        }
    }

    // [MouseJstr]
    if ((map[md->bl.m].flag.pvp == 0) || (battle_config.pvp_exp == 1))
    {

        if ((double) max_hp < tdmg)
            dmg_rate = ((double) max_hp) / tdmg;
        else
            dmg_rate = 1;

        // �o���l�̕��z
        for (i = 0; i < DAMAGELOG_SIZE; i++)
        {

            int  pid, base_exp, job_exp, flag = 1;
            double per;
            struct party *p;
            if (tmpsd[i] == NULL || tmpsd[i]->bl.m != md->bl.m)
                continue;
/* jAthena's exp formula
		per = ((double)md->dmglog[i].dmg)*(9.+(double)((count > 6)? 6:count))/10./((double)max_hp) * dmg_rate;
		temp = ((double)mob_db[md->class].base_exp * (double)battle_config.base_exp_rate / 100. * per);
		base_exp = (temp > 2147483647.)? 0x7fffffff:(int)temp;
		if(mob_db[md->class].base_exp > 0 && base_exp < 1) base_exp = 1;
		if(base_exp < 0) base_exp = 0;
		temp = ((double)mob_db[md->class].job_exp * (double)battle_config.job_exp_rate / 100. * per);
		job_exp = (temp > 2147483647.)? 0x7fffffff:(int)temp;
		if(mob_db[md->class].job_exp > 0 && job_exp < 1) job_exp = 1;
		if(job_exp < 0) job_exp = 0;
*/
//eAthena's exp formula rather than jAthena's
//      per=(double)md->dmglog[i].dmg*256*(9+(double)((count > 6)? 6:count))/10/(double)max_hp;
            // [Fate] The above is the old formula.  We do a more involved computation below.
            per = (double) md->dmglog[i].dmg * 256 / (double) max_hp;   // 256 = 100% of the score
            per *= damage_bonus_factor[count > DAMAGE_BONUS_COUNT ? DAMAGE_BONUS_COUNT : count];    // Bonus for party attack
            if (per > 512)
                per = 512;      // [Fate] Retained from before.  The maximum a single individual can get is double the original value.
            if (per < 1)
                per = 1;

            base_exp =
                ((mob_db[md->class].base_exp *
                  md->stats[MOB_XP_BONUS]) >> MOB_XP_BONUS_SHIFT) * per / 256;
            if (base_exp < 1)
                base_exp = 1;
            if (sd && md && battle_config.pk_mode == 1
                && (mob_db[md->class].lv - sd->status.base_level >= 20))
            {
                base_exp *= 1.15;   // pk_mode additional exp if monster >20 levels [Valaris]
            }
            if (md->state.special_mob_ai >= 1
                && battle_config.alchemist_summon_reward != 1)
                base_exp = 0;   // Added [Valaris]
            job_exp = mob_db[md->class].job_exp * per / 256;
            if (job_exp < 1)
                job_exp = 1;
            if (sd && md && battle_config.pk_mode == 1
                && (mob_db[md->class].lv - sd->status.base_level >= 20))
            {
                job_exp *= 1.15;    // pk_mode additional exp if monster >20 levels [Valaris]
            }
            if (md->state.special_mob_ai >= 1
                && battle_config.alchemist_summon_reward != 1)
                job_exp = 0;    // Added [Valaris]

            if ((pid = tmpsd[i]->status.party_id) > 0)
            {                   // �p�[�e�B�ɓ����Ă���
                int  j = 0;
                for (j = 0; j < pnum; j++)  // �����p�[�e�B���X�g�ɂ��邩�ǂ���
                    if (pt[j].id == pid)
                        break;
                if (j == pnum)
                {               // ���Ȃ��Ƃ��͌������ǂ����m�F
                    if ((p = party_search (pid)) != NULL && p->exp != 0)
                    {
                        pt[pnum].id = pid;
                        pt[pnum].p = p;
                        pt[pnum].base_exp = base_exp;
                        pt[pnum].job_exp = job_exp;
                        pnum++;
                        flag = 0;
                    }
                }
                else
                {               // ����Ƃ��͌���
                    pt[j].base_exp += base_exp;
                    pt[j].job_exp += job_exp;
                    flag = 0;
                }
            }
            if (flag)           // �e������
                pc_gainexp (tmpsd[i], base_exp, job_exp);
        }
        // �������z
        for (i = 0; i < pnum; i++)
            party_exp_share (pt[i].p, md->bl.m, pt[i].base_exp,
                             pt[i].job_exp);

        // item drop
        if (!(type & 1))
        {
            for (i = 0; i < 8; i++)
            {
                struct delay_item_drop *ditem;
                int  drop_rate;

                if (md->state.special_mob_ai >= 1 && battle_config.alchemist_summon_reward != 1)    // Added [Valaris]
                    break;      // End

                if (mob_db[md->class].dropitem[i].nameid <= 0)
                    continue;
                drop_rate = mob_db[md->class].dropitem[i].p;
                if (drop_rate <= 0 && battle_config.drop_rate0item == 1)
                    drop_rate = 1;
                if (battle_config.drops_by_luk > 0 && sd && md)
                    drop_rate += (sd->status.luk * battle_config.drops_by_luk) / 100;   // drops affected by luk [Valaris]
                if (sd && md && battle_config.pk_mode == 1
                    && (mob_db[md->class].lv - sd->status.base_level >= 20))
                    drop_rate *= 1.25;  // pk_mode increase drops if 20 level difference [Valaris]
                if (drop_rate <= MRAND (10000))
                    continue;

                ditem =
                    (struct delay_item_drop *) aCalloc (1,
                                                        sizeof (struct
                                                                delay_item_drop));
                ditem->nameid = mob_db[md->class].dropitem[i].nameid;
                ditem->amount = 1;
                ditem->m = md->bl.m;
                ditem->x = md->bl.x;
                ditem->y = md->bl.y;
                ditem->first_sd = mvp_sd;
                ditem->second_sd = second_sd;
                ditem->third_sd = third_sd;
                add_timer (tick + 500 + i, mob_delay_item_drop, (int) ditem,
                           0);
            }
            if (sd && sd->state.attack_type == BF_WEAPON)
            {
                for (i = 0; i < sd->monster_drop_item_count; i++)
                {
                    struct delay_item_drop *ditem;
                    int  race = battle_get_race (&md->bl);
                    if (sd->monster_drop_itemid[i] <= 0)
                        continue;
                    if (sd->monster_drop_race[i] & (1 << race) ||
                        (mob_db[md->class].mode & 0x20
                         && sd->monster_drop_race[i] & 1 << 10)
                        || (!(mob_db[md->class].mode & 0x20)
                            && sd->monster_drop_race[i] & 1 << 11))
                    {
                        if (sd->monster_drop_itemrate[i] <= MRAND (10000))
                            continue;

                        ditem =
                            (struct delay_item_drop *) aCalloc (1,
                                                                sizeof (struct
                                                                        delay_item_drop));
                        ditem->nameid = sd->monster_drop_itemid[i];
                        ditem->amount = 1;
                        ditem->m = md->bl.m;
                        ditem->x = md->bl.x;
                        ditem->y = md->bl.y;
                        ditem->first_sd = mvp_sd;
                        ditem->second_sd = second_sd;
                        ditem->third_sd = third_sd;
                        add_timer (tick + 520 + i, mob_delay_item_drop,
                                   (int) ditem, 0);
                    }
                }
                if (sd->get_zeny_num > 0)
                    pc_getzeny (sd,
                                mob_db[md->class].lv * 10 +
                                MRAND ((sd->get_zeny_num + 1)));
            }
            if (md->lootitem)
            {
                for (i = 0; i < md->lootitem_count; i++)
                {
                    struct delay_item_drop2 *ditem;

                    ditem =
                        (struct delay_item_drop2 *) aCalloc (1,
                                                             sizeof (struct
                                                                     delay_item_drop2));
                    memcpy (&ditem->item_data, &md->lootitem[i],
                            sizeof (md->lootitem[0]));
                    ditem->m = md->bl.m;
                    ditem->x = md->bl.x;
                    ditem->y = md->bl.y;
                    ditem->first_sd = mvp_sd;
                    ditem->second_sd = second_sd;
                    ditem->third_sd = third_sd;
                    add_timer (tick + 540 + i, mob_delay_item_drop2,
                               (int) ditem, 0);
                }
            }
        }

        // mvp����
        if (mvp_sd && mob_db[md->class].mexp > 0)
        {
            int  j;
            int  mexp = battle_get_mexp (&md->bl);
            temp =
                ((double) mexp * (double) battle_config.mvp_exp_rate *
                 (9. + (double) count) / 1000.);
            mexp = (temp > 2147483647.) ? 0x7fffffff : (int) temp;
            if (mexp < 1)
                mexp = 1;
            clif_mvp_effect (mvp_sd);   // �G�t�F�N�g
            clif_mvp_exp (mvp_sd, mexp);
            pc_gainexp (mvp_sd, mexp, 0);
            for (j = 0; j < 3; j++)
            {
                i = MRAND (3);
                if (mob_db[md->class].mvpitem[i].nameid <= 0)
                    continue;
                drop_rate = mob_db[md->class].mvpitem[i].p;
                if (drop_rate <= 0 && battle_config.drop_rate0item == 1)
                    drop_rate = 1;
                if (drop_rate < battle_config.item_drop_mvp_min)
                    drop_rate = battle_config.item_drop_mvp_min;
                if (drop_rate > battle_config.item_drop_mvp_max)
                    drop_rate = battle_config.item_drop_mvp_max;
                if (drop_rate <= MRAND (10000))
                    continue;
                memset (&item, 0, sizeof (item));
                item.nameid = mob_db[md->class].mvpitem[i].nameid;
                item.identify = !itemdb_isequip3 (item.nameid);
                clif_mvp_item (mvp_sd, item.nameid);
                if (mvp_sd->weight * 2 > mvp_sd->max_weight)
                    map_addflooritem (&item, 1, mvp_sd->bl.m, mvp_sd->bl.x,
                                      mvp_sd->bl.y, mvp_sd, second_sd,
                                      third_sd, 1);
                else if ((ret = pc_additem (mvp_sd, &item, 1)))
                {
                    clif_additem (sd, 0, 0, ret);
                    map_addflooritem (&item, 1, mvp_sd->bl.m, mvp_sd->bl.x,
                                      mvp_sd->bl.y, mvp_sd, second_sd,
                                      third_sd, 1);
                }
                break;
            }
        }

    }                           // [MouseJstr]

    // <Agit> NPC Event [OnAgitBreak]
    if (md->npc_event[0]
        && strcmp (((md->npc_event) + strlen (md->npc_event) - 13),
                   "::OnAgitBreak") == 0)
    {
        printf ("MOB.C: Run NPC_Event[OnAgitBreak].\n");
        if (agit_flag == 1)     //Call to Run NPC_Event[OnAgitBreak]
            guild_agit_break (md);
    }

    // SCRIPT���s
    if (md->npc_event[0])
    {
        if (sd == NULL)
        {
            if (mvp_sd != NULL)
                sd = mvp_sd;
            else
            {
                struct map_session_data *tmpsd;
                int  i;
                for (i = 0; i < fd_max; i++)
                {
                    if (session[i] && (tmpsd = session[i]->session_data)
                        && tmpsd->state.auth)
                    {
                        if (md->bl.m == tmpsd->bl.m)
                        {
                            sd = tmpsd;
                            break;
                        }
                    }
                }
            }
        }
        if (sd)
            npc_event (sd, md->npc_event, 0);
    }

    clif_clearchar_area (&md->bl, 1);
    map_delblock (&md->bl);
    if (mob_get_viewclass (md->class) <= 1000)
        clif_clearchar_delay (tick + 3000, &md->bl, 0);
    mob_deleteslave (md);
    mob_setdelayspawn (md->bl.id);
    map_freeblock_unlock ();

    return 0;
}

/*==========================================
 *
 *------------------------------------------
 */
int mob_class_change (struct mob_data *md, int *value)
{
    unsigned int tick = gettick ();
    int  i, c, hp_rate, max_hp, class, count = 0;

    nullpo_retr (0, md);
    nullpo_retr (0, value);

    if (value[0] <= 1000 || value[0] > 2000)
        return 0;
    if (md->bl.prev == NULL)
        return 0;

    while (count < 5 && value[count] > 1000 && value[count] <= 2000)
        count++;
    if (count < 1)
        return 0;

    class = value[MRAND (count)];
    if (class <= 1000 || class > 2000)
        return 0;

    max_hp = battle_get_max_hp (&md->bl);
    hp_rate = md->hp * 100 / max_hp;
    clif_mob_class_change (md, class);
    md->class = class;
    max_hp = battle_get_max_hp (&md->bl);
    if (battle_config.monster_class_change_full_recover == 1)
    {
        md->hp = max_hp;
        memset (md->dmglog, 0, sizeof (md->dmglog));
    }
    else
        md->hp = max_hp * hp_rate / 100;
    if (md->hp > max_hp)
        md->hp = max_hp;
    else if (md->hp < 1)
        md->hp = 1;

    memcpy (md->name, mob_db[class].jname, 24);
    memset (&md->state, 0, sizeof (md->state));
    md->attacked_id = 0;
    md->target_id = 0;
    md->move_fail_count = 0;

    md->stats[MOB_SPEED] = mob_db[md->class].speed;
    md->def_ele = mob_db[md->class].element;

    mob_changestate (md, MS_IDLE, 0);
    skill_castcancel (&md->bl, 0);
    md->state.skillstate = MSS_IDLE;
    md->last_thinktime = tick;
    md->next_walktime = tick + MPRAND (5000, 50);
    md->attackabletime = tick;
    md->canmove_tick = tick;
    md->sg_count = 0;

    for (i = 0, c = tick - 1000 * 3600 * 10; i < MAX_MOBSKILL; i++)
        md->skilldelay[i] = c;
    md->skillid = 0;
    md->skilllv = 0;

    if (md->lootitem == NULL && mob_db[class].mode & 0x02)
        md->lootitem =
            (struct item *) aCalloc (LOOTITEM_SIZE, sizeof (struct item));

    skill_clear_unitgroup (&md->bl);
    skill_cleartimerskill (&md->bl);

    clif_clearchar_area (&md->bl, 0);
    clif_spawnmob (md);

    return 0;
}

/*==========================================
 * mob��
 *------------------------------------------
 */
int mob_heal (struct mob_data *md, int heal)
{
    int  max_hp = battle_get_max_hp (&md->bl);

    nullpo_retr (0, md);

    md->hp += heal;
    if (max_hp < md->hp)
        md->hp = max_hp;

    if (md->class >= 1285 && md->class <= 1287)
    {                           // guardian hp update [Valaris]
        struct guild_castle *gc = guild_mapname2gc (map[md->bl.m].name);
        if (gc)
        {
            if (md->bl.id == gc->GID0)
                gc->Ghp0 = md->hp;
            if (md->bl.id == gc->GID1)
                gc->Ghp1 = md->hp;
            if (md->bl.id == gc->GID2)
                gc->Ghp2 = md->hp;
            if (md->bl.id == gc->GID3)
                gc->Ghp3 = md->hp;
            if (md->bl.id == gc->GID4)
                gc->Ghp4 = md->hp;
            if (md->bl.id == gc->GID5)
                gc->Ghp5 = md->hp;
            if (md->bl.id == gc->GID6)
                gc->Ghp6 = md->hp;
            if (md->bl.id == gc->GID7)
                gc->Ghp7 = md->hp;
        }
    }                           // end addition [Valaris]

    return 0;
}

/*==========================================
 * Added by RoVeRT
 *------------------------------------------
 */
int mob_warpslave_sub (struct block_list *bl, va_list ap)
{
    struct mob_data *md = (struct mob_data *) bl;
    int  id, x, y;
    id = va_arg (ap, int);
    x = va_arg (ap, int);
    y = va_arg (ap, int);
    if (md->master_id == id)
    {
        mob_warp (md, -1, x, y, 2);
    }
    return 0;
}

/*==========================================
 * Added by RoVeRT
 *------------------------------------------
 */
int mob_warpslave (struct mob_data *md, int x, int y)
{
//printf("warp slave\n");
    map_foreachinarea (mob_warpslave_sub, md->bl.m,
                       x - AREA_SIZE, y - AREA_SIZE,
                       x + AREA_SIZE, y + AREA_SIZE, BL_MOB,
                       md->bl.id, md->bl.x, md->bl.y);
    return 0;
}

/*==========================================
 * mob���[�v
 *------------------------------------------
 */
int mob_warp (struct mob_data *md, int m, int x, int y, int type)
{
    int  i = 0, c, xs = 0, ys = 0, bx = x, by = y;

    nullpo_retr (0, md);

    if (md->bl.prev == NULL)
        return 0;

    if (m < 0)
        m = md->bl.m;

    if (type >= 0)
    {
        if (map[md->bl.m].flag.monster_noteleport)
            return 0;
        clif_clearchar_area (&md->bl, type);
    }
    skill_unit_out_all (&md->bl, gettick (), 1);
    map_delblock (&md->bl);

    if (bx > 0 && by > 0)
    {                           // �ʒu�w��̏ꍇ���͂X�Z����T��
        xs = ys = 9;
    }

    while ((x < 0 || y < 0 || ((c = read_gat (m, x, y)) == 1 || c == 5))
           && (i++) < 1000)
    {
        if (xs > 0 && ys > 0 && i < 250)
        {                       // �w��ʒu�t�߂̒T��
            x = MPRAND (bx, xs) - xs / 2;
            y = MPRAND (by, ys) - ys / 2;
        }
        else
        {                       // ���S�����_���T��
            x = MPRAND (1, (map[m].xs - 2));
            y = MPRAND (1, (map[m].ys - 2));
        }
    }
    md->dir = 0;
    if (i < 1000)
    {
        md->bl.x = md->to_x = x;
        md->bl.y = md->to_y = y;
        md->bl.m = m;
    }
    else
    {
        m = md->bl.m;
        if (battle_config.error_log == 1)
            printf ("MOB %d warp failed, class = %d\n", md->bl.id, md->class);
    }

    md->target_id = 0;          // �^�Q����������
    md->state.targettype = NONE_ATTACKABLE;
    md->attacked_id = 0;
    md->state.skillstate = MSS_IDLE;
    mob_changestate (md, MS_IDLE, 0);

    if (type > 0 && i == 1000)
    {
        if (battle_config.battle_log == 1)
            printf ("MOB %d warp to (%d,%d), class = %d\n", md->bl.id, x, y,
                    md->class);
    }

    map_addblock (&md->bl);
    if (type > 0)
    {
        clif_spawnmob (md);
        mob_warpslave (md, md->bl.x, md->bl.y);
    }

    return 0;
}

/*==========================================
 * ��ʓ��̎�芪���̐��v�Z�p(foreachinarea)
 *------------------------------------------
 */
int mob_countslave_sub (struct block_list *bl, va_list ap)
{
    int  id, *c;
    struct mob_data *md;

    id = va_arg (ap, int);

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, c = va_arg (ap, int *));
    nullpo_retr (0, md = (struct mob_data *) bl);

    if (md->master_id == id)
        (*c)++;
    return 0;
}

/*==========================================
 * ��ʓ��̎�芪���̐��v�Z
 *------------------------------------------
 */
int mob_countslave (struct mob_data *md)
{
    int  c = 0;

    nullpo_retr (0, md);

    map_foreachinarea (mob_countslave_sub, md->bl.m,
                       0, 0, map[md->bl.m].xs - 1, map[md->bl.m].ys - 1,
                       BL_MOB, md->bl.id, &c);
    return c;
}

/*==========================================
 * �艺MOB����
 *------------------------------------------
 */
int mob_summonslave (struct mob_data *md2, int *value, int amount, int flag)
{
    struct mob_data *md;
    int  bx, by, m, count = 0, class, k, a = amount;

    nullpo_retr (0, md2);
    nullpo_retr (0, value);

    bx = md2->bl.x;
    by = md2->bl.y;
    m = md2->bl.m;

    if (value[0] <= 1000 || value[0] > 2000)    // �l���ُ�Ȃ珢�����~�߂�
        return 0;
    while (count < 5 && value[count] > 1000 && value[count] <= 2000)
        count++;
    if (count < 1)
        return 0;

    for (k = 0; k < count; k++)
    {
        amount = a;
        class = value[k];
        if (class <= 1000 || class > 2000)
            continue;
        for (; amount > 0; amount--)
        {
            int  x = 0, y = 0, c = 0, i = 0;
            md = (struct mob_data *) aCalloc (1, sizeof (struct mob_data));
            if (mob_db[class].mode & 0x02)
                md->lootitem =
                    (struct item *) aCalloc (LOOTITEM_SIZE,
                                             sizeof (struct item));
            else
                md->lootitem = NULL;

            while ((x <= 0 || y <= 0 || (c = map_getcell (m, x, y)) == 1
                    || c == 5) && (i++) < 100)
            {
                x = MPRAND (bx, 9) - 4;
                y = MPRAND (by, 9) - 4;
            }
            if (i >= 100)
            {
                x = bx;
                y = by;
            }

            mob_spawn_dataset (md, "--ja--", class);
            md->bl.prev = NULL;
            md->bl.next = NULL;
            md->bl.m = m;
            md->bl.x = x;
            md->bl.y = y;

            md->m = m;
            md->x0 = x;
            md->y0 = y;
            md->xs = 0;
            md->ys = 0;
            md->stats[MOB_SPEED] = md2->stats[MOB_SPEED];
            md->spawndelay1 = -1;   // ��x�̂݃t���O
            md->spawndelay2 = -1;   // ��x�̂݃t���O

            memset (md->npc_event, 0, sizeof (md->npc_event));
            md->bl.type = BL_MOB;
            map_addiddb (&md->bl);
            mob_spawn (md->bl.id);
            clif_skill_nodamage (&md->bl, &md->bl,
                                 (flag) ? NPC_SUMMONSLAVE : NPC_SUMMONMONSTER,
                                 a, 1);

            if (flag)
                md->master_id = md2->bl.id;
        }
    }
    return 0;
}

/*==========================================
 * ���������b�N���Ă���PC�̐��𐔂���(foreachclient)
 *------------------------------------------
 */
static int mob_counttargeted_sub (struct block_list *bl, va_list ap)
{
    int  id, *c, target_lv;
    struct block_list *src;

    id = va_arg (ap, int);
    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, c = va_arg (ap, int *));

    src = va_arg (ap, struct block_list *);
    target_lv = va_arg (ap, int);
    if (id == bl->id || (src && id == src->id))
        return 0;
    if (bl->type == BL_PC)
    {
        struct map_session_data *sd = (struct map_session_data *) bl;
        if (sd && sd->attacktarget == id && sd->attacktimer != -1
            && sd->attacktarget_lv >= target_lv)
            (*c)++;
    }
    else if (bl->type == BL_MOB)
    {
        struct mob_data *md = (struct mob_data *) bl;
        if (md && md->target_id == id && md->timer != -1
            && md->state.state == MS_ATTACK && md->target_lv >= target_lv)
            (*c)++;
    }
    return 0;
}

/*==========================================
 * ���������b�N���Ă���PC�̐��𐔂���
 *------------------------------------------
 */
int mob_counttargeted (struct mob_data *md, struct block_list *src,
                       int target_lv)
{
    int  c = 0;

    nullpo_retr (0, md);

    map_foreachinarea (mob_counttargeted_sub, md->bl.m,
                       md->bl.x - AREA_SIZE, md->bl.y - AREA_SIZE,
                       md->bl.x + AREA_SIZE, md->bl.y + AREA_SIZE, 0,
                       md->bl.id, &c, src, target_lv);
    return c;
}

/*==========================================
 *MOBskill����Y��skillid��skillidx��Ԃ�
 *------------------------------------------
 */
int mob_skillid2skillidx (int class, int skillid)
{
    int  i;
    struct mob_skill *ms = mob_db[class].skill;

    if (ms == NULL)
        return -1;

    for (i = 0; i < mob_db[class].maxskill; i++)
    {
        if (ms[i].skill_id == skillid)
            return i;
    }
    return -1;

}

//
// MOB�X�L��
//

/*==========================================
 * �X�L���g�p�i�r�������AID�w��j
 *------------------------------------------
 */
int mobskill_castend_id (int tid, unsigned int tick, int id, int data)
{
    struct mob_data *md = NULL;
    struct block_list *bl;
    struct block_list *mbl;
    int  range;

    if ((mbl = map_id2bl (id)) == NULL) //�r������Mob���������Ȃ��Ƃ����̂͗ǂ����鐳�폈��
        return 0;
    if ((md = (struct mob_data *) mbl) == NULL)
    {
        printf ("mobskill_castend_id nullpo mbl->id:%d\n", mbl->id);
        return 0;
    }
    if (md->bl.type != BL_MOB || md->bl.prev == NULL)
        return 0;
    if (md->skilltimer != tid)  // �^�C�}ID�̊m�F
        return 0;

    md->skilltimer = -1;
    //���ق��Ԉُ�Ȃ�
    if (md->sc_data)
    {
        if (md->opt1 > 0 || md->sc_data[SC_DIVINA].timer != -1
            || md->sc_data[SC_ROKISWEIL].timer != -1
            || md->sc_data[SC_STEELBODY].timer != -1)
            return 0;
        if (md->sc_data[SC_AUTOCOUNTER].timer != -1 && md->skillid != KN_AUTOCOUNTER)   //�I�[�g�J�E���^�[
            return 0;
        if (md->sc_data[SC_BLADESTOP].timer != -1)  //���n���
            return 0;
        if (md->sc_data[SC_BERSERK].timer != -1)    //�o�[�T�[�N
            return 0;
    }
    if (md->skillid != NPC_EMOTION)
        md->last_thinktime = tick + battle_get_adelay (&md->bl);

    if ((bl = map_id2bl (md->skilltarget)) == NULL || bl->prev == NULL)
    {                           //�X�L���^�[�Q�b�g�����݂��Ȃ�
        //printf("mobskill_castend_id nullpo\n");//�^�[�Q�b�g�����Ȃ��Ƃ���nullpo����Ȃ��ĕ��ʂɏI��
        return 0;
    }
    if (md->bl.m != bl->m)
        return 0;

    if (md->skillid == PR_LEXAETERNA)
    {
        struct status_change *sc_data = battle_get_sc_data (bl);
        if (sc_data
            && (sc_data[SC_FREEZE].timer != -1
                || (sc_data[SC_STONE].timer != -1
                    && sc_data[SC_STONE].val2 == 0)))
            return 0;
    }
    else if (md->skillid == RG_BACKSTAP)
    {
        int  dir = map_calc_dir (&md->bl, bl->x, bl->y), t_dir =
            battle_get_dir (bl);
        int  dist = distance (md->bl.x, md->bl.y, bl->x, bl->y);
        if (bl->type != BL_SKILL && (dist == 0 || map_check_dir (dir, t_dir)))
            return 0;
    }
    if (((skill_get_inf (md->skillid) & 1) || (skill_get_inf2 (md->skillid) & 4)) &&    // �މ�G�Ί֌W�`�F�b�N
        battle_check_target (&md->bl, bl, BCT_ENEMY) <= 0)
        return 0;
    range = skill_get_range (md->skillid, md->skilllv);
    if (range < 0)
        range = battle_get_range (&md->bl) - (range + 1);
    if (range + battle_config.mob_skill_add_range <
        distance (md->bl.x, md->bl.y, bl->x, bl->y))
        return 0;

    md->skilldelay[md->skillidx] = tick;

    if (battle_config.mob_skill_log == 1)
        printf ("MOB skill castend skill=%d, class = %d\n", md->skillid,
                md->class);
    mob_stop_walking (md, 0);

    switch (skill_get_nk (md->skillid))
    {
            // �U���n/������΂��n
        case 0:
        case 2:
            skill_castend_damage_id (&md->bl, bl, md->skillid, md->skilllv,
                                     tick, 0);
            break;
        case 1:                // �x���n
            if (!mob_db[md->class].skill[md->skillidx].val[0] &&
                (md->skillid == AL_HEAL
                 || (md->skillid == ALL_RESURRECTION && bl->type != BL_PC))
                && battle_check_undead (battle_get_race (bl),
                                        battle_get_elem_type (bl)))
                skill_castend_damage_id (&md->bl, bl, md->skillid,
                                         md->skilllv, tick, 0);
            else
                skill_castend_nodamage_id (&md->bl, bl, md->skillid,
                                           md->skilllv, tick, 0);
            break;
    }

    return 0;
}

/*==========================================
 * �X�L���g�p�i�r�������A�ꏊ�w��j
 *------------------------------------------
 */
int mobskill_castend_pos (int tid, unsigned int tick, int id, int data)
{
    struct mob_data *md = NULL;
    struct block_list *bl;
    int  range, maxcount;

    //mobskill_castend_id���l�r������Mob���r���������ɂ������Ȃ��Ƃ����̂͂��肻���Ȃ̂�nullpo���珜�O
    if ((bl = map_id2bl (id)) == NULL)
        return 0;

    nullpo_retr (0, md = (struct mob_data *) bl);

    if (md->bl.type != BL_MOB || md->bl.prev == NULL)
        return 0;

    if (md->skilltimer != tid)  // �^�C�}ID�̊m�F
        return 0;

    md->skilltimer = -1;
    if (md->sc_data)
    {
        if (md->opt1 > 0 || md->sc_data[SC_DIVINA].timer != -1
            || md->sc_data[SC_ROKISWEIL].timer != -1
            || md->sc_data[SC_STEELBODY].timer != -1)
            return 0;
        if (md->sc_data[SC_AUTOCOUNTER].timer != -1 && md->skillid != KN_AUTOCOUNTER)   //�I�[�g�J�E���^�[
            return 0;
        if (md->sc_data[SC_BLADESTOP].timer != -1)  //���n���
            return 0;
        if (md->sc_data[SC_BERSERK].timer != -1)    //�o�[�T�[�N
            return 0;
    }

    if (battle_config.monster_skill_reiteration == 0)
    {
        range = -1;
        switch (md->skillid)
        {
            case MG_SAFETYWALL:
            case WZ_FIREPILLAR:
            case HT_SKIDTRAP:
            case HT_LANDMINE:
            case HT_ANKLESNARE:
            case HT_SHOCKWAVE:
            case HT_SANDMAN:
            case HT_FLASHER:
            case HT_FREEZINGTRAP:
            case HT_BLASTMINE:
            case HT_CLAYMORETRAP:
            case PF_SPIDERWEB: /* �X�p�C�_�[�E�F�b�u */
                range = 0;
                break;
            case AL_PNEUMA:
            case AL_WARP:
                range = 1;
                break;
        }
        if (range >= 0)
        {
            if (skill_check_unit_range
                (md->bl.m, md->skillx, md->skilly, range, md->skillid) > 0)
                return 0;
        }
    }
    if (battle_config.monster_skill_nofootset == 1)
    {
        range = -1;
        switch (md->skillid)
        {
            case WZ_FIREPILLAR:
            case HT_SKIDTRAP:
            case HT_LANDMINE:
            case HT_ANKLESNARE:
            case HT_SHOCKWAVE:
            case HT_SANDMAN:
            case HT_FLASHER:
            case HT_FREEZINGTRAP:
            case HT_BLASTMINE:
            case HT_CLAYMORETRAP:
            case AM_DEMONSTRATION:
            case PF_SPIDERWEB: /* �X�p�C�_�[�E�F�b�u */
                range = 1;
                break;
            case AL_WARP:
                range = 0;
                break;
        }
        if (range >= 0)
        {
            if (skill_check_unit_range2
                (md->bl.m, md->skillx, md->skilly, range) > 0)
                return 0;
        }
    }

    if (battle_config.monster_land_skill_limit == 1)
    {
        maxcount = skill_get_maxcount (md->skillid);
        if (maxcount > 0)
        {
            int  i, c;
            for (i = c = 0; i < MAX_MOBSKILLUNITGROUP; i++)
            {
                if (md->skillunit[i].alive_count > 0
                    && md->skillunit[i].skill_id == md->skillid)
                    c++;
            }
            if (c >= maxcount)
                return 0;
        }
    }

    range = skill_get_range (md->skillid, md->skilllv);
    if (range < 0)
        range = battle_get_range (&md->bl) - (range + 1);
    if (range + battle_config.mob_skill_add_range <
        distance (md->bl.x, md->bl.y, md->skillx, md->skilly))
        return 0;
    md->skilldelay[md->skillidx] = tick;

    if (battle_config.mob_skill_log == 1)
        printf ("MOB skill castend skill=%d, class = %d\n", md->skillid,
                md->class);
    mob_stop_walking (md, 0);

    skill_castend_pos2 (&md->bl, md->skillx, md->skilly, md->skillid,
                        md->skilllv, tick, 0);

    return 0;
}

/*==========================================
 * Skill use (an aria start, ID specification)
 *------------------------------------------
 */
int mobskill_use_id (struct mob_data *md, struct block_list *target,
                     int skill_idx)
{
    int  casttime, range;
    struct mob_skill *ms;
    int  skill_id, skill_lv, forcecast = 0;

    nullpo_retr (0, md);
    nullpo_retr (0, ms = &mob_db[md->class].skill[skill_idx]);

    if (target == NULL && (target = map_id2bl (md->target_id)) == NULL)
        return 0;

    if (target->prev == NULL || md->bl.prev == NULL)
        return 0;

    skill_id = ms->skill_id;
    skill_lv = ms->skill_lv;

    // ���ق�ُ�
    if (md->sc_data)
    {
        if (md->opt1 > 0 || md->sc_data[SC_DIVINA].timer != -1
            || md->sc_data[SC_ROKISWEIL].timer != -1
            || md->sc_data[SC_STEELBODY].timer != -1)
            return 0;
        if (md->sc_data[SC_AUTOCOUNTER].timer != -1 && md->skillid != KN_AUTOCOUNTER)   //�I�[�g�J�E���^�[
            return 0;
        if (md->sc_data[SC_BLADESTOP].timer != -1)  //���n���
            return 0;
        if (md->sc_data[SC_BERSERK].timer != -1)    //�o�[�T�[�N
            return 0;
    }

    if (md->option & 4 && skill_id == TF_HIDING)
        return 0;
    if (md->option & 2 && skill_id != TF_HIDING && skill_id != AS_GRIMTOOTH
        && skill_id != RG_BACKSTAP && skill_id != RG_RAID)
        return 0;

    if (map[md->bl.m].flag.gvg
        && (skill_id == SM_ENDURE || skill_id == AL_TELEPORT
            || skill_id == AL_WARP || skill_id == WZ_ICEWALL
            || skill_id == TF_BACKSLIDING))
        return 0;

    if (skill_get_inf2 (skill_id) & 0x200 && md->bl.id == target->id)
        return 0;

    // �˒��Ə�Q���`�F�b�N
    range = skill_get_range (skill_id, skill_lv);
    if (range < 0)
        range = battle_get_range (&md->bl) - (range + 1);

    if (!battle_check_range (&md->bl, target, range))
        return 0;

//  delay=skill_delayfix(&md->bl, skill_get_delay( skill_id,skill_lv) );

    casttime = skill_castfix (&md->bl, ms->casttime);
    md->state.skillcastcancel = ms->cancel;
    md->skilldelay[skill_idx] = gettick ();

    switch (skill_id)
    {                           /* ��������ȏ������K�v */
        case ALL_RESURRECTION: /* ���U���N�V���� */
            if (target->type != BL_PC
                && battle_check_undead (battle_get_race (target),
                                        battle_get_elem_type (target)))
            {                   /* �G���A���f�b�h�Ȃ� */
                forcecast = 1;  /* �^�[���A���f�b�g�Ɠ����r������ */
                casttime =
                    skill_castfix (&md->bl,
                                   skill_get_cast (PR_TURNUNDEAD, skill_lv));
            }
            break;
        case MO_EXTREMITYFIST: /*���C���e�P�� */
        case SA_MAGICROD:
        case SA_SPELLBREAKER:
            forcecast = 1;
            break;
    }

    if (battle_config.mob_skill_log == 1)
        printf
            ("MOB skill use target_id=%d skill=%d lv=%d cast=%d, class = %d\n",
             target->id, skill_id, skill_lv, casttime, md->class);

    if (casttime > 0 || forcecast)
    {                           // �r�����K�v
//      struct mob_data *md2;
        clif_skillcasting (&md->bl,
                           md->bl.id, target->id, 0, 0, skill_id, casttime);

        // �r�����������X�^�[
/*		if( target->type==BL_MOB && mob_db[(md2=(struct mob_data *)target)->class].mode&0x10 &&
			md2->state.state!=MS_ATTACK){
				md2->target_id=md->bl.id;
				md->state.targettype = ATTACKABLE;
				md2->min_chase=13;
		}*/
    }

    if (casttime <= 0)          // �r���̖������̂̓L�����Z������Ȃ�
        md->state.skillcastcancel = 0;

    md->skilltarget = target->id;
    md->skillx = 0;
    md->skilly = 0;
    md->skillid = skill_id;
    md->skilllv = skill_lv;
    md->skillidx = skill_idx;

    if (!(battle_config.monster_cloak_check_type & 2)
        && md->sc_data[SC_CLOAKING].timer != -1 && md->skillid != AS_CLOAKING)
        skill_status_change_end (&md->bl, SC_CLOAKING, -1);

    if (casttime > 0)
    {
        md->skilltimer =
            add_timer (gettick () + casttime, mobskill_castend_id, md->bl.id,
                       0);
    }
    else
    {
        md->skilltimer = -1;
        mobskill_castend_id (md->skilltimer, gettick (), md->bl.id, 0);
    }

    return 1;
}

/*==========================================
 * �X�L���g�p�i�ꏊ�w��j
 *------------------------------------------
 */
int mobskill_use_pos (struct mob_data *md,
                      int skill_x, int skill_y, int skill_idx)
{
    int  casttime = 0, range;
    struct mob_skill *ms;
    struct block_list bl;
    int  skill_id, skill_lv;

    nullpo_retr (0, md);
    nullpo_retr (0, ms = &mob_db[md->class].skill[skill_idx]);

    if (md->bl.prev == NULL)
        return 0;

    skill_id = ms->skill_id;
    skill_lv = ms->skill_lv;

    //���ق��Ԉُ�Ȃ�
    if (md->sc_data)
    {
        if (md->opt1 > 0 || md->sc_data[SC_DIVINA].timer != -1
            || md->sc_data[SC_ROKISWEIL].timer != -1
            || md->sc_data[SC_STEELBODY].timer != -1)
            return 0;
        if (md->sc_data[SC_AUTOCOUNTER].timer != -1 && md->skillid != KN_AUTOCOUNTER)   //�I�[�g�J�E���^�[
            return 0;
        if (md->sc_data[SC_BLADESTOP].timer != -1)  //���n���
            return 0;
        if (md->sc_data[SC_BERSERK].timer != -1)    //�o�[�T�[�N
            return 0;
    }

    if (md->option & 2)
        return 0;

    if (map[md->bl.m].flag.gvg
        && (skill_id == SM_ENDURE || skill_id == AL_TELEPORT
            || skill_id == AL_WARP || skill_id == WZ_ICEWALL
            || skill_id == TF_BACKSLIDING))
        return 0;

    // �˒��Ə�Q���`�F�b�N
    bl.type = BL_NUL;
    bl.m = md->bl.m;
    bl.x = skill_x;
    bl.y = skill_y;
    range = skill_get_range (skill_id, skill_lv);
    if (range < 0)
        range = battle_get_range (&md->bl) - (range + 1);
    if (!battle_check_range (&md->bl, &bl, range))
        return 0;

//  delay=skill_delayfix(&sd->bl, skill_get_delay( skill_id,skill_lv) );
    casttime = skill_castfix (&md->bl, ms->casttime);
    md->skilldelay[skill_idx] = gettick ();
    md->state.skillcastcancel = ms->cancel;

    if (battle_config.mob_skill_log == 1)
        printf
            ("MOB skill use target_pos=(%d,%d) skill=%d lv=%d cast=%d, class = %d\n",
             skill_x, skill_y, skill_id, skill_lv, casttime, md->class);

    if (casttime > 0)           // A cast time is required.
        clif_skillcasting (&md->bl,
                           md->bl.id, 0, skill_x, skill_y, skill_id,
                           casttime);

    if (casttime <= 0)          // A skill without a cast time wont be cancelled.
        md->state.skillcastcancel = 0;

    md->skillx = skill_x;
    md->skilly = skill_y;
    md->skilltarget = 0;
    md->skillid = skill_id;
    md->skilllv = skill_lv;
    md->skillidx = skill_idx;
    if (!(battle_config.monster_cloak_check_type & 2)
        && md->sc_data[SC_CLOAKING].timer != -1)
        skill_status_change_end (&md->bl, SC_CLOAKING, -1);
    if (casttime > 0)
    {
        md->skilltimer =
            add_timer (gettick () + casttime, mobskill_castend_pos, md->bl.id,
                       0);
    }
    else
    {
        md->skilltimer = -1;
        mobskill_castend_pos (md->skilltimer, gettick (), md->bl.id, 0);
    }

    return 1;
}

/*==========================================
 * Friendly Mob whose HP is decreasing by a nearby MOB is looked for.
 *------------------------------------------
 */
int mob_getfriendhpltmaxrate_sub (struct block_list *bl, va_list ap)
{
    int  rate;
    struct mob_data **fr, *md, *mmd;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, mmd = va_arg (ap, struct mob_data *));

    md = (struct mob_data *) bl;

    if (mmd->bl.id == bl->id)
        return 0;
    rate = va_arg (ap, int);
    fr = va_arg (ap, struct mob_data **);
    if (md->hp < mob_db[md->class].max_hp * rate / 100)
        (*fr) = md;
    return 0;
}

struct mob_data *mob_getfriendhpltmaxrate (struct mob_data *md, int rate)
{
    struct mob_data *fr = NULL;
    const int r = 8;

    nullpo_retr (NULL, md);

    map_foreachinarea (mob_getfriendhpltmaxrate_sub, md->bl.m,
                       md->bl.x - r, md->bl.y - r, md->bl.x + r, md->bl.y + r,
                       BL_MOB, md, rate, &fr);
    return fr;
}

/*==========================================
 * What a status state suits by nearby MOB is looked for.
 *------------------------------------------
 */
int mob_getfriendstatus_sub (struct block_list *bl, va_list ap)
{
    int  cond1, cond2;
    struct mob_data **fr, *md, *mmd;
    int  flag = 0;

    nullpo_retr (0, bl);
    nullpo_retr (0, ap);
    nullpo_retr (0, md = (struct mob_data *) bl);
    nullpo_retr (0, mmd = va_arg (ap, struct mob_data *));

    if (mmd->bl.id == bl->id)
        return 0;
    cond1 = va_arg (ap, int);
    cond2 = va_arg (ap, int);
    fr = va_arg (ap, struct mob_data **);
    if (cond2 == -1)
    {
        int  j;
        for (j = SC_STONE; j <= SC_BLIND && !flag; j++)
        {
            flag = (md->sc_data[j].timer != -1);
        }
    }
    else
        flag = (md->sc_data[cond2].timer != -1);
    if (flag ^ (cond1 == MSC_FRIENDSTATUSOFF))
        (*fr) = md;

    return 0;
}

struct mob_data *mob_getfriendstatus (struct mob_data *md, int cond1,
                                      int cond2)
{
    struct mob_data *fr = NULL;
    const int r = 8;

    nullpo_retr (0, md);

    map_foreachinarea (mob_getfriendstatus_sub, md->bl.m,
                       md->bl.x - r, md->bl.y - r, md->bl.x + r, md->bl.y + r,
                       BL_MOB, md, cond1, cond2, &fr);
    return fr;
}

/*==========================================
 * Skill use judging
 *------------------------------------------
 */
int mobskill_use (struct mob_data *md, unsigned int tick, int event)
{
    struct mob_skill *ms;
//  struct block_list *target=NULL;
    int  i, max_hp;

    nullpo_retr (0, md);
    nullpo_retr (0, ms = mob_db[md->class].skill);

    max_hp = battle_get_max_hp (&md->bl);

    if (battle_config.mob_skill_use == 0 || md->skilltimer != -1)
        return 0;

    if (md->state.special_mob_ai)
        return 0;

    if (md->sc_data[SC_SELFDESTRUCTION].timer != -1)    //�������̓X�L�����g��Ȃ�
        return 0;

    for (i = 0; i < mob_db[md->class].maxskill; i++)
    {
        int  c2 = ms[i].cond2, flag = 0;
        struct mob_data *fmd = NULL;

        // �f�B���C��
        if (DIFF_TICK (tick, md->skilldelay[i]) < ms[i].delay)
            continue;

        // ��Ԕ���
        if (ms[i].state >= 0 && ms[i].state != md->state.skillstate)
            continue;

        // ��������
        flag = (event == ms[i].cond1);
        if (!flag)
        {
            switch (ms[i].cond1)
            {
                case MSC_ALWAYS:
                    flag = 1;
                    break;
                case MSC_MYHPLTMAXRATE:    // HP< maxhp%
                    flag = (md->hp < max_hp * c2 / 100);
                    break;
                case MSC_MYSTATUSON:   // status[num] on
                case MSC_MYSTATUSOFF:  // status[num] off
                    if (ms[i].cond2 == -1)
                    {
                        int  j;
                        for (j = SC_STONE; j <= SC_BLIND && !flag; j++)
                        {
                            flag = (md->sc_data[j].timer != -1);
                        }
                    }
                    else
                        flag = (md->sc_data[ms[i].cond2].timer != -1);
                    flag ^= (ms[i].cond1 == MSC_MYSTATUSOFF);
                    break;
                case MSC_FRIENDHPLTMAXRATE:    // friend HP < maxhp%
                    flag =
                        ((fmd =
                          mob_getfriendhpltmaxrate (md,
                                                    ms[i].cond2)) != NULL);
                    break;
                case MSC_FRIENDSTATUSON:   // friend status[num] on
                case MSC_FRIENDSTATUSOFF:  // friend status[num] off
                    flag =
                        ((fmd =
                          mob_getfriendstatus (md, ms[i].cond1,
                                               ms[i].cond2)) != NULL);
                    break;
                case MSC_NOTINTOWN:     // Only outside of towns.
                    flag = !map[md->bl.m].flag.town;
                    break;
                case MSC_SLAVELT:  // slave < num
                    flag = (mob_countslave (md) < c2);
                    break;
                case MSC_ATTACKPCGT:   // attack pc > num
                    flag = (mob_counttargeted (md, NULL, 0) > c2);
                    break;
                case MSC_SLAVELE:  // slave <= num
                    flag = (mob_countslave (md) <= c2);
                    break;
                case MSC_ATTACKPCGE:   // attack pc >= num
                    flag = (mob_counttargeted (md, NULL, 0) >= c2);
                    break;
                case MSC_SKILLUSED:    // specificated skill used
                    flag = ((event & 0xffff) == MSC_SKILLUSED
                            && ((event >> 16) == c2 || c2 == 0));
                    break;
            }
        }

        // �m������
        if (flag && MRAND (10000) < ms[i].permillage)
        {

            if (skill_get_inf (ms[i].skill_id) & 2)
            {
                // �ꏊ�w��
                struct block_list *bl = NULL;
                int  x = 0, y = 0;
                if (ms[i].target <= MST_AROUND)
                {
                    bl = ((ms[i].target == MST_TARGET
                           || ms[i].target ==
                           MST_AROUND5) ? map_id2bl (md->
                                                     target_id)
                          : (ms[i].target ==
                             MST_FRIEND) ? &fmd->bl : &md->bl);
                    if (bl != NULL)
                    {
                        x = bl->x;
                        y = bl->y;
                    }
                }
                if (x <= 0 || y <= 0)
                    continue;
                // �����̎���
                if (ms[i].target >= MST_AROUND1)
                {
                    int  bx = x, by = y, i = 0, c, m = bl->m, r =
                        ms[i].target - MST_AROUND1;
                    do
                    {
                        bx = x + MRAND ((r * 2 + 3)) - r;
                        by = y + MRAND ((r * 2 + 3)) - r;
                    }
                    while ((bx <= 0 || by <= 0 || bx >= map[m].xs
                            || by >= map[m].ys
                            || ((c = read_gat (m, bx, by)) == 1 || c == 5))
                           && (i++) < 1000);
                    if (i < 1000)
                    {
                        x = bx;
                        y = by;
                    }
                }
                // ����̎���
                if (ms[i].target >= MST_AROUND5)
                {
                    int  bx = x, by = y, i = 0, c, m = bl->m, r =
                        (ms[i].target - MST_AROUND5) + 1;
                    do
                    {
                        bx = x + MRAND ((r * 2 + 1)) - r;
                        by = y + MRAND ((r * 2 + 1)) - r;
                    }
                    while ((bx <= 0 || by <= 0 || bx >= map[m].xs
                            || by >= map[m].ys
                            || ((c = read_gat (m, bx, by)) == 1 || c == 5))
                           && (i++) < 1000);
                    if (i < 1000)
                    {
                        x = bx;
                        y = by;
                    }
                }
                if (!mobskill_use_pos (md, x, y, i))
                    return 0;

            }
            else
            {
                // ID�w��
                if (ms[i].target <= MST_FRIEND)
                {
                    struct block_list *bl = NULL;
                    bl = ((ms[i].target ==
                           MST_TARGET) ? map_id2bl (md->
                                                    target_id) : (ms[i].target
                                                                  ==
                                                                  MST_FRIEND)
                          ? &fmd->bl : &md->bl);
                    if (bl && !mobskill_use_id (md, bl, i))
                        return 0;
                }
            }
            if (ms[i].emotion >= 0)
                clif_emotion (&md->bl, ms[i].emotion);
            return 1;
        }
    }

    return 0;
}

/*==========================================
 * Skill use event processing
 *------------------------------------------
 */
int mobskill_event (struct mob_data *md, int flag)
{
    nullpo_retr (0, md);

    if (flag == -1 && mobskill_use (md, gettick (), MSC_CASTTARGETED))
        return 1;
    if ((flag & BF_SHORT)
        && mobskill_use (md, gettick (), MSC_CLOSEDATTACKED))
        return 1;
    if ((flag & BF_LONG)
        && mobskill_use (md, gettick (), MSC_LONGRANGEATTACKED))
        return 1;
    return 0;
}

/*==========================================
 * Mob���G���y���E���Ȃǂ̏ꍇ�̔���
 *------------------------------------------
 */
int mob_gvmobcheck (struct map_session_data *sd, struct block_list *bl)
{
    struct mob_data *md = NULL;

    nullpo_retr (0, sd);
    nullpo_retr (0, bl);

    if (bl->type == BL_MOB && (md = (struct mob_data *) bl) &&
        (md->class == 1288 || md->class == 1287 || md->class == 1286
         || md->class == 1285))
    {
        struct guild_castle *gc = guild_mapname2gc (map[sd->bl.m].name);
        struct guild *g = guild_search (sd->status.guild_id);

        if (g == NULL && md->class == 1288)
            return 0;           //�M���h�������Ȃ�_���[�W����
        else if (gc != NULL && !map[sd->bl.m].flag.gvg)
            return 0;           //�ԓ���Gv����Ȃ��Ƃ��̓_���[�W�Ȃ�
        else if (g && gc != NULL && g->guild_id == gc->guild_id)
            return 0;           //����̃M���h�̃G���y�Ȃ�_���[�W����
        else if (g && guild_checkskill (g, GD_APPROVAL) <= 0
                 && md->class == 1288)
            return 0;           //���K�M���h���F���Ȃ��ƃ_���[�W����

    }

    return 1;
}

/*==========================================
 * �X�L���p�^�C�}�[�폜
 *------------------------------------------
 */
int mobskill_deltimer (struct mob_data *md)
{
    nullpo_retr (0, md);

    if (md->skilltimer != -1)
    {
        if (skill_get_inf (md->skillid) & 2)
            delete_timer (md->skilltimer, mobskill_castend_pos);
        else
            delete_timer (md->skilltimer, mobskill_castend_id);
        md->skilltimer = -1;
    }
    return 0;
}

//
// ������
//
/*==========================================
 * Since un-setting [ mob ] up was used, it is an initial provisional value setup.
 *------------------------------------------
 */
static int mob_makedummymobdb (int class)
{
    int  i;

    sprintf (mob_db[class].name, "mob%d", class);
    sprintf (mob_db[class].jname, "mob%d", class);
    mob_db[class].lv = 1;
    mob_db[class].max_hp = 1000;
    mob_db[class].max_sp = 1;
    mob_db[class].base_exp = 2;
    mob_db[class].job_exp = 1;
    mob_db[class].range = 1;
    mob_db[class].atk1 = 7;
    mob_db[class].atk2 = 10;
    mob_db[class].def = 0;
    mob_db[class].mdef = 0;
    mob_db[class].str = 1;
    mob_db[class].agi = 1;
    mob_db[class].vit = 1;
    mob_db[class].int_ = 1;
    mob_db[class].dex = 6;
    mob_db[class].luk = 2;
    mob_db[class].range2 = 10;
    mob_db[class].range3 = 10;
    mob_db[class].size = 0;
    mob_db[class].race = 0;
    mob_db[class].element = 0;
    mob_db[class].mode = 0;
    mob_db[class].speed = 300;
    mob_db[class].adelay = 1000;
    mob_db[class].amotion = 500;
    mob_db[class].dmotion = 500;
    mob_db[class].dropitem[0].nameid = 909; // Jellopy
    mob_db[class].dropitem[0].p = 1000;
    for (i = 1; i < 8; i++)
    {
        mob_db[class].dropitem[i].nameid = 0;
        mob_db[class].dropitem[i].p = 0;
    }
    // Item1,Item2
    mob_db[class].mexp = 0;
    mob_db[class].mexpper = 0;
    for (i = 0; i < 3; i++)
    {
        mob_db[class].mvpitem[i].nameid = 0;
        mob_db[class].mvpitem[i].p = 0;
    }
    for (i = 0; i < MAX_RANDOMMONSTER; i++)
        mob_db[class].summonper[i] = 0;
    return 0;
}

/*==========================================
 * db/mob_db.txt reading
 *------------------------------------------
 */
static int mob_readdb (void)
{
    FILE *fp;
    char line[1024];
    char *filename[] = { "db/mob_db.txt", "db/mob_db2.txt" };
    int  i;

    memset (mob_db, 0, sizeof (mob_db));

    for (i = 0; i < 2; i++)
    {

        fp = fopen_ (filename[i], "r");
        if (fp == NULL)
        {
            if (i > 0)
                continue;
            return -1;
        }
        while (fgets (line, 1020, fp))
        {
            int  class, i;
            char *str[57], *p, *np;

            if (line[0] == '/' && line[1] == '/')
                continue;

            for (i = 0, p = line; i < 57; i++)
            {
                while (*p == '\t' || *p == ' ')
                    p++;
                if ((np = strchr (p, ',')) != NULL)
                {
                    str[i] = p;
                    *np = 0;
                    p = np + 1;
                }
                else
                    str[i] = p;
            }

            class = atoi (str[0]);
            if (class <= 1000 || class > 2000)
                continue;

            mob_db[class].view_class = class;
            memcpy (mob_db[class].name, str[1], 24);
            memcpy (mob_db[class].jname, str[2], 24);
            mob_db[class].lv = atoi (str[3]);
            mob_db[class].max_hp = atoi (str[4]);
            mob_db[class].max_sp = atoi (str[5]);

            mob_db[class].base_exp = atoi (str[6]);
            if (mob_db[class].base_exp < 0)
                mob_db[class].base_exp = 0;
            else if (mob_db[class].base_exp > 0
                     && (mob_db[class].base_exp *
                         battle_config.base_exp_rate / 100 > 1000000000
                         || mob_db[class].base_exp *
                         battle_config.base_exp_rate / 100 < 0))
                mob_db[class].base_exp = 1000000000;
            else
                mob_db[class].base_exp *= battle_config.base_exp_rate / 100;

            mob_db[class].job_exp = atoi (str[7]);
            if (mob_db[class].job_exp < 0)
                mob_db[class].job_exp = 0;
            else if (mob_db[class].job_exp > 0
                     && (mob_db[class].job_exp * battle_config.job_exp_rate /
                         100 > 1000000000
                         || mob_db[class].job_exp *
                         battle_config.job_exp_rate / 100 < 0))
                mob_db[class].job_exp = 1000000000;
            else
                mob_db[class].job_exp *= battle_config.job_exp_rate / 100;

            mob_db[class].range = atoi (str[8]);
            mob_db[class].atk1 = atoi (str[9]);
            mob_db[class].atk2 = atoi (str[10]);
            mob_db[class].def = atoi (str[11]);
            mob_db[class].mdef = atoi (str[12]);
            mob_db[class].str = atoi (str[13]);
            mob_db[class].agi = atoi (str[14]);
            mob_db[class].vit = atoi (str[15]);
            mob_db[class].int_ = atoi (str[16]);
            mob_db[class].dex = atoi (str[17]);
            mob_db[class].luk = atoi (str[18]);
            mob_db[class].range2 = atoi (str[19]);
            mob_db[class].range3 = atoi (str[20]);
            mob_db[class].size = atoi (str[21]);
            mob_db[class].race = atoi (str[22]);
            mob_db[class].element = atoi (str[23]);
            mob_db[class].mode = atoi (str[24]);
            mob_db[class].speed = atoi (str[25]);
            mob_db[class].adelay = atoi (str[26]);
            mob_db[class].amotion = atoi (str[27]);
            mob_db[class].dmotion = atoi (str[28]);

            for (i = 0; i < 8; i++)
            {
                int  rate = 0, type, ratemin, ratemax;
                mob_db[class].dropitem[i].nameid = atoi (str[29 + i * 2]);
                type = itemdb_type (mob_db[class].dropitem[i].nameid);
                if (type == 0)
                {               // Added [Valaris]
                    rate = battle_config.item_rate_heal;
                    ratemin = battle_config.item_drop_heal_min;
                    ratemax = battle_config.item_drop_heal_max;
                }
                else if (type == 2)
                {
                    rate = battle_config.item_rate_use;
                    ratemin = battle_config.item_drop_use_min;
                    ratemax = battle_config.item_drop_use_max;  // End
                }
                else if (type == 4 || type == 5 || type == 8)
                {
                    rate = battle_config.item_rate_equip;
                    ratemin = battle_config.item_drop_equip_min;
                    ratemax = battle_config.item_drop_equip_max;
                }
                else if (type == 6)
                {
                    rate = battle_config.item_rate_card;
                    ratemin = battle_config.item_drop_card_min;
                    ratemax = battle_config.item_drop_card_max;
                }
                else
                {
                    rate = battle_config.item_rate_common;
                    ratemin = battle_config.item_drop_common_min;
                    ratemax = battle_config.item_drop_common_max;
                }
                rate = (rate / 100) * atoi (str[30 + i * 2]);
                rate =
                    (rate < ratemin) ? ratemin : (rate >
                                                  ratemax) ? ratemax : rate;
                mob_db[class].dropitem[i].p = rate;
            }
            // Item1,Item2
            mob_db[class].mexp =
                atoi (str[45]) * battle_config.mvp_exp_rate / 100;
            mob_db[class].mexpper = atoi (str[46]);
            for (i = 0; i < 3; i++)
            {
                mob_db[class].mvpitem[i].nameid = atoi (str[47 + i * 2]);
                mob_db[class].mvpitem[i].p =
                    atoi (str[48 + i * 2]) * battle_config.mvp_item_rate /
                    100;
            }
            mob_db[class].mutations_nr = atoi (str[55]);
            mob_db[class].mutation_power = atoi (str[56]);

            for (i = 0; i < MAX_RANDOMMONSTER; i++)
                mob_db[class].summonper[i] = 0;
            mob_db[class].maxskill = 0;

            mob_db[class].sex = 0;
            mob_db[class].hair = 0;
            mob_db[class].hair_color = 0;
            mob_db[class].weapon = 0;
            mob_db[class].shield = 0;
            mob_db[class].head_top = 0;
            mob_db[class].head_mid = 0;
            mob_db[class].head_buttom = 0;
            mob_db[class].clothes_color = 0;    //Add for player monster dye - Valaris

            if (mob_db[class].base_exp == 0)
                mob_db[class].base_exp = mob_gen_exp (&mob_db[class]);
        }
        fclose_ (fp);
        printf ("read %s done\n", filename[i]);
    }
    return 0;
}

/*==========================================
 * MOB display graphic change data reading
 *------------------------------------------
 */
static int mob_readdb_mobavail (void)
{
    FILE *fp;
    char line[1024];
    int  ln = 0;
    int  class, j, k;
    char *str[20], *p, *np;

    if ((fp = fopen_ ("db/mob_avail.txt", "r")) == NULL)
    {
        printf ("can't read db/mob_avail.txt\n");
        return -1;
    }

    while (fgets (line, 1020, fp))
    {
        if (line[0] == '/' && line[1] == '/')
            continue;
        memset (str, 0, sizeof (str));

        for (j = 0, p = line; j < 12; j++)
        {
            if ((np = strchr (p, ',')) != NULL)
            {
                str[j] = p;
                *np = 0;
                p = np + 1;
            }
            else
                str[j] = p;
        }

        if (str[0] == NULL)
            continue;

        class = atoi (str[0]);

        if (class <= 1000 || class > 2000)  // �l���ُ�Ȃ珈�����Ȃ��B
            continue;
        k = atoi (str[1]);
        if (k >= 0)
            mob_db[class].view_class = k;

        if ((mob_db[class].view_class < 24)
            || (mob_db[class].view_class > 4000))
        {
            mob_db[class].sex = atoi (str[2]);
            mob_db[class].hair = atoi (str[3]);
            mob_db[class].hair_color = atoi (str[4]);
            mob_db[class].weapon = atoi (str[5]);
            mob_db[class].shield = atoi (str[6]);
            mob_db[class].head_top = atoi (str[7]);
            mob_db[class].head_mid = atoi (str[8]);
            mob_db[class].head_buttom = atoi (str[9]);
            mob_db[class].option = atoi (str[10]) & ~0x46;
            mob_db[class].clothes_color = atoi (str[11]);   // Monster player dye option - Valaris
        }

        else if (atoi (str[2]) > 0)
            mob_db[class].equip = atoi (str[2]);    // mob equipment [Valaris]

        ln++;
    }
    fclose_ (fp);
    printf ("read db/mob_avail.txt done (count=%d)\n", ln);
    return 0;
}

/*==========================================
 * Reading of random monster data
 *------------------------------------------
 */
static int mob_read_randommonster (void)
{
    FILE *fp;
    char line[1024];
    char *str[10], *p;
    int  i, j;

    const char *mobfile[] = {
        "db/mob_branch.txt",
        "db/mob_poring.txt",
        "db/mob_boss.txt"
    };

    for (i = 0; i < MAX_RANDOMMONSTER; i++)
    {
        mob_db[0].summonper[i] = 1002;  // �ݒ肵�Y�ꂽ�ꍇ�̓|�������o��悤�ɂ��Ă���
        fp = fopen_ (mobfile[i], "r");
        if (fp == NULL)
        {
            printf ("can't read %s\n", mobfile[i]);
            return -1;
        }
        while (fgets (line, 1020, fp))
        {
            int  class, per;
            if (line[0] == '/' && line[1] == '/')
                continue;
            memset (str, 0, sizeof (str));
            for (j = 0, p = line; j < 3 && p; j++)
            {
                str[j] = p;
                p = strchr (p, ',');
                if (p)
                    *p++ = 0;
            }

            if (str[0] == NULL || str[2] == NULL)
                continue;

            class = atoi (str[0]);
            per = atoi (str[2]);
            if ((class > 1000 && class <= 2000) || class == 0)
                mob_db[class].summonper[i] = per;
        }
        fclose_ (fp);
        printf ("read %s done\n", mobfile[i]);
    }
    return 0;
}

/*==========================================
 * db/mob_skill_db.txt reading
 *------------------------------------------
 */
static int mob_readskilldb (void)
{
    FILE *fp;
    char line[1024];
    int  i;

    const struct
    {
        char str[32];
        int  id;
    } cond1[] =
    {
        {
        "always", MSC_ALWAYS},
        {
        "myhpltmaxrate", MSC_MYHPLTMAXRATE},
        {
        "friendhpltmaxrate", MSC_FRIENDHPLTMAXRATE},
        {
        "mystatuson", MSC_MYSTATUSON},
        {
        "mystatusoff", MSC_MYSTATUSOFF},
        {
        "friendstatuson", MSC_FRIENDSTATUSON},
        {
        "friendstatusoff", MSC_FRIENDSTATUSOFF},
        {
        "notintown", MSC_NOTINTOWN},
        {
        "attackpcgt", MSC_ATTACKPCGT},
        {
        "attackpcge", MSC_ATTACKPCGE},
        {
        "slavelt", MSC_SLAVELT},
        {
        "slavele", MSC_SLAVELE},
        {
        "closedattacked", MSC_CLOSEDATTACKED},
        {
        "longrangeattacked", MSC_LONGRANGEATTACKED},
        {
        "skillused", MSC_SKILLUSED},
        {
    "casttargeted", MSC_CASTTARGETED},}, cond2[] =
    {
        {
        "anybad", -1},
        {
        "stone", SC_STONE},
        {
        "freeze", SC_FREEZE},
        {
        "stan", SC_STAN},
        {
        "sleep", SC_SLEEP},
        {
        "poison", SC_POISON},
        {
        "curse", SC_CURSE},
        {
        "silence", SC_SILENCE},
        {
        "confusion", SC_CONFUSION},
        {
        "blind", SC_BLIND},
        {
        "hiding", SC_HIDING},
        {
    "sight", SC_SIGHT},}, state[] =
    {
        {
        "any", -1},
        {
        "idle", MSS_IDLE},
        {
        "walk", MSS_WALK},
        {
        "attack", MSS_ATTACK},
        {
        "dead", MSS_DEAD},
        {
        "loot", MSS_LOOT},
        {
    "chase", MSS_CHASE},}, target[] =
    {
        {
        "target", MST_TARGET},
        {
        "self", MST_SELF},
        {
        "friend", MST_FRIEND},
        {
        "around5", MST_AROUND5},
        {
        "around6", MST_AROUND6},
        {
        "around7", MST_AROUND7},
        {
        "around8", MST_AROUND8},
        {
        "around1", MST_AROUND1},
        {
        "around2", MST_AROUND2},
        {
        "around3", MST_AROUND3},
        {
        "around4", MST_AROUND4},
        {
    "around", MST_AROUND},};

    int  x;
    char *filename[] = { "db/mob_skill_db.txt", "db/mob_skill_db2.txt" };

    for (x = 0; x < 2; x++)
    {

        fp = fopen_ (filename[x], "r");
        if (fp == NULL)
        {
            if (x == 0)
                printf ("can't read %s\n", filename[x]);
            continue;
        }
        while (fgets (line, 1020, fp))
        {
            char *sp[20], *p;
            int  mob_id;
            struct mob_skill *ms;
            int  j = 0;

            if (line[0] == '/' && line[1] == '/')
                continue;

            memset (sp, 0, sizeof (sp));
            for (i = 0, p = line; i < 18 && p; i++)
            {
                sp[i] = p;
                if ((p = strchr (p, ',')) != NULL)
                    *p++ = 0;
            }
            if ((mob_id = atoi (sp[0])) <= 0)
                continue;

            if (strcmp (sp[1], "clear") == 0)
            {
                memset (mob_db[mob_id].skill, 0,
                        sizeof (mob_db[mob_id].skill));
                mob_db[mob_id].maxskill = 0;
                continue;
            }

            for (i = 0; i < MAX_MOBSKILL; i++)
                if ((ms = &mob_db[mob_id].skill[i])->skill_id == 0)
                    break;
            if (i == MAX_MOBSKILL)
            {
                printf
                    ("mob_skill: readdb: too many skill ! [%s] in %d[%s]\n",
                     sp[1], mob_id, mob_db[mob_id].jname);
                continue;
            }

            ms->state = atoi (sp[2]);
            for (j = 0; j < sizeof (state) / sizeof (state[0]); j++)
            {
                if (strcmp (sp[2], state[j].str) == 0)
                    ms->state = state[j].id;
            }
            ms->skill_id = atoi (sp[3]);
            ms->skill_lv = atoi (sp[4]);

            ms->permillage = atoi (sp[5]);
            ms->casttime = atoi (sp[6]);
            ms->delay = atoi (sp[7]);
            ms->cancel = atoi (sp[8]);
            if (strcmp (sp[8], "yes") == 0)
                ms->cancel = 1;
            ms->target = atoi (sp[9]);
            for (j = 0; j < sizeof (target) / sizeof (target[0]); j++)
            {
                if (strcmp (sp[9], target[j].str) == 0)
                    ms->target = target[j].id;
            }
            ms->cond1 = -1;
            for (j = 0; j < sizeof (cond1) / sizeof (cond1[0]); j++)
            {
                if (strcmp (sp[10], cond1[j].str) == 0)
                    ms->cond1 = cond1[j].id;
            }
            ms->cond2 = atoi (sp[11]);
            for (j = 0; j < sizeof (cond2) / sizeof (cond2[0]); j++)
            {
                if (strcmp (sp[11], cond2[j].str) == 0)
                    ms->cond2 = cond2[j].id;
            }
            ms->val[0] = atoi (sp[12]);
            ms->val[1] = atoi (sp[13]);
            ms->val[2] = atoi (sp[14]);
            ms->val[3] = atoi (sp[15]);
            ms->val[4] = atoi (sp[16]);
            if (sp[17] != NULL && strlen (sp[17]) > 2)
                ms->emotion = atoi (sp[17]);
            else
                ms->emotion = -1;
            mob_db[mob_id].maxskill = i + 1;
        }
        fclose_ (fp);
        printf ("read %s done\n", filename[x]);
    }
    return 0;
}

void mob_reload (void)
{
    /*
     * 
     * <empty monster database>
     * mob_read();
     * 
     */

    do_init_mob ();
}

/*==========================================
 * Circumference initialization of mob
 *------------------------------------------
 */
int do_init_mob (void)
{
    mob_readdb ();

    mob_readdb_mobavail ();
    mob_read_randommonster ();
    mob_readskilldb ();

    add_timer_func_list (mob_timer, "mob_timer");
    add_timer_func_list (mob_delayspawn, "mob_delayspawn");
    add_timer_func_list (mob_delay_item_drop, "mob_delay_item_drop");
    add_timer_func_list (mob_delay_item_drop2, "mob_delay_item_drop2");
    add_timer_func_list (mob_ai_hard, "mob_ai_hard");
    add_timer_func_list (mob_ai_lazy, "mob_ai_lazy");
    add_timer_func_list (mobskill_castend_id, "mobskill_castend_id");
    add_timer_func_list (mobskill_castend_pos, "mobskill_castend_pos");
    add_timer_func_list (mob_timer_delete, "mob_timer_delete");
    add_timer_interval (gettick () + MIN_MOBTHINKTIME, mob_ai_hard, 0, 0,
                        MIN_MOBTHINKTIME);
    add_timer_interval (gettick () + MIN_MOBTHINKTIME * 10, mob_ai_lazy, 0, 0,
                        MIN_MOBTHINKTIME * 10);

    return 0;
}