Repack PZ SEASON 9.5 IGCN

**lico** · 25/09/2017, 01:21 PM

Resolvido.
@[Somente membros podem ver os links. ]

era o gs que nao dava certo. peguei o do seu post funcionou normal. obrigado

**BaLLesTra** · 05/10/2017, 12:11 AM

@[Somente membros podem ver os links. ],

estou com um problema onde ao passar um item no trade informa que o inventário esta full.

Alguma solução?

**roxasl** · 01/11/2017, 10:51 AM

bom dia estou testando esse gs mais ao clica no editor de contas ele fala que nao conecto ao banco de dados ja mudei a senha em configura mais continua do mesmo jeito ja segui tutorial do mento mais nada tbm 1 vez aqui no forum desculpa se postei errado

boa tarde bom depois de muita dor de cabeça consegui resolver

onde ta Address eu tirei o (local) e deixei que nem aii em baixo mais acho que so e tira os ( ) que ja resolve

Username = sa ; User to connect to the Database
Password = ; Password to connect to the Database
Address = 127.0.0.1 ; (local) if the SQL Server is in the same PC and User
Port = 1433 ; TCP Port to use to connect to the SQL Server
MuOnlineDatabase = [MuOnline] ; Database name for main MuOnline database - add [ ] to the value if the database name contain numbers or special characters
Me_MuOnlineDatabase = [MuOnline] ; Database name for your Accounts (MEMB_INFO and MEMB_STAT tables) - add [ ] to the value if the database name contain numbers or special characters
EventsDatabase = [Events] ; Database name for Events database - add [ ] to the value if the database name contain numbers or special characters
RankingDatabase = [Ranking] ; Database name for Ranking database - add [ ] to the value if the database name contain numbers or special characters
BattleCoreDatabase = [BattleCore]

**Zuko12** · 07/11/2017, 12:34 PM

pls share source

**ADMTec** · 01/12/2017, 02:19 PM

