• 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!

TFS 1.X+ Nostatius Respawn monster

K

kowal67612

New Member
Joined
Nov 7, 2023
Messages
38
Reaction score
4
monsters respawn in a second, I have the spawn time set to 1600 and they still respawn in a second look me source spawn.cpp and spawn.h

LUA: 
/**
 * Tibia GIMUD Server - a free and open-source MMORPG server emulator
 * Copyright (C) 2019 Sabrehaven and Mark Samman <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "otpch.h"

#include "spawn.h"
#include "game.h"
#include "monster.h"
#include "configmanager.h"
#include "scheduler.h"

#include "pugicast.h"

extern ConfigManager g_config;
extern Monsters g_monsters;
extern Game g_game;

static constexpr int32_t MINSPAWN_INTERVAL = 1000;

bool Spawns::loadFromXml(const std::string& filename)
{
    if (loaded) {
        return true;
    }

    pugi::xml_document doc;
    pugi::xml_parse_result result = doc.load_file(filename.c_str());
    if (!result) {
        printXMLError("Error - Spawns::loadFromXml", filename, result);
        return false;
    }

    this->filename = filename;
    loaded = true;

    for (auto spawnNode : doc.child("spawns").children()) {
        Position centerPos(
            pugi::cast<uint16_t>(spawnNode.attribute("centerx").value()),
            pugi::cast<uint16_t>(spawnNode.attribute("centery").value()),
            pugi::cast<uint16_t>(spawnNode.attribute("centerz").value())
        );

        int32_t radius;
        pugi::xml_attribute radiusAttribute = spawnNode.attribute("radius");
        if (radiusAttribute) {
            radius = pugi::cast<int32_t>(radiusAttribute.value());
        } else {
            radius = -1;
        }

        for (auto childNode : spawnNode.children()) {
            if (strcasecmp(childNode.name(), "monster") == 0) {
                pugi::xml_attribute nameAttribute = childNode.attribute("name");
                if (!nameAttribute) {
                    continue;
                }

                Direction dir;

                pugi::xml_attribute directionAttribute = childNode.attribute("direction");
                if (directionAttribute) {
                    dir = static_cast<Direction>(pugi::cast<uint16_t>(directionAttribute.value()));
                } else {
                    dir = DIRECTION_NORTH;
                }

                Position pos(
                    centerPos.x + pugi::cast<uint16_t>(childNode.attribute("x").value()),
                    centerPos.y + pugi::cast<uint16_t>(childNode.attribute("y").value()),
                    centerPos.z
                );

                spawnList.emplace_front(pos, radius);
                Spawn& spawn = spawnList.front();

                uint32_t interval = uniform_random(pugi::cast<uint32_t>(childNode.attribute("spawntime").value()) * g_config.getNumber(ConfigManager::MIN_RATE_SPAWN), pugi::cast<uint32_t>(childNode.attribute("spawntime").value()) * g_config.getNumber(ConfigManager::MAX_RATE_SPAWN));
                if (interval > MINSPAWN_INTERVAL) {
                    uint32_t exInterval = g_config.getNumber(ConfigManager::RATE_SPAWN);
                    if (exInterval) {
                        spawn.addMonster(nameAttribute.as_string(), pos, dir, exInterval * 1000);
                    } else {
                        spawn.addMonster(nameAttribute.as_string(), pos, dir, interval);
                    }
                } else {
                    std::cout << "[Warning - Spawns::loadFromXml] " << nameAttribute.as_string() << ' ' << pos << " spawntime can not be less than " << MINSPAWN_INTERVAL / 1000 << " seconds." << std::endl;
                }
            } else if (strcasecmp(childNode.name(), "npc") == 0) {
                pugi::xml_attribute nameAttribute = childNode.attribute("name");
                if (!nameAttribute) {
                    continue;
                }

                Npc* npc = Npc::createNpc(nameAttribute.as_string());
                if (!npc) {
                    continue;
                }

                pugi::xml_attribute directionAttribute = childNode.attribute("direction");
                if (directionAttribute) {
                    npc->setDirection(static_cast<Direction>(pugi::cast<uint16_t>(directionAttribute.value())));
                }

                npc->setMasterPos(Position(
                    centerPos.x + pugi::cast<uint16_t>(childNode.attribute("x").value()),
                    centerPos.y + pugi::cast<uint16_t>(childNode.attribute("y").value()),
                    centerPos.z
                ), radius);
                npcList.push_front(npc);
            }
        }
    }
    return true;
}

void Spawns::startup()
{
    if (!loaded || isStarted()) {
        return;
    }

    for (Npc* npc : npcList) {
        g_game.placeCreature(npc, npc->getMasterPos(), false, true);
    }
    npcList.clear();

    for (Spawn& spawn : spawnList) {
        spawn.startup();
    }

    started = true;
}

void Spawns::clear()
{
    for (Spawn& spawn : spawnList) {
        spawn.stopEvent();
    }
    spawnList.clear();

    loaded = false;
    started = false;
    filename.clear();
}

bool Spawns::isInZone(const Position& centerPos, int32_t radius, const Position& pos)
{
    if (radius == -1) {
        return true;
    }

    return ((pos.getX() >= centerPos.getX() - radius) && (pos.getX() <= centerPos.getX() + radius) &&
            (pos.getY() >= centerPos.getY() - radius) && (pos.getY() <= centerPos.getY() + radius));
}

void Spawn::startSpawnCheck()
{
    if (checkSpawnEvent == 0) {
        checkSpawnEvent = g_scheduler.addEvent(createSchedulerTask(getInterval(), std::bind(&Spawn::checkSpawn, this)));
    }
}

Spawn::~Spawn()
{
    for (const auto& it : spawnedMap) {
        Monster* monster = it.second;
        monster->setSpawn(nullptr);
        monster->decrementReferenceCounter();
    }
}

bool Spawn::findPlayer(const Position& pos)
{
    SpectatorVec list;
    g_game.map.getSpectators(list, pos, false, true);
    for (Creature* spectator : list) {
        if (!spectator->getPlayer()->hasFlag(PlayerFlag_IgnoredByMonsters)) {
            return true;
        }
    }
    return false;
}

bool Spawn::isInSpawnZone(const Position& pos)
{
    return Spawns::isInZone(centerPos, radius, pos);
}

bool Spawn::spawnMonster(uint32_t spawnId, MonsterType* mType, const Position& pos, Direction dir, bool startup /*= false*/)
{
    std::unique_ptr<Monster> monster_ptr(new Monster(mType));
    if (startup) {
        //No need to send out events to the surrounding since there is no one out there to listen!
        if (!g_game.internalPlaceCreature(monster_ptr.get(), pos, true)) {
            return false;
        }
    } else {
        if (!g_game.placeCreature(monster_ptr.get(), pos, false, true)) {
            return false;
        }
    }

    Monster* monster = monster_ptr.release();
    monster->setDirection(dir);
    monster->setSpawn(this);
    monster->setMasterPos(pos);
    monster->incrementReferenceCounter();

    spawnedMap.insert(spawned_pair(spawnId, monster));
    spawnMap[spawnId].lastSpawn = OTSYS_TIME();
    return true;
}

