I'm looking for programmer to add custom a source IGCN 9.5

Results 1 to 4 of 4
  1. #1
    Account Upgraded | Title Enabled! ADMTec is offline
    True MemberRank
    Aug 2011 Join Date
    374Posts

    I'm looking for programmer to add custom a source IGCN 9.5

    I pay for the service.

    I want to add a custom that is in the ZTeam Season 8.2 muserver.
    The custom name is MonsterSpawner.

    the MonsterSpawner.xml

    in Red is define an item that when it is dropped will create a Temporary Spot
    in Yellow is defined the monster that will spawn and also the quantity and the duration time.
    in Green it is defined if the spot created will be private or not (if it is deprived only those who dropped the item can attack the monsters.
    in Blue is defined if the party of whom the item drops will be able to attack.
    in Orange is set if the guild of who drops the item will be able to attack.

    <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

    PHP Code:

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

    MonsterSpawnerMngMonsterSpawnerMng::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"); nodeItnodeIt nodeIt.next_sibling()) {
            
    MonsterSpawnerItemInfo newItem = { };
            
    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 0m_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].gObj[MonsterIndex].StartX;
        
    gObj[MonsterIndex].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 UserIndexint ItemCode) {
        
    MonsterSpawnerItemInfotmpItemInfo getItemInfo(ItemCode);
        if (
    tmpItemInfo == NULL) {
            return 
    false;
        }
        
    int tmpSlotIndex getEmptySlot();
        if (
    tmpSlotIndex == -1) {
            
    MonsterSpawnerWorkNode newNode;
            
    newNode.setSlot(UserIndextmpItemInfo);
            
    m_WorkPool.push_back(newNode);
        } else {
            
    m_WorkPool[tmpSlotIndex].setSlot(UserIndextmpItemInfo);
        }
        
    LogAddTD("[MonsterSpawnerMng] [%s][%s] spot has been created (monster: %d, count: %d, duration: %d, map: %d (%d:%d))",
            
    gObj[UserIndex].AccountIDgObj[UserIndex].NametmpItemInfo->spawnMonsterIdtmpItemInfo->spawnMonsterCount,
            
    tmpItemInfo->spawnDurationgObj[UserIndex].MapNumbergObj[UserIndex].XgObj[UserIndex].Y);
        return 
    true;
    }

    bool MonsterSpawnerMng::isPrivate(short UserIndexshort MonsterIndex) {
        
    LPOBJ tmpAttacker = &gObj[UserIndex];
        
    LPOBJ tmpMonster = &gObj[MonsterIndex];
        
    LPOBJ tmpOwner NULL;
        
    MonsterSpawnerWorkNodetmpNode NULL;
        
    MonsterSpawnerItemInfotmpItem NULL;

        for (
    size_t i 0m_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_STARTUSERINDEXOBJMAXi++) { // 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 0m_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 0m_WorkPool.size(); i++) {

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

    MonsterSpawnerItemInfoMonsterSpawnerMng::getItemInfo(int ItemCode) {
        if (!
    m_Loaded) {
            return 
    NULL;
        }

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

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

    MonsterSpawner.h



    PHP Code:

    #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 UserIndexMonsterSpawnerItemInfoitemInfo) {
            if (
    UserIndex || UserIndex OBJMAX) {
                return;
            }
            
    LPOBJ tmpUser = &gObj[UserIndex];
            if (
    tmpUser == NULL) {
                return;
            }
            
    ownerName.assign(tmpUser->Name);
            
    itemCode ITEMGET(itemInfo->itemCategoryitemInfo->itemIndex);
            
    tickEnd GetTickCount() + (itemInfo->spawnDuration 60 1000);
            
    setSpot(UserIndexitemInfo);
        }
        
    void clearSlot() {
            
    ownerName.assign("");
            
    itemCode = -1;
            
    tickEnd 0;
            
    clearSpot();
            
    monsterPool.clear();
        }
        
    void setSpot(short UserIndexMonsterSpawnerItemInfoitemInfo) {
            if (
    UserIndex || UserIndex OBJMAX) {
                return;
            }
            
    LPOBJ tmpUser = &gObj[UserIndex];
            if (
    tmpUser == NULL) {
                return;
            }
            for (
    int i 0itemInfo->spawnMonsterCounti++) {
                
    int tmpMonsterIndex gObjAddMonster(tmpUser->MapNumber);
                if (
    tmpMonsterIndex 0) {
                    return;
                }
                
    gObj[tmpMonsterIndex].m_PosNum = -1;
                
    gObj[tmpMonsterIndex].X    tmpUser->rand() % 2;
                
    gObj[tmpMonsterIndex].Y    tmpUser->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(tmpMonsterIndexitemInfo->spawnMonsterId);
                
    monsterPool.push_back(tmpMonsterIndex);
            }
        }
        
    void clearSpot() {

            for (
    size_t i 0monsterPool.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(charOwnerName) {
            if (
    ownerName.compare(OwnerName) == NULL) {
                return 
    true;
            }
            return 
    false;
        }
        
    bool isMonster(short MonsterIndex) {

            for (
    size_t i 0monsterPool.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<shortmonsterPool;
        
    int itemCode;
        
    DWORD tickEnd;
    };

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

        
    void Load();
        
    void Init();
        
    void Read(const charFile);

        
    void procRun();
        
    void procRegen(short MonsterIndex);
        
    bool procCreate(short UserIndexint ItemCode);
        
        
    bool isPrivate(short UserIndexshort MonsterIndex);
        
    bool isEventMonster(short MonsterIndex);
        
    bool isKeyItem(int ItemCode);
        
    int getEmptySlot();
        
    MonsterSpawnerItemInfogetItemInfo(int ItemCode);

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

    private:
        static 
    MonsterSpawnerMngm_Instance;
        
    std::vector<MonsterSpawnerWorkNodem_WorkPool;
        
    std::vector<MonsterSpawnerItemInfom_ItemData;

    private:
        
    bool m_Loaded;
    }; 


  2. #2

    Re: I'm looking for programmer to add custom a source IGCN 9.5

    Still need add customs to IGCN?

  3. #3
    Account Upgraded | Title Enabled! ADMTec is offline
    True MemberRank
    Aug 2011 Join Date
    374Posts

    Re: I'm looking for programmer to add custom a source IGCN 9.5

    Yes


    Enviado do meu iPhone usando Tapatalk

  4. #4
    Account Upgraded | Title Enabled! ADMTec is offline
    True MemberRank
    Aug 2011 Join Date
    374Posts

    Re: I'm looking for programmer to add custom a source IGCN 9.5

    I was able to add my Custom but the monsters that are generated can not be attacked but they damage the player, I wanted to know if you could help me with this @drakelv



Advertisement