Procuro Programador PAGO Pelo Serviço
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
Código PHP:
#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
Código PHP:
#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;
};
