• There is NO official Otland's Discord server and NO official Otland's server list. The Otland's Staff does not manage any Discord server or server list. Moderators or administrator of any Discord server or server lists have NO connection to the Otland's Staff. Do not get scammed!

C++ UH_TRAP not working, HELP ADD FEATURE TO TFS 1.5

Felipe93

Felipe93

Ghost Member
Joined
Mar 21, 2015
Messages
1,990
Solutions
9
Reaction score
334
Location
Chile
Hello I'm trying to add uh trap via sources to my server the code works but it does not matter if i turn uhtrap true or false.
can somebody help me? here are the codes edited
Lua: 
Creature* Tile::getTopCreature() const 
{
    if (const CreatureVector* creatures = getCreatures()) {
        if (!creatures->empty()) {
            return *creatures->begin();
        }
    }
     if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
        if (const CreatureVector* creatures = getCreatures()) {
            if (!creatures->empty()) {
                return *creatures->rbegin();
            }
        }
    }
    return nullptr;
}

Code: 
/*const Creature* topVisibleCreature = tile->getBottomVisibleCreature(player);
    if (blockingCreature && topVisibleCreature)*/
    const Creature* visibleCreature = tile->getTopCreature();//agregado uh trap
    if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
        visibleCreature = tile->getBottomCreature();
    }
    if (blockingCreature && visibleCreature) {
        player->sendCancelMessage(RETURNVALUE_NOTENOUGHROOM);//agregado uh trap
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    } else if (blockingSolid && tile->hasFlag(TILESTATE_BLOCKSOLID)) {
        player->sendCancelMessage(RETURNVALUE_NOTENOUGHROOM);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    //if (needTarget && !topVisibleCreature) {
    if (needTarget && !visibleCreature) {//agregado uh trap
        player->sendCancelMessage(RETURNVALUE_CANONLYUSETHISRUNEONCREATURES);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    /*if (aggressive && needTarget && topVisibleCreature && player->hasSecureMode()) {
        const Player* targetPlayer = topVisibleCreature->getPlayer();*/
    if (aggressive && needTarget && visibleCreature && player->hasSecureMode()) {//agregado uh trap
        const Player* targetPlayer = visibleCreature->getPlayer();//agregado uh trap
        if (targetPlayer && targetPlayer != player && player->getSkullClient(targetPlayer) == SKULL_NONE && !Combat::isInPvpZone(player, targetPlayer)) {
            player->sendCancelMessage(RETURNVALUE_TURNSECUREMODETOATTACKUNMARKEDPLAYERS);
            g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
            return false;
        }
    }
 
Sort by date Sort by votes
C++: 
Creature* Tile::getTopCreature() const
{
    if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
        if (const CreatureVector* creatures = getCreatures()) {
            if (!creatures->empty()) {
                return *creatures->rbegin();
            }
        }
    }

    if (const CreatureVector* creatures = getCreatures()) {
        if (!creatures->empty()) {
            return *creatures->begin();
        }
    }

    return nullptr;
}

Or

C++: 
Creature* Tile::getTopCreature() const
{
    if (const CreatureVector* creatures = getCreatures()) {
        if (!creatures->empty()) {
            return (g_config.getBoolean(ConfigManager::UH_TRAP) ? *creatures->rbegin() : *creatures->begin());
        }
    }
    
    return nullptr;
}
 
Upvote 0 Downvote
Roddet said:
C++: 
Creature* Tile::getTopCreature() const
{
    if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
        if (const CreatureVector* creatures = getCreatures()) {
            if (!creatures->empty()) {
                return *creatures->rbegin();
            }
        }
    }

    if (const CreatureVector* creatures = getCreatures()) {
        if (!creatures->empty()) {
            return *creatures->begin();
        }
    }

    return nullptr;
}

Or

C++: 
Creature* Tile::getTopCreature() const
{
    if (const CreatureVector* creatures = getCreatures()) {
        if (!creatures->empty()) {
            return (g_config.getBoolean(ConfigManager::UH_TRAP) ? *creatures->rbegin() : *creatures->begin());
        }
    }
  
    return nullptr;
}
Click to expand...
would you mind to help me with the other piece of code pls? it works but it does not for when i enable or disable uhtrap


