Exemple #1
0
int skill_power_bl(dumb_ptr<block_list> bl, SkillID skill)
{
    if (bl->bl_type == BL::PC)
        return skill_power(bl->is_player(), skill);
    else
        return 0;
}
Exemple #2
0
// HP通知の必要性検査用(map_foreachinmoveareaから呼ばれる)
void party_send_hp_check(dumb_ptr<block_list> bl, int party_id, int *flag)
{
    dumb_ptr<map_session_data> sd;

    nullpo_retv(bl);
    sd = bl->is_player();

    if (sd->status.party_id == party_id)
    {
        *flag = 1;
        sd->party_hp = -1;
    }
}
static
void entity_warp(dumb_ptr<block_list> target, map_local *destm, int destx, int desty)
{
    if (target->bl_type == BL::PC || target->bl_type == BL::MOB)
    {

        switch (target->bl_type)
        {
        case BL::PC:
        {
            dumb_ptr<map_session_data> character = target->is_player();
            clif_clearchar(character, BeingRemoveWhy::WARPED);
            map_delblock(character);
            character->bl_x = destx;
            character->bl_y = desty;
            character->bl_m = destm;

            pc_touch_all_relevant_npcs(character);

            // Note that touching NPCs may have triggered warping and thereby updated x and y:
            MapName map_name = character->bl_m->name_;

            // Warp part #1: update relevant data, interrupt trading etc.:
            pc_setpos(character, map_name, character->bl_x, character->bl_y, BeingRemoveWhy::GONE);
            // Warp part #2: now notify the client
            clif_changemap(character, map_name,
                           character->bl_x, character->bl_y);
            break;
        }
        case BL::MOB:
            target->bl_x = destx;
            target->bl_y = desty;
            target->bl_m = destm;
            clif_fixmobpos(target->is_mob());
            break;
        }
    }
}
Exemple #4
0
static
FString show_entity(dumb_ptr<block_list> entity)
{
    switch (entity->bl_type)
    {
        case BL::PC:
            return entity->is_player()->status.name.to__actual();
        case BL::NPC:
            return entity->is_npc()->name;
        case BL::MOB:
            return entity->is_mob()->name;
        case BL::ITEM:
            assert (0 && "There is no way this code did what it was supposed to do!");
            /* Sorry about this one... */
            // WTF? item_data is a struct item, not a struct item_data
            // return ((struct item_data *) (&entity->is_item()->item_data))->name;
            abort();
        case BL::SPELL:
            return {"%invocation(ERROR:this-should-not-be-an-entity)"};
        default:
            return {"%unknown-entity"};
    }
}
Exemple #5
0
static
void ladmin_itemfrob_c2(dumb_ptr<block_list> bl, ItemNameId source_id, ItemNameId dest_id)
{
#define IFIX(v) if (v == source_id) {v = dest_id; }
#define FIX(item) ladmin_itemfrob_fix_item(source_id, dest_id, &item)

    if (!bl)
        return;

    switch (bl->bl_type)
    {
        case BL::PC:
        {
            dumb_ptr<map_session_data> pc = bl->is_player();

            for (IOff0 j : IOff0::iter())
                IFIX(pc->status.inventory[j].nameid);
            // cart is no longer supported
            // IFIX(pc->status.weapon);
            IFIX(pc->status.shield);
            IFIX(pc->status.head_top);
            IFIX(pc->status.head_mid);
            IFIX(pc->status.head_bottom);

            Option<P<Storage>> stor_ = account2storage2(pc->status_key.account_id);
            if OPTION_IS_SOME(stor, stor_)
            {
                for (SOff0 j : SOff0::iter())
                    FIX(stor->storage_[j]);
            }

            for (IOff0 j : IOff0::iter())
            {
                P<struct item_data> item = TRY_UNWRAP(pc->inventory_data[j], continue);
                if (item->nameid == source_id)
                {
                    item->nameid = dest_id;
                    if (bool(item->equip))
                        pc_unequipitem(pc, j, CalcStatus::NOW);
                    item->nameid = dest_id;
                }
            }

            break;
        }

        case BL::MOB:
        {
            dumb_ptr<mob_data> mob = bl->is_mob();
            for (Item& itm : mob->lootitemv)
                FIX(itm);
            break;
        }

        case BL::ITEM:
        {
            dumb_ptr<flooritem_data> item = bl->is_item();
            FIX(item->item_data);
            break;
        }
    }
#undef FIX
#undef IFIX
}
static
void find_entities_in_area_c(dumb_ptr<block_list> target,
                             std::vector<int> *entities_vp,
                             FOREACH_FILTER filter)
{
    switch (target->bl_type)
    {

    case BL::PC:
        if (filter == FOREACH_FILTER::PC
                || filter == FOREACH_FILTER::ENTITY
                || (filter == FOREACH_FILTER::TARGET
                    && target->bl_m->flag.pvp))
            break;
        else if (filter == FOREACH_FILTER::SPELL)
        {   /* Check all spells bound to the caster */
            dumb_ptr<invocation> invoc = target->is_player()->active_spells;
            /* Add all spells locked onto thie PC */

            while (invoc)
            {
                entities_vp->push_back(invoc->bl_id);
                invoc = invoc->next_invocation;
            }
        }
        return;

    case BL::MOB:
        if (filter == FOREACH_FILTER::MOB
                || filter == FOREACH_FILTER::ENTITY
                || filter == FOREACH_FILTER::TARGET)
            break;
        else
            return;

    case BL::SPELL:
        if (filter == FOREACH_FILTER::SPELL)
        {
            dumb_ptr<invocation> invocation = target->is_spell();

            /* Check whether the spell is `bound'-- if so, we'll consider it iff we see the caster(case BL::PC). */
            if (bool(invocation->flags & INVOCATION_FLAG::BOUND))
                return;
            else
                break;      /* Add the spell */
        }
        else
            return;

    case BL::NPC:
        if (filter == FOREACH_FILTER::NPC)
            break;
        else
            return;

    default:
        return;
    }

    entities_vp->push_back(target->bl_id);
}