uint32_t Spawn::getInterval() const
{
    uint32_t newInterval = interval;
   
    if (newInterval > 500000) {
        size_t playersOnline = g_game.getPlayersOnline();
        if (playersOnline <= 800) {
            if (playersOnline > 200) {
                newInterval = 200 * interval / (playersOnline / 2 + 100);
            }
        } else {
            newInterval = 2 * interval / 5;
        }
   
        return normal_random(newInterval / 2, newInterval);
    }

    return newInterval;
}

void Spawn::startup()
{
    for (const auto& it : spawnMap) {
        uint32_t spawnId = it.first;
        const spawnBlock_t& sb = it.second;
        spawnMonster(spawnId, sb.mType, sb.pos, sb.direction, true);
    }
}

void Spawn::checkSpawn()
{
    checkSpawnEvent = 0;

    cleanup();

    for (auto& it : spawnMap) {
        uint32_t spawnId = it.first;
        if (spawnedMap.find(spawnId) != spawnedMap.end()) {
            continue;
        }

        spawnBlock_t& sb = it.second;
        if (OTSYS_TIME() >= sb.lastSpawn + sb.interval) {
            if (findPlayer(sb.pos)) {
                sb.lastSpawn = OTSYS_TIME();
                continue;
            }

            spawnMonster(spawnId, sb.mType, sb.pos, sb.direction);
        }
    }

    if (spawnedMap.size() < spawnMap.size()) {
        checkSpawnEvent = g_scheduler.addEvent(createSchedulerTask(getInterval(), std::bind(&Spawn::checkSpawn, this)));
    }
}

void Spawn::cleanup()
{
    auto it = spawnedMap.begin();
    while (it != spawnedMap.end()) {
        uint32_t spawnId = it->first;
        Monster* monster = it->second;
        if (monster->isRemoved()) {
            if (spawnId != 0) {
                spawnMap[spawnId].lastSpawn = OTSYS_TIME();
            }

            monster->decrementReferenceCounter();
            it = spawnedMap.erase(it);
        } else {
            ++it;
        }
    }
}