Alguem poderia adicionar a esse muserver um custum que tem no Zteam que eu acho muito interessante para bonificar players em eventos.
e o MonsterSpawner.xml
em Vermelho e define um item que quando ele e dropado vai criar um Spot Temporário
em Amarelo e definido o mostro que vai spawnar e tambem a quantidade e o tempo de duração.
em Verde e definido se o spor criado vai ser privado ou nao(se for privado so quem dropou o item pode atacar os m onstros.
em Azul e definido se a party de quem dropo o item vai poder atacar.
em Laranja e definido se a guilde de quem dropo o item vai poder atacar.
<monsterspawner>

<item type="14" index="300">
<spawn monster="20" count="30" duration="60" />

<private active="true">
<party>true</party>
<guild>false</guild>
</private>
</item>


<item type="14" index="301">
<spawn monster="62" count="30" duration="60" />

<private active="true">
<party>true</party>
<guild>false</guild>
</private>
</item>


<item type="14" index="302">
<spawn monster="291" count="30" duration="60" />

<private active="true">
<party>true</party>
<guild>false</guild>
</private>
</item>
</monsterspawner>

aqui fica os código que eu pegue da source da Zteam

MonsterSpawner.cpp

Código HTML:

#include "stdafx.h"
#include "MonsterSpawner.h"
#include "GameMain.h"
#include "..\pugixml\pugixml.hpp"

MonsterSpawnerMng* MonsterSpawnerMng::m_Instance = NULL;

MonsterSpawnerMng::MonsterSpawnerMng() {
    m_WorkPool.clear();
    //m_ItemData.clear();
}

MonsterSpawnerMng::~MonsterSpawnerMng() {
    // lifetime instance...
}

void MonsterSpawnerMng::Load() {
    m_Loaded = false;
    Init();
    Read(gDirPath.GetNewPath(FILE_CUSTOM_MONSTERSPAWNER));
}

void MonsterSpawnerMng::Init() {
    m_ItemData.clear();
}

void MonsterSpawnerMng::Read(const char *File) {
    using namespace pugi;
    xml_document Document;
    xml_parse_result Result = Document.load_file(File);
    if (Result.status != status_ok) {
        MsgBox("[MonsterSpawnerMng] File %s not found!", File);
        return;
    }
    xml_node nodeMain = Document.child("monsterspawner");
    for (xml_node nodeIt = nodeMain.child("item"); nodeIt; nodeIt = nodeIt.next_sibling()) {
        MonsterSpawnerItemInfo newItem = { 0 };
        newItem.itemCategory = nodeIt.attribute("type").as_int(-1);
        newItem.itemIndex = nodeIt.attribute("index").as_int(-1);
        newItem.spawnMonsterId = nodeIt.child("spawn").attribute("monster").as_int(-1);
        newItem.spawnMonsterCount = nodeIt.child("spawn").attribute("count").as_int(-1);
        newItem.spawnDuration = nodeIt.child("spawn").attribute("duration").as_int(-1);
        newItem.isPrivate = nodeIt.child("private").attribute("active").as_bool();
        newItem.isPrivateParty = nodeIt.child("private").child("party").text().as_bool();
        newItem.isPrivateGuild = nodeIt.child("private").child("guild").text().as_bool();
        m_ItemData.push_back(newItem);
    }
    LogAddTD("[MonsterSpawnerMng] loaded %d node(s)", m_ItemData.size());
    m_Loaded = true;
}

void MonsterSpawnerMng::procRun() {

    for (size_t i = 0; i < m_WorkPool.size(); i++) {

        if (m_WorkPool[i].isEmpty()) {
            continue;
        }
        if (m_WorkPool[i].isExpired()) {
            LogAddTD("[MonsterSpawnerMng] [%s] spot duration is expired, slot cleared",
                m_WorkPool[i].ownerName.c_str());
            m_WorkPool[i].clearSlot();
        }
    }
}

void MonsterSpawnerMng::procRegen(short MonsterIndex) {
    gObj[MonsterIndex].X = gObj[MonsterIndex].StartX;
    gObj[MonsterIndex].Y = gObj[MonsterIndex].StartY;
    gObj[MonsterIndex].MTX = gObj[MonsterIndex].X;
    gObj[MonsterIndex].MTY = gObj[MonsterIndex].Y;
    gObj[MonsterIndex].m_ActState.Emotion = 1;
    gObj[MonsterIndex].m_ActState.EmotionCount = 1;
}

bool MonsterSpawnerMng::procCreate(short UserIndex, int ItemCode) {
    MonsterSpawnerItemInfo* tmpItemInfo = getItemInfo(ItemCode);
    if (tmpItemInfo == NULL) {
        return false;
    }
    int tmpSlotIndex = getEmptySlot();
    if (tmpSlotIndex == -1) {
        MonsterSpawnerWorkNode newNode;
        newNode.setSlot(UserIndex, tmpItemInfo);
        m_WorkPool.push_back(newNode);
    } else {
        m_WorkPool[tmpSlotIndex].setSlot(UserIndex, tmpItemInfo);
    }
    LogAddTD("[MonsterSpawnerMng] [%s][%s] spot has been created (monster: %d, count: %d, duration: %d, map: %d (%d:%d))", 
        gObj[UserIndex].AccountID, gObj[UserIndex].Name, tmpItemInfo->spawnMonsterId, tmpItemInfo->spawnMonsterCount,
        tmpItemInfo->spawnDuration, gObj[UserIndex].MapNumber, gObj[UserIndex].X, gObj[UserIndex].Y);
    return true;
}

bool MonsterSpawnerMng::isPrivate(short UserIndex, short MonsterIndex) {
    LPOBJ tmpAttacker = &gObj[UserIndex];
    LPOBJ tmpMonster = &gObj[MonsterIndex];
    LPOBJ tmpOwner = NULL;
    MonsterSpawnerWorkNode* tmpNode = NULL;
    MonsterSpawnerItemInfo* tmpItem = NULL;

    for (size_t i = 0; i < m_WorkPool.size(); i++) { // select node

        if (m_WorkPool[i].isMonster(MonsterIndex)) {
            tmpNode = &m_WorkPool[i];
            break;
        }
    }
    if (tmpNode == NULL) { // node not founded, spot unblocked
        return false;
    }
    if (tmpNode->isOwner(tmpAttacker->Name)) { // owner
        return false;
    }
    tmpItem = getItemInfo(tmpNode->itemCode);
    if (tmpItem == NULL) { // rules for node not founded, spot unblocked
        return false;
    }
    if (!tmpItem->isPrivate) { // spot not privated by rules
        return false;
    }
    for (int i = OBJ_STARTUSERINDEX; i < OBJMAX; i++) { // select live owner
        if (gObj[i].Connected >= PLAYER_PLAYING) {
            if (tmpNode->isOwner(gObj[i].Name)) {
                tmpOwner = &gObj[i];
                break;
            }
        }
    }
    if (tmpOwner == NULL) { // spot have owner, but owner is offline, cant check rules - block by rules
        MsgOutput(UserIndex, "Monster is privated by %s", tmpNode->ownerName.c_str());
        return true;
    }
    if (tmpItem->isPrivateParty && tmpOwner->PartyNumber >= 0) { // spot is not privated for party members
        if (tmpOwner->PartyNumber == tmpAttacker->PartyNumber) {
            return false;
        }
    }
    if (tmpItem->isPrivateGuild && tmpOwner->GuildNumber > 0) { // spot is not privated for guild members
        if (tmpOwner->GuildNumber == tmpAttacker->GuildNumber) {
            return false;
        }
    }
    MsgOutput(UserIndex, "Monster is privated by %s", tmpNode->ownerName.c_str());
    return true;
}

bool MonsterSpawnerMng::isEventMonster(short MonsterIndex) {

    for (size_t i = 0; i < m_WorkPool.size(); i++) {

        if (m_WorkPool[i].isMonster(MonsterIndex)) {
            return true;
        }
    }
    return false;
}

bool MonsterSpawnerMng::isKeyItem(int ItemCode) {
    if (getItemInfo(ItemCode) != NULL) {
        return true;
    }
    return false;
}

int MonsterSpawnerMng::getEmptySlot() {

    for (size_t i = 0; i < m_WorkPool.size(); i++) {

        if (m_WorkPool[i].isEmpty()) {
            return i;
        }
    }
    return -1;
}

MonsterSpawnerItemInfo* MonsterSpawnerMng::getItemInfo(int ItemCode) {
    if (!m_Loaded) {
        return NULL;
    }

    for (size_t i = 0; i < m_ItemData.size(); i++) {

        if (ITEMGET(m_ItemData[i].itemCategory, m_ItemData[i].itemIndex) == ItemCode) {
            return &m_ItemData[i];
        }
    }
    return NULL;
}

MonsterSpawner.h

Código HTML:

#pragma once

// import
#include "user.h"

// data
struct MonsterSpawnerItemInfo {
    short itemIndex;
    short itemCategory;
    short spawnMonsterId;
    short spawnMonsterCount;
    short spawnDuration;
    bool isPrivate;
    bool isPrivateParty;
    bool isPrivateGuild;
};

struct MonsterSpawnerWorkNode { // maybe better use class & ptr instance...
    MonsterSpawnerWorkNode() {
        ownerName.reserve(MAX_ACCOUNT_LEN + 1);
        monsterPool.clear();
        itemCode = -1;
        tickEnd = 0;
    }
    void setSlot(short UserIndex, MonsterSpawnerItemInfo* itemInfo) {
        if (UserIndex < 0 || UserIndex > OBJMAX) {
            return;
        }
        LPOBJ tmpUser = &gObj[UserIndex];
        if (tmpUser == NULL) {
            return;
        }
        ownerName.assign(tmpUser->Name);
        itemCode = ITEMGET(itemInfo->itemCategory, itemInfo->itemIndex);
        tickEnd = GetTickCount() + (itemInfo->spawnDuration * 60 * 1000);
        setSpot(UserIndex, itemInfo);
    }
    void clearSlot() {
        ownerName.assign("");
        itemCode = -1;
        tickEnd = 0;
        clearSpot();
        monsterPool.clear();
    }
    void setSpot(short UserIndex, MonsterSpawnerItemInfo* itemInfo) {
        if (UserIndex < 0 || UserIndex > OBJMAX) {
            return;
        }
        LPOBJ tmpUser = &gObj[UserIndex];
        if (tmpUser == NULL) {
            return;
        }
        for (int i = 0; i < itemInfo->spawnMonsterCount; i++) {
            int tmpMonsterIndex = gObjAddMonster(tmpUser->MapNumber);
            if (tmpMonsterIndex < 0) {
                return;
            }
            gObj[tmpMonsterIndex].m_PosNum = -1;
            gObj[tmpMonsterIndex].X    = tmpUser->X + rand() % 2;
            gObj[tmpMonsterIndex].Y    = tmpUser->Y + rand() % 2;
            gObj[tmpMonsterIndex].MapNumber    = tmpUser->MapNumber;
            gObj[tmpMonsterIndex].TX = gObj[tmpMonsterIndex].X;
            gObj[tmpMonsterIndex].TY = gObj[tmpMonsterIndex].Y;
            gObj[tmpMonsterIndex].m_OldX = gObj[tmpMonsterIndex].X;
            gObj[tmpMonsterIndex].m_OldY = gObj[tmpMonsterIndex].Y;
            gObj[tmpMonsterIndex].StartX = gObj[tmpMonsterIndex].X;
            gObj[tmpMonsterIndex].StartY = gObj[tmpMonsterIndex].Y;
            gObj[tmpMonsterIndex].m_ActState.Emotion = 1;
            gObj[tmpMonsterIndex].m_ActState.EmotionCount = 15;
            gObj[tmpMonsterIndex].Dir = rand() % 8;
            gObjSetMonster(tmpMonsterIndex, itemInfo->spawnMonsterId);
            monsterPool.push_back(tmpMonsterIndex);
        }
    }
    void clearSpot() {

        for (size_t i = 0; i < monsterPool.size(); i++) {

            gObjViewportListProtocolDestroy(&gObj[monsterPool[i]]);
            gObjViewportClose(&gObj[monsterPool[i]]);
            gObjDel(monsterPool[i]);
            gObj[monsterPool[i]].Live = 0;
            gObj[monsterPool[i]].DieRegen = 1;
        }
    }
    bool isOwner(char* OwnerName) {
        if (ownerName.compare(OwnerName) == NULL) {
            return true;
        }
        return false;
    }
    bool isMonster(short MonsterIndex) {

        for (size_t i = 0; i < monsterPool.size(); i++) {

            if (monsterPool[i] == MonsterIndex) {
                return true;
            }
        }
        return false;
    }
    bool isEmpty() {
        if (isOwner("")) {
            return true;
        }
        return false;
    }
    bool isExpired() {
        if (GetTickCount() >= tickEnd) {
            return true;
        }
        return false;
    }
    std::string ownerName;
    std::vector<short> monsterPool;
    int itemCode;
    DWORD tickEnd;
};

// monster spawner by item drop impletation
class MonsterSpawnerMng {
public:
    MonsterSpawnerMng();
    ~MonsterSpawnerMng();

    void Load();
    void Init();
    void Read(const char* File);

    void procRun();
    void procRegen(short MonsterIndex);
    bool procCreate(short UserIndex, int ItemCode);
    
    bool isPrivate(short UserIndex, short MonsterIndex);
    bool isEventMonster(short MonsterIndex);
    bool isKeyItem(int ItemCode);
    int getEmptySlot();
    MonsterSpawnerItemInfo* getItemInfo(int ItemCode);

    // singleton
    static MonsterSpawnerMng* getInstance() {
        if (m_Instance == NULL) {
            m_Instance = new MonsterSpawnerMng();
        }
        return m_Instance;
    }

private:
    static MonsterSpawnerMng* m_Instance;
    std::vector<MonsterSpawnerWorkNode> m_WorkPool;
    std::vector<MonsterSpawnerItemInfo> m_ItemData;

private:
    bool m_Loaded;
};

**kkovas** · 01/02/2018, 03:08 AM

Alguém sabe como corrigir isso?

[Somente membros podem ver os links. ]

Já conseguir ajeita a tradução porem o item que ele pede não consigo de forma alguma...

Alguma solução?

**jrland** · 11/04/2018, 05:12 PM

Galera... já tentei de tudo aqui, o que fosse imaginável fazer, e só tomo disconnect quando tento acessar o servidor... alguém sabe o que pode ser?

**lacovic** · 11/04/2018, 05:29 PM

Originally Posted by jrland

Galera... já tentei de tudo aqui, o que fosse imaginável fazer, e só tomo disconnect quando tento acessar o servidor... alguém sabe o que pode ser?

Alguma configuração errada com IP.... Tá ligando o servidor no seu PC ou em um dedicado?

**jrland** · 11/04/2018, 06:12 PM

PC comum... já tive servidor, muitos anos... já revi todas as configs... mas não achei nada que tivesse dado errado, usei no-ip, usei ip fixo, local, configurei arquivos hosts e nada... tentei mudar ip direto no main via editor hexa. na dll, no .bmd e de nenhum jeito conecta... server abre normal, tudo liga 100% mas quando vou conectar, o cliente carrega e da dc antes de aparecer a lista de servidores...

**thealiensDJ** · 26/04/2018, 02:27 PM

alguém pode arruma o link do cliente, esta OFF

Tópico: Repack PZ SEASON 9.5 IGCN

Thread Tools

Pesquisar Tópico

Display

Permissões de Postagem

Sobre nós

Nossos anunciantes

Rede Sociais