what i got so far, excluding configmanager.cpp & h
tile.cpp
C++: 
[CODE=lua]Creature* Tile::getTopCreature() const
{
    if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
        if (const CreatureVector* creatures = getCreatures()) {
            if (!creatures->empty()) {
                return *creatures->rbegin();
            }
        }
    }

    if (const CreatureVector* creatures = getCreatures()) {
        if (!creatures->empty()) {
            return *creatures->begin();
        }
    }

    return nullptr;
}
[/CODE]
combat.cpp
C++: 
[CODE]void Combat::doCombat(Creature* caster, const Position& position) const
{
    //area combat callback function
    if (params.combatType != COMBAT_NONE) {
        CombatDamage damage = getCombatDamage(caster, nullptr);
        doAreaCombat(caster, position, area.get(), damage, params);
    } else {
        auto tiles = caster ? getCombatArea(caster->getPosition(), position, area.get()) : getCombatArea(position, position, area.get());

        SpectatorVec spectators;
        uint32_t maxX = 0;
        uint32_t maxY = 0;

        //calculate the max viewable range
        for (Tile* tile : tiles) {
            const Position& tilePos = tile->getPosition();

            uint32_t diff = Position::getDistanceX(tilePos, position);
            if (diff > maxX) {
                maxX = diff;
            }

            diff = Position::getDistanceY(tilePos, position);
            if (diff > maxY) {
                maxY = diff;
            }
        }

        const int32_t rangeX = maxX + Map::maxViewportX;
        const int32_t rangeY = maxY + Map::maxViewportY;
        g_game.map.getSpectators(spectators, position, true, true, rangeX, rangeX, rangeY, rangeY);

        bool Second_Continue = true;

        postCombatEffects(caster, position, params);

        for (Tile* tile : tiles) {
            if (canDoCombat(caster, tile, params.aggressive) != RETURNVALUE_NOERROR) {
                continue;
            }

            combatTileEffects(spectators, caster, tile, params);

            if (CreatureVector* creatures = tile->getCreatures()) {
                //const Creature* topCreature = tile->getTopCreature();
                for (Creature* creature : *creatures) {
                    if (params.targetCasterOrTopMost) {
                        /*if (caster && caster->getTile() == tile) {
                            if (creature != caster) {
                                continue;*/
                        if (!g_config.getBoolean(ConfigManager::UH_TRAP) &&
                        (caster && caster->getTile() == tile)){
                        if (creature != caster) {
                            Second_Continue = false;
                            }
                        /*} else if (creature != topCreature) {*/
                        }
                        else if (creature == tile->getBottomCreature()) {
                            Second_Continue = false;
                        }

                        if (Second_Continue) {
                            continue;
                        }
                    }

                    if (!params.aggressive || (caster != creature && Combat::canDoCombat(caster, creature) == RETURNVALUE_NOERROR)) {
                        for (const auto& condition : params.conditionList) {
                            if (caster == creature || !creature->isImmune(condition->getType())) {
                                Condition* conditionCopy = condition->clone();
                                if (caster) {
                                    conditionCopy->setParam(CONDITION_PARAM_OWNER, caster->getID());
                                }

                                //TODO: infight condition until all aggressive conditions has ended
                                creature->addCombatCondition(conditionCopy);
                            }
                        }
                    }

                    if (params.dispelType == CONDITION_PARALYZE) {
                        creature->removeCondition(CONDITION_PARALYZE);
                    } else {
                        creature->removeCombatCondition(params.dispelType);
                    }

                    if (params.targetCallback) {
                        params.targetCallback->onTargetCombat(caster, creature);
                    }

                    if (params.targetCasterOrTopMost) {
                        break;
                    }
                }
            }
        }
    }
}
[/CODE]