bool Spawn::addMonster(const std::string& name, const Position& pos, Direction dir, uint32_t interval)
{
    MonsterType* mType = g_monsters.getMonsterType(name);
    if (!mType) {
        std::cout << "[Spawn::addMonster] Can not find " << name << std::endl;
        return false;
    }

    this->interval = std::min(this->interval, interval);

    spawnBlock_t sb;
    sb.mType = mType;
    sb.pos = pos;
    sb.direction = dir;
    sb.interval = interval;
    sb.lastSpawn = 0;

    uint32_t spawnId = spawnMap.size() + 1;
    spawnMap[spawnId] = sb;
    return true;
}

void Spawn::removeMonster(Monster* monster)
{
    for (auto it = spawnedMap.begin(), end = spawnedMap.end(); it != end; ++it) {
        if (it->second == monster) {
            monster->decrementReferenceCounter();
            spawnedMap.erase(it);
            break;
        }
    }
}

void Spawn::stopEvent()
{
    if (checkSpawnEvent != 0) {
        g_scheduler.stopEvent(checkSpawnEvent);
        checkSpawnEvent = 0;
    }
}
Click to expand...












spawn.h
LUA: 
/**
 * Tibia GIMUD Server - a free and open-source MMORPG server emulator
 * Copyright (C) 2019 Sabrehaven and Mark Samman <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef FS_SPAWN_H_1A86089E080846A9AE53ED12E7AE863B
#define FS_SPAWN_H_1A86089E080846A9AE53ED12E7AE863B

#include "tile.h"
#include "position.h"

class Monster;
class MonsterType;
class Npc;

struct spawnBlock_t {
    Position pos;
    MonsterType* mType;
    int64_t lastSpawn;
    uint32_t interval;
    Direction direction;
};

class Spawn
{
    public:
        Spawn(Position pos, int32_t radius) : centerPos(std::move(pos)), radius(radius) {}
        ~Spawn();

        // non-copyable
        Spawn(const Spawn&) = delete;
        Spawn& operator=(const Spawn&) = delete;

        bool addMonster(const std::string& name, const Position& pos, Direction dir, uint32_t interval);
        void removeMonster(Monster* monster);

        uint32_t getInterval() const;
        void startup();

        void startSpawnCheck();
        void stopEvent();

        bool isInSpawnZone(const Position& pos);
        void cleanup();

    private:
        //map of the spawned creatures
        typedef std::multimap<uint32_t, Monster*> SpawnedMap;
        typedef SpawnedMap::value_type spawned_pair;
        SpawnedMap spawnedMap;

        //map of creatures in the spawn
        std::map<uint32_t, spawnBlock_t> spawnMap;

        Position centerPos;
        int32_t radius;

        uint32_t interval = 60000;
        uint32_t checkSpawnEvent = 0;

        static bool findPlayer(const Position& pos);
        bool spawnMonster(uint32_t spawnId, MonsterType* mType, const Position& pos, Direction dir, bool startup = false);
        void checkSpawn();
};

class Spawns
{
    public:
        static bool isInZone(const Position& centerPos, int32_t radius, const Position& pos);

        bool loadFromXml(const std::string& filename);
        void startup();
        void clear();

        bool isStarted() const {
            return started;
        }

    private:
        std::forward_list<Npc*> npcList;
        std::forward_list<Spawn> spawnList;
        std::string filename;
        bool loaded = false;
        bool started = false;
};

#endif
 
Sort by date Sort by votes
Spróbuj z moim:

Zamień w spawn.cpp u siebie:

C++: 
                uint32_t interval = uniform_random(pugi::cast<uint32_t>(childNode.attribute("spawntime").value()) * g_config.getNumber(ConfigManager::MIN_RATE_SPAWN), pugi::cast<uint32_t>(childNode.attribute("spawntime").value()) * g_config.getNumber(ConfigManager::MAX_RATE_SPAWN));

na

C++: 
                uint32_t interval = pugi::cast<uint32_t>(childNode.attribute("spawntime").value()) * 1000;
 
Upvote 0 Downvote
LUA: 
-- Custom
clientVersion = 800
knightCloseAttackDamageIncreasePercent = -1
paladinRangeAttackDamageIncreasePercent = -1
corpseOwnerEnabled = false
uhTrap = false
ropeSpotBlock = false
showMonsterLoot = true
blockHeight = false
dropItems = false
marketOfferDuration = 7 * 24 * 60 * 60
premiumToCreateMarketOffer = false

-- Combat settings
-- NOTE: valid values for worldType are: "pvp", "no-pvp" and "pvp-enforced"
worldType = "pvp"
hotkeyAimbotEnabled = true
protectionLevel = 1
pzLocked = 20000
removeChargesFromRunes = true
stairJumpExhaustion = 0
experienceByKillingPlayers = true
expFromPlayersLevelRange = 50
distanceWeaponsDropOnGround = false
removeWeaponAmmunition = "true"

-- Skull System
banLength = 2 * 24 * 60 * 60
whiteSkullTime = 15 * 60
redSkullTime = 2 * 24 * 60 * 60
killsDayRedSkull = 4
killsWeekRedSkull = 12
killsMonthRedSkull = 35
killsDayBanishment = 7
killsWeekBanishment = 18
killsMonthBanishment = 60

-- Connection Config
-- NOTE: maxPlayers set to 0 means no limit
ip = ""
bindOnlyGlobalAddress = false
loginProtocolPort = 7171
gameProtocolPort = 7172
statusProtocolPort = 7171
maxPlayers = 0
motd = "Welcome to Wampirka!"
onePlayerOnlinePerAccount = false
allowClones = false
serverName = "Vampirka"
statusTimeout = 5000
replaceKickOnLogin = true
maxPacketsPerSecond = 50
packetCompression = false
autoStackCumulatives = true
moneyRate = 1

-- Deaths
-- NOTE: Leave deathLosePercent as -1 if you want to use the default
-- death penalty formula. For the old formula, set it to 10. For
-- no skill/experience loss, set it to 0.
deathLosePercent = 10

-- Houses
housePriceEachSQM = 1000
houseRentPeriod = "monthly"

-- Item Usage
timeBetweenActions = 200
timeBetweenExActions = 1000

-- Map
-- NOTE: set mapName WITHOUT .otbm at the end
mapName = "map"
mapAuthor = "CipSoft"

-- MySQL
mysqlHost = ""
mysqlUser = ""
mysqlPass = ""
mysqlDatabase = ""
mysqlPort = 3306
mysqlSock = ""

-- Misc.
allowChangeOutfit = true
freePremium = true
kickIdlePlayerAfterMinutes = 15
maxMessageBuffer = 8

-- Character Rooking
-- Level threshold is the level requirement to teleport players back to newbie town
teleportNewbies = true
newbieTownId = 11
newbieLevelThreshold = 5

-- Rates
-- NOTE: rateExp is not used if you have enabled stages in data/XML/stages.xml
rateExp = 20
rateSkill = 3
rateLoot = 3
rateMagic = 3
rateSpawn = 1
rateSpawnMin = 1
rateSpawnMax = 1

-- Monsters
deSpawnRange = 1
deSpawnRadius = 50

-- Scripts
warnUnsafeScripts = true
convertUnsafeScripts = true

-- Startup
-- NOTE: defaultPriority only works on Windows and sets process
-- priority, valid values are: "normal", "above-normal", "high"
defaultPriority = "high"
startupDatabaseOptimization = true

-- Status server information
ownerName = "Erikas"
ownerEmail = ""
url = "https://vampirka.eu"
location = "Poland"
 
Upvote 0 Downvote
spróbuj :
na moim spawn.cpp
rateSpawn <span>=</span> <span>1</span>
a
rateSpawnMin <span>=</span> <span>1</span><br>rateSpawnMax <span>=</span> <span>1</span>
wyrzuć z configu

albo na Twoim spawn.cpp
wyrzuć rateSpawn <span>=</span> <span>1</span>
rateSpawnMin <span>=</span> <span>1</span><br>rateSpawnMax <span>=</span> <span>2</span>
 
Upvote 0 Downvote

Similar threads

Demoncrawler
  • Question Question
C++ This old code isn't working anymore
Replies
1
Views
123
czouski
czouski
johnsamir
  • Question Question
Solved two bugs generated by me where should i look for?
Replies
4
Views
293
johnsamir
johnsamir
tiag0_bn
  • Question Question
Interval Monster Attack otx2
Replies
0
Views
93
tiag0_bn
tiag0_bn
Itutorial
  • Question Question
Compiling Luavarient errors after adding .clang-format
Replies
0
Views
70
Itutorial
Itutorial
C
  • Solved
C++ Parcel without writing city name
Replies
4
Views
578
clouf
C
Back
Top