Procuro Programador PAGO Pelo Serviço

[ADMTec]

Procuro alguém que saiba programar que possa adicionar esse custom que tem no muserver da ZTeam eX802. estou disposto a PAGAR para que seja adicionado na source da IGCN season 9 ou da X-Team Season 8.
Se ele puder resolver a questão do Friend Chat em alguma dessas duas Tambem estou disposto a pagar.



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>
<!-- example, elite yeti -->
<item type="14" index="300">
<spawn monster="20" count="30" duration="60" />
<!-- rules for use this spot (false: any user can attack, true: only owner & by rules) -->
<private active="true">
<party>true</party>
<guild>false</guild>
</private>
</item>

<!-- example, mutant -->
<item type="14" index="301">
<spawn monster="62" count="30" duration="60" />
<!-- rules for use this spot (false: any user can attack, true: only owner & by rules) -->
<private active="true">
<party>true</party>
<guild>false</guild>
</private>
</item>

<!-- example, fire golem -->
<item type="14" index="302">
<spawn monster="291" count="30" duration="60" />
<!-- rules for use this spot (false: any user can attack, true: only owner & by rules) -->
<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

#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:rocRun() {

    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:rocRegen(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:rocCreate(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

#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;
}; 

[ValterHernandes]

Mano se for pagar programador , aconselho procura o @[Somente membros podem ver os links. ] ele manja muito de season !

[ADMTec]

@[Somente membros podem ver os links. ] Nao aceito pegar esse serviço.
Eu queria saber se alguém gostaria de me ajudar.

eu estou estudando os arquivos mais não sei se e preciso também fazer alguma alteração no Main.

[louis]

Obrigado pela indicação, mas infelizmente não tenho tempo pra fazer, recomendo o velton ^^

[ADMTec]

@[Somente membros podem ver os links. ]

queria saber se você aceitaria pegar um serviço de adição de um custom ao muserver da IGCN Season 9 ou MUEMU Season 8