spells.cpp
C++: 
bool Spell::playerRuneSpellCheck(Player* player, const Position& toPos)
{
    if (!playerSpellCheck(player)) {
        return false;
    }

    if (toPos.x == 0xFFFF) {
        return true;
    }

    const Position& playerPos = player->getPosition();
    if (playerPos.z > toPos.z) {
        player->sendCancelMessage(RETURNVALUE_FIRSTGOUPSTAIRS);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    } else if (playerPos.z < toPos.z) {
        player->sendCancelMessage(RETURNVALUE_FIRSTGODOWNSTAIRS);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    Tile* tile = g_game.map.getTile(toPos);
    if (!tile) {
        player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    if (range != -1 && !g_game.canThrowObjectTo(playerPos, toPos, true, true, range, range)) {
        player->sendCancelMessage(RETURNVALUE_DESTINATIONOUTOFREACH);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    ReturnValue ret = Combat::canDoCombat(player, tile, aggressive);
    if (ret != RETURNVALUE_NOERROR) {
        player->sendCancelMessage(ret);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    /*const Creature* topVisibleCreature = tile->getBottomVisibleCreature(player);
    if (blockingCreature && topVisibleCreature)*/
    const Creature* visibleCreature = tile->getTopCreature();//agregado uh trap
    if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
        visibleCreature = tile->getBottomCreature();
    }
    if (blockingCreature && visibleCreature) {
        player->sendCancelMessage(RETURNVALUE_NOTENOUGHROOM);//agregado uh trap
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    } else if (blockingSolid && tile->hasFlag(TILESTATE_BLOCKSOLID)) {
        player->sendCancelMessage(RETURNVALUE_NOTENOUGHROOM);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    //if (needTarget && !topVisibleCreature) {
    if (needTarget && !visibleCreature) {//agregado uh trap
        player->sendCancelMessage(RETURNVALUE_CANONLYUSETHISRUNEONCREATURES);
        g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
        return false;
    }

    /*if (aggressive && needTarget && topVisibleCreature && player->hasSecureMode()) {
        const Player* targetPlayer = topVisibleCreature->getPlayer();*/
    if (aggressive && needTarget && visibleCreature && player->hasSecureMode()) {//agregado uh trap
        const Player* targetPlayer = visibleCreature->getPlayer();//agregado uh trap
        if (targetPlayer && targetPlayer != player && player->getSkullClient(targetPlayer) == SKULL_NONE && !Combat::isInPvpZone(player, targetPlayer)) {
            player->sendCancelMessage(RETURNVALUE_TURNSECUREMODETOATTACKUNMARKEDPLAYERS);
            g_game.addMagicEffect(player->getPosition(), CONST_ME_POFF);
            return false;
        }
    }
    return true;
}
spells.cpp
C++: 
bool RuneSpell::executeUse(Player* player, Item* item, const Position&, Thing* target, const Position& toPosition, bool isHotkey)
{
    if (!playerRuneSpellCheck(player, toPosition)) {
        return false;
    }

    if (!scripted) {
        return false;
    }

    LuaVariant var;

    if (needTarget) {
        var.type = VARIANT_NUMBER;

        if (target == nullptr) {
            Tile* toTile = g_game.map.getTile(toPosition);
            if (toTile) {
                const Creature* visibleCreature = toTile->getTopVisibleCreature(player); //getBottomVisibleCreature(player);
                if (g_config.getBoolean(ConfigManager::UH_TRAP)) {
                    visibleCreature = toTile->getBottomCreature();
                }
                if (visibleCreature) {
                    var.number = visibleCreature->getID();
                }
            }
        } else {
            var.number = target->getCreature()->getID();
        }
    } else {
        var.type = VARIANT_POSITION;
        var.pos = toPosition;
    }

    if (!internalCastSpell(player, var, isHotkey)) {
        return false;
    }

    postCastSpell(player);

    target = g_game.getCreatureByID(var.number);
    if (getPzLock() && target) {
        player->onAttackedCreature(target->getCreature());
    }

    if (hasCharges && item && g_config.getBoolean(ConfigManager::REMOVE_RUNE_CHARGES)) {
        int32_t newCount = std::max<int32_t>(0, item->getSubType() - 1);
        g_game.transformItem(item, item->getID(), newCount);
    }
    return true;
}
 
Last edited:
Upvote 0 Downvote

Similar threads

Jpstafe
  • Question
C++ Skull system, help me do this
Replies
11
Views
785
Jpstafe
Jpstafe
L
  • Question
TFS 0.X Help! "You may not attack this creature"
Replies
5
Views
387
lSenturion2
L
Back
Top