[Release] zTeam Season 8 Episode 2 (Source)

Omaruu · Mar 2, 2017

Enter key bug fix(disappear of cursor at chat box):
Open ClientDLL/Controller.cpp -> Search for function:

Code:

bool Controller::Load()

Replace whole function with:

Code:

bool Controller::Load()
{
    
    if( !this->m_MouseHook )
    {
        this->m_MouseHook = SetWindowsHookEx(WH_MOUSE, this->Mouse, g_Controller.m_Instance, GetCurrentThreadId());
        // ----
        if( !this->m_MouseHook )
        {
            return false;
        }
    }
    
    // ----
    /*
    if( !this->m_KeyboardHook )
    {
        this->m_KeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, this->Keyboard, g_Controller.m_Instance, NULL);
        // ----
        if( !this->m_KeyboardHook )
        {
            return false;
        }
    }
    */
    // ----
    return true;
}

pravednik · Mar 3, 2017

.....

bikutoru123 · Mar 8, 2017

I have the same error, someone to help me please:

- 80 people test
- After 5 hours ~ 10 hours
- 10% ~ 40% increase in CPU
- Multiserver causes
- CPU 20% ↑ Game connection delay / warehouse open delay

Omaruu lastupdatepack test

I can not speak English
Google translation.....

Problem with server performance

Specifications:
4 GB Ram
Intel Xeon 4 Cores

Hello everyone, I'm having problems with the performance of MultiServer.exe just like others:

http://forum.ragezone.com/f197/zteam-season-8-episode-2-a-1068058-post8465441/#post8465441
http://forum.ragezone.com/f197/zteam-season-8-episode-2-a-1068058-post8576229/#post8576229
http://forum.ragezone.com/f197/zteam-season-8-episode-2-a-1068058-post8722962/#post8722962

The problem occurs when there are many users, the more there is, the less time for the crash of MultiServer.exe, the problem apparently is a memory leak, unfortunately I do not have the ability to repair this. I have started the MultiServer in debug mode and with the plugins for VS, Deleaker, I have detected several memory leaks, but I am not able to detect which ones are real and which are a false positive. I performed a tuning of processes, leaving the MultiServer.exe only in the fourth core, leaving the rest of the processes in the remaining three, with the exception of GameServer.exe which I left in the second core. As you can see the resource consumption is unstable, worse even as the time increases, adding the number of players (60-70), the more unstable it becomes.

Please ask some expert on the subject to help me, I witnessed the files for a year, I have dedicated a lot of time, just like you, so I do not want to feel that I lost all this time. I would appreciate any information or idea on how to repair this BUG, it is worth mentioning that it is a high priority bug, since it is no use repairing more things, if the server is unstable and can not be released to the public, I would appreciate, from the bottom of my Heart to who arrives with the solution to this problem.

The symptoms are the same as the rest, it starts to slow the opening of the baul, then the server starts to slow down and then crashes the MultiServer.exe

Be attentive, greetings and many thanks

:

5xdEKlP - [Release] zTeam Season 8 Episode 2 (Source) - RaGEZONE Forums

Omaruu · Mar 8, 2017

I've sended you PM already with temporary ("fix").
Could you provide logs from your zMS and upload somewhere.
Also the .dmp file of when crash occured.
Btw I have zMS with some memory leaks fixed but it's not well known if this is the exact one you have problem or something send me your skype name so I could send you zMS.exe to test it.

bikutoru123 · Mar 12, 2017

Everything working perfectly, my multiserver has the option to enable or disable DataServer, RankingServer, EventServer, etc. I disabled Dataserver and activated in another only the DataServer, besides I isolated it tuning the processor, the results were very favorable, thank you very much for your recommendation, I really appreciate it, regards.

EDIT: Please keep posting your fixes, first time I immerse myself in the world of MU development and I entertain too much going to understand how you are repairing everything, really many many thanks

bikutoru123 · Mar 12, 2017

CommandMannager.cpp:

- CommandManager logs
- clearinventory target
- Fix online count

Code:

#include "stdafx.h"
#include "CommandManager.h"
#include "..\pugixml\pugixml.hpp"
#include "GameMain.h"
#include "DSProtocol.h"
#include "BuffEffectSlot.h"
#include "..\common\winutil.h"
#include "CastleSiege.h"
#include "Crywolf.h"
#include "MoveCommand.h"
#include "Gate.h"
#include "MultiWareHouseSystem.h"
#include "SProtocol.h"
#include "ResetSystem.h"
#include "QuestInfo.h"
#include "CashShop.h"

#if(ENABLE_CUSTOM_OFFLINETRADE == 1)
#include "OfflineTrade.h"
#endif

#if (__MARRIAGE_SYSTEM__ == 1)
#include "Marriage.h"
#endif

using namespace pugi;
CommandManager g_CommandManager;

CommandManager::CommandManager()
{
	/**/
}

CommandManager::~CommandManager()
{
	/**/
}

void CommandManager::Init()
{
	this->m_CommandInfo.clear();
	if( this->m_CommandInfo.capacity() > 0 )
	{
		std::vector<CommandInfo>().swap(this->m_CommandInfo);
	}
}

void CommandManager::Load()
{
	this->Init();
	this->Read(gDirPath.GetNewPath(FILE_CUSTOM_COMMANDMANAGER));
}

void CommandManager::Read(LPSTR File)
{
	xml_document Document;
	xml_parse_result Result = Document.load_file(File);

	if( Result.status != status_ok )
	{
		MsgBox("[CommandManager] File %s not found! %d", File, Result.status);
		return;
	}

	xml_node CommandManager = Document.child("commandmanager");
	xml_node CommandList = CommandManager.child("commandlist");

	for( xml_node Node = CommandList.child("command"); Node; Node = Node.next_sibling() )
	{
		CommandInfo lpCommand = { 0 };
		lpCommand.Index = Node.attribute("id").as_int();
		lpCommand.Access = Node.attribute("access").as_int();
		lpCommand.MinLevel = Node.attribute("minlevel").as_int();
		lpCommand.MinReset = Node.attribute("minreset").as_int();
		lpCommand.PriceType = Node.attribute("pricetype").as_int();
		lpCommand.Price = Node.attribute("price").as_int();
		lpCommand.PremiumAccess = Node.attribute("premium").as_int();
		strcpy_s(lpCommand.Text, Node.text().as_string());
		this->m_CommandInfo.push_back(lpCommand);
	}
}

void CommandManager::Run(LPOBJ lpUser,LPSTR Text)
{
	if(g_SelfDefenseOn == TRUE)
	{
		if((GetTickCount() - lpUser->MySelfDefenseTime) < g_SelfDefenseTime * 1000) 
		{
			GCServerMsgStringSend(lMsg.Get(1133),lpUser->m_Index,1);
			return;
		}
	}
	
	LPSTR Command = {0};

	char Buffer[256];
	char Separator[2] = " ";
	
	strcpy_s(Buffer,Text);
	Command = strtok(Buffer,Separator);
	
	CommandInfo* lpCommand = this->GetCommand(Command);
	BYTE CheckStatus = this->CheckCommand(lpUser,Command);	

	if(lpCommand == NULL)
	{
		return;
	}

	if( CheckStatus != 1)
	{
		if( CheckStatus == 0 )
		{
			MsgOutput(lpUser->m_Index,"Comando inválido.");
		}
		else if( CheckStatus == 2 )
		{
			MsgOutput(lpUser->m_Index,"No tienes acceso a este comando.");
		}
		else if
		(
			(CheckStatus == 3) &&
			(lpCommand->Index != Command::PKReset)
		) // Special Calculation for what?
		{
			MsgOutput(lpUser->m_Index,"Necesitas %d de Zen para usar este comando.",lpCommand->Price);
		}
		else if( CheckStatus == 4 )
		{
			const char* szType[] = {"Free","Bronze","Silver","Gold"};

			MsgOutput
			(
				lpUser->m_Index,
				"Necesitas ser VIP %s para usar este comando.",
				szType[lpCommand->PremiumAccess]
			);
		}
		else if( CheckStatus == 5 )
		{
			MsgOutput(lpUser->m_Index,"Necesitas nivel %d para usar este comando.",lpCommand->MinLevel);
		}
		else if( CheckStatus == 6 )
		{
			MsgOutput
			(
				lpUser->m_Index,
				"Necesitas %d %s para usar este comando.",
				lpCommand->MinReset,
				(lpCommand->MinReset > 1) ? "resets" : "reset"
 			);
		}
		
		return;
	}
	
	switch(lpCommand->Index)
	{
		case Command::BanChat:
		{
			LPSTR UserName = this->GetTokenString();
			int Time = this->GetTokenNumber();
			
			if(UserName == 0 || Time == 1)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player> <tiempo>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser, UserName);
			
			if( !lpTarget )
			{
				return;
			}
			
			lpTarget->ChatLimitTime = Time;

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s %d", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name, Time);

			break;
		}
		case Command::BanUser: //Need DB request for set new ctrlcode
		{
			/*
				MsgOutput(lpUser->m_Index, "Command temporarily not working");
				return;
			*/

			LPSTR UserName = this->GetTokenString();
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser,UserName);
			
			if( !lpTarget )
			{
				return;
			}

			GJPAccountBlock
			(
				lpTarget->m_Index,
				lpTarget->AccountID,
				lpTarget->DBNumber,
				lpTarget->UserNumber,
				1
			);

			MsgOutput
			(
				lpTarget->m_Index,
				"Haz sido baneado por %s.",
				lpUser->Name
			);

			gObjCloseSet(lpTarget->m_Index,0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);

			break;
		}
		case Command::BanAccount:
		{
			/*
				MsgOutput(lpUser->m_Index, "Command temporarily not working");
				return;
			*/

			LPSTR UserName = this->GetTokenString();
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser,UserName);
			
			if( !lpTarget )
			{
				return;
			}

			GJPAccountBlock
			(
				lpTarget->m_Index,
				lpTarget->AccountID,
				lpTarget->DBNumber,
				lpTarget->UserNumber,
				1
			);

			MsgOutput
			(
				lpTarget->m_Index,
				"Haz sido baneado por %s.",
				lpUser->Name
			);
			
			CloseClient(lpTarget->m_Index);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);

			break;
		}
		case Command::Disconnect:
		{
			LPSTR UserName = this->GetTokenString();
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser, UserName);
			
			if(!lpTarget)
			{
				return;
			}
			
			CloseClient(lpTarget->m_Index);
#if (ENABLE_CUSTOM_OFFLINETRADE == 1)
			if(lpTarget->bOffTrade)
			{
				gObjDel(lpTarget->m_Index);
			}
#endif
			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);

			break;
		}
		case Command::PKSet:
		{
			LPSTR UserName = this->GetTokenString();
			int Level = this->GetTokenNumber();
			
			if( UserName == 0 || Level ==1 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player> <level>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser, UserName);
			
			if( !lpTarget )
			{
				return;
			}
			
			lpTarget->m_PK_Level = Level;
			
			if( lpTarget->PartyNumber >= 0 )
			{
				gParty.SetPkLevel(lpTarget->PartyNumber, lpTarget->m_Index, lpTarget->DBNumber, lpTarget->m_PK_Level);
				gParty.SetPkCount(lpTarget->PartyNumber);
			}
			
			GCPkLevelSend(lpTarget->m_Index, lpTarget->m_PK_Level);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s %d", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name, lpTarget->m_PK_Level);

			break;
		}
		case Command::PKReset:
		{
			int iNeededZen = (lpCommand->Price * lpUser->m_PK_Count);

			if (lpUser->Money < iNeededZen)
			{
				MsgOutput(lpUser->m_Index,"Necesitas %d de Zen.",iNeededZen);
				return;
			}

			if(lpUser->m_PK_Level > 3)
			{
				lpUser->Money -= iNeededZen;
				GCMoneySend(lpUser->m_Index, lpUser->Money);
			
				lpUser->m_PK_Count = 0;
				lpUser->m_PK_Level = 3;
				lpUser->m_PK_Time	= 0;
			
				if( lpUser->PartyNumber >= 0 )
				{
					gParty.SetPkLevel(lpUser->PartyNumber, lpUser->m_Index, lpUser->DBNumber, lpUser->m_PK_Level);
					gParty.SetPkCount(lpUser->PartyNumber);
				}
			
				GCPkLevelSend(lpUser->m_Index,lpUser->m_PK_Level);

				char Command[256];
				strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
				LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);
			}
			else
			{
				MsgOutput(lpUser->m_Index,"Tu personaje no es PK.");
				return;
			}

			break;
		}
		case Command::MoneySet:
		{
			int iAmount = this->GetTokenNumber();

			if(iAmount >= 1 && iAmount <= 2000000000)
			{
				lpUser->Money = iAmount;
				GCMoneySend(lpUser->m_Index,lpUser->Money);

				MsgOutput(lpUser->m_Index,"Haz obtenido %d de Zen.",iAmount);

				char Command[256];
				strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
				LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, lpUser->Money);
			}
			else
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <1~2000000000>",this->GetCommand(Command::MoneySet)->Text);

				return;
			}

			break;
		}
		case Command::MakeItem:
		{
			int EBP798;
			int EBP79C = 0;
			int EBP7A0 = 0;
			int EBP7A4 = 0;
			BYTE EBP7A8 = 0;
			int iDur = (BYTE) - 1;//7AC
			int EBP7B0;

			int ItemCount = this->GetTokenNumber();
			int ItemType  = this->GetTokenNumber();
			int ItemIndex  = this->GetTokenNumber();
			EBP798 = this->GetTokenNumber();
			iDur = this->GetTokenNumber();
			EBP79C = this->GetTokenNumber();
			EBP7A0 = this->GetTokenNumber();
			EBP7B0 = this->GetTokenNumber();

			if( ItemCount <= 0 )
			{
				ItemCount = 1;
			}

			if( ItemCount > 20 )
			{
				ItemCount = 20;
			}

			if( ItemType < 0 || ItemType > 15 )
			{
				MsgOutput
				(
					lpUser->m_Index,
					"Uso: %s <Num> <Type> <Id> <Level> <Dur> <Skill> <Luck> <Option> <Anc> <AncCount> <eOpt1> <eOpt2> <eOpt3> <eOpt4> <eOpt5> <eOpt6>",
					this->GetCommand(lpCommand->Index)->Text
				);

				return;
			}

			if( ItemIndex < 0 || ItemIndex > 512 )
			{
				MsgOutput
				(
					lpUser->m_Index,
					"Uso: %s <Num> <Type> <Id> <Level> <Dur> <Skill> <Luck> <Option> <Anc> <AncCount> <eOpt1> <eOpt2> <eOpt3> <eOpt4> <eOpt5> <eOpt6>",
					this->GetCommand(lpCommand->Index)->Text
				);

				return;
			}
			
			int ItemCode = ITEMGET(ItemType,ItemIndex);
			
			if( ItemCode < ITEMGET(0,0) || ItemCode > ITEMGET(15,512) )
			{
				MsgOutput(lpUser->m_Index,"Item ID fuera del intervalo.");
				return;
			}

			if( !ItemAttribute[ItemCode].HaveItemInfo )
			{
				MsgOutput(lpUser->m_Index,"Información del item no encontrada.");
				return;
			}

			if(ItemType == 13 && ItemIndex == 3)
			{
				if(	EBP7B0 < 8)
				{
					EBP7A4 = EBP7B0;
				}
			}
			else
			{
				if( EBP7B0 >= 4 )
				{
					EBP7A4 = EBP7B0 / 4;
				}
				else
				{
					EBP7B0 = 0;
				}
			}

			int EBP7B4 = this->GetTokenNumber();
			int EBP7B8 = this->GetTokenNumber();

			if(EBP7B4 != 0 )
			{
				if( EBP7B8 == 0)
				{
					if((rand()%100) < 80)
					{
						EBP7B4 |= 4; 
					}
					else
					{
						EBP7B4 |= 8; 
					}
				}
				else if (EBP7B8 == 1) 
				{
					EBP7B4 |= 4; 
				}
				else
				{
					EBP7B4 |= 8; 
				}
			}

			int EBP7BC = this->GetTokenNumber();

			if(EBP7BC > 0)
			{
				EBP7A8 |= 0x20;
			}

			int EBP7C0 = this->GetTokenNumber();

			if(EBP7C0 > 0)
			{
				EBP7A8 |= 0x10;
			}

			int EBP7C4 = this->GetTokenNumber();

			if(EBP7C4 > 0)
			{
				EBP7A8 |= 0x08;
			}

			int EBP7C8 = this->GetTokenNumber();

			if(EBP7C8 > 0)
			{
				EBP7A8 |= 0x04;
			}

			int EBP7CC = this->GetTokenNumber();

			if(EBP7CC > 0)
			{
				EBP7A8 |= 0x02;
			}

			int EBP7D0 = this->GetTokenNumber();

			if(EBP7D0 > 0)
			{
				EBP7A8 |= 0x01;
			}

			if( ItemType >= 0 && ItemType < 512 &&
				ItemIndex >= 0 && ItemIndex < 512)
			{
				int iItemNumber = ItemGetNumberMake(ItemType, ItemIndex);

				if( iItemNumber == ITEMGET(0,19) || 
					iItemNumber == ITEMGET(4,18) || 
					iItemNumber == ITEMGET(5,10) || 
					iItemNumber == ITEMGET(2,13))
				{
					EBP7A8 = 63;	
				}

				for( int i =0;i < ItemCount; i++ )
				{
					ItemSerialCreateSend(lpUser->m_Index, lpUser->MapNumber, lpUser->X, lpUser->Y, iItemNumber, EBP798, iDur, EBP79C, EBP7A0, EBP7A4, -1, EBP7A8, EBP7B4); 
				}

				char Command[256];
				strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
				LogAddTD("[CommandManager][%s][%s] %s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d", lpUser->AccountID, lpUser->Name, Command, ItemCount, ItemType, ItemIndex, EBP798, iDur, EBP79C, EBP7A0, EBP7B0, EBP7B4, EBP7B8, EBP7BC, EBP7C0, EBP7C4, EBP7C8, EBP7CC, EBP7D0);
			}

			break;
		}
		case Command::MakeRandomSet:
		{
			int Count = this->GetTokenNumber();
			
			if(( Count < 0 ) || ( Count > 30))
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <1~30>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			for( int i = 1; i < Count; i++ )
			{
				MakeRandomSetItem(lpUser->m_Index);
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, Count);

			break;
		}
		case Command::HideOn:
		{
			gObjAddBuffEffect(lpUser, BUFF_INVISIBILITY, 0, 0, 0, 0, -10);
			gObjViewportListProtocolDestroy(lpUser);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::HideOff:
		{
			gObjRemoveBuffEffect(lpUser, BUFF_INVISIBILITY);
			gObjViewportListProtocolCreate(lpUser);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::ClearDrop:
		{
			int Distance = this->GetTokenNumber();

			if( Distance == -1 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <1~255>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			MapC[lpUser->MapNumber].ClearItem(lpUser, Distance);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, Distance);

			break;
		}
		case Command::ClearInventory:
		{
			LPSTR UserName = this->GetTokenString();
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,UserName);
			
			if( !lpTarget )
			{
				return;
			}

			int ItemCount = 0;

			for( int i = INVETORY_WEAR_SIZE;i < MAIN_INVENTORY_SIZE;i++ )
			{
				if( lpTarget->pInventory[i].IsItem() )
				{
					gObjInventoryDeleteItem(lpTarget->m_Index, i);
					ItemCount++;
				}
			}

			GCItemListSend(lpTarget->m_Index);

			/*
				We cannot request price for command,
				sice player not removed any item ...
			*/
			if(ItemCount == 0)
			{
				MsgOutput
				(
					lpUser->m_Index,
					"No se han encontrado items en el inventario."
				);

				return;
			}
			else
			{
				MsgOutput
				(
					lpUser->m_Index,
					"Haz eliminado %d %s %s.",
					ItemCount,
					(ItemCount > 1) ? "items" : "item",
					(lpUser->m_Index == lpTarget->m_Index) ? "de tu inventario" : "del inventario"
				);

				if(lpUser->m_Index != lpTarget->m_Index)
				{
					MsgOutput
					(
						lpTarget->m_Index,
						"(%s) ha eliminado %d %s de tu inventario.",
						lpUser->Name,
						ItemCount,
						(ItemCount > 1) ? "items" : "item"
					);
				}

				char Command[256];
				strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
				LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);
			}

			break;
		}
		case Command::Skin:
		{
			int SkinNumber = this->GetTokenNumber();

			if(SkinNumber != -1)
			{
			
				lpUser->m_Change = SkinNumber;
				gObjViewportListProtocolCreate(lpUser);

				char Command[256];
				strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
				LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, SkinNumber);
			}
			else
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <1~512>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			break;
		}
		case Command::PartyInfo:
		{
			LPSTR UserName = this->GetTokenString();
			char Text[80] = { 0 };
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser, UserName);
			
			if( !lpTarget )
			{
				return;
			}
			
			if( lpTarget->PartyNumber < 0 )
			{
				MsgOutput(lpUser->m_Index, "Party no encontrada.");
				return;
			}
			
			PARTY_STRUCT* lpParty = &gParty.m_PartyS[lpTarget->PartyNumber];
			
			if( !lpParty )
			{
				MsgOutput(lpUser->m_Index, "Party no encontrada.");
				return;
			}
			
			MsgOutput(lpUser->m_Index, "Party:");
			
			int PartyCount = 0;
			int PartyNumber = -1;
			
			for( int i = 0; i < 5; i++ )
			{
				PartyNumber = lpParty->Number[i];
				
				if( PartyNumber < 0 )
				{
					continue;
				}
				
				LPOBJ lpPartyObj = &gObj[PartyNumber];
				
				if( lpPartyObj != NULL )
				{
					if( lpPartyObj->Connected >= PLAYER_PLAYING )
					{
						PartyCount++;
						strcat(Text, lpPartyObj->Name);
						
						if(i == 0)
						{
							strcat(Text,"(Líder)");
						}
						
						if( lpParty->Count > PartyCount)
						{
							strcat(Text,", ");
						}
					}
				}
			}
			
			MsgOutput(lpUser->m_Index,Text);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);

			break;
		}
		case Command::FireCrack:
		{
			for( int i = 0; i < 3; i++ )
			{
				PMSG_SERVERCMD ServerCmd = { 0 };
				PHeadSubSetB((LPBYTE)&ServerCmd, 0xF3, 0x40, sizeof(ServerCmd));

				ServerCmd.CmdType = 0;
				ServerCmd.X = lpUser->X + (rand() % 5) * 2 - 4;
				ServerCmd.Y = lpUser->Y + (rand() % 5) * 2 - 4;

				MsgSendV2(lpUser, (LPBYTE)&ServerCmd, sizeof(ServerCmd));
				DataSend(lpUser->m_Index, (LPBYTE)&ServerCmd, sizeof(ServerCmd));
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::Trans:
		{
			LPSTR szName = this->GetTokenString();
			int MapNumber = this->GetTokenNumber();

			int X = this->GetTokenNumber();
			int Y = this->GetTokenNumber();
			
			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player|All> [MapId] [X] [Y]",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			BOOL bHaveMap = FALSE;

			((MapNumber == -1) && (X == -1) && (Y == -1)) ? (bHaveMap = FALSE) : (bHaveMap = TRUE);

			if(bHaveMap && !(MapNumber >= MAP_INDEX_RORENCIA && MapNumber <= MAP_INDEX_TERRAIN_2))
			{
				MsgOutput(lpUser->m_Index,"Mapa (%d) no encontrado.",MapNumber);
				return;
			}
			
			if(strcmpi(szName,"all") == 0)
			{
				for(int n=0;n < OBJMAX;n++)
				{
					if(gObj[n].m_Index > 0)
					{
						if((gObj[n].Live != FALSE) && (gObj[n].Connected != PLAYER_EMPTY) && (gObj[n].Type == OBJ_USER))
						{
							if(((lpUser->Authority & 32) != 32) && ((lpUser->Authority & 8) != 8))
							{
								if(bHaveMap == TRUE)
								{
									gObjTeleport(gObj[n].m_Index,MapNumber,X,Y);
								}
								else
								{
									gObjTeleport(gObj[n].m_Index,lpUser->MapNumber,lpUser->X,lpUser->Y);
								}
							}
						}
					}
				}
			}
			else
			{
				LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
				if(lpTarget != NULL)
				{
					if(bHaveMap == TRUE)
					{
						gObjTeleport(lpTarget->m_Index,MapNumber,X,Y);
					}
					else
					{
						gObjTeleport(lpTarget->m_Index,lpUser->MapNumber,lpUser->X,lpUser->Y);
					}

					MsgOutput(lpUser->m_Index,"Player %s movido.",lpTarget->Name);
				}
				else
				{
					return;
				}
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s %d %d %d", lpUser->AccountID, lpUser->Name, Command, szName, MapNumber, X, Y);

			break;
		}
		case Command::Track:
		{
			LPSTR UserName = this->GetTokenString();
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser, UserName);
			
			if( !lpTarget )
			{
				return;
			}

			MsgOutput(lpUser->m_Index,"Player %s movido.",lpTarget->Name);
			gObjTeleport(lpTarget->m_Index, lpUser->MapNumber, lpUser->X, lpUser->Y);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);

			break;
		}
		case Command::Trace:
		{
			LPSTR UserName = this->GetTokenString();
			
			if( UserName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			LPOBJ lpTarget = this->GetUserInfo(lpUser, UserName);
			
			if( !lpTarget )
			{
				return;
			}
			
			gObjTeleport(lpUser->m_Index, lpTarget->MapNumber, lpTarget->X, lpTarget->Y);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpTarget->Name);

			break;
		}
		case Command::CastleSiege1:
		{
			LPSTR GuildName = this->GetTokenString();
			
			if( GuildName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <guild>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 0, GuildName);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, GuildName);

			break;
		}
		case Command::CastleSiege2:
		{
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 1, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::CastleSiege3:
		{
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 2, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::CastleSiege4:
		{
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 3, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::CastleSiege5:
		{
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 4, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::CastleSiege6:
		{
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 5, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::CastleSiege7:
		{
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 6, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::CastleSiege8:
		{
			LPSTR GuildName = this->GetTokenString();
			
			if( GuildName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <guild>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			g_CastleSiege.OperateGmCommand(lpUser->m_Index, 8, GuildName);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, GuildName);

			break;
		}
		case Command::Crywolf1:
		{
			g_Crywolf.OperateGmCommand(lpUser->m_Index, 1);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::Crywolf2:
		{
			g_Crywolf.OperateGmCommand(lpUser->m_Index, 2);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::Crywolf3:
		{
			g_Crywolf.OperateGmCommand(lpUser->m_Index, 3);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::Crywolf4:
		{
			g_Crywolf.OperateGmCommand(lpUser->m_Index, 0);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::Request:
		{
			LPSTR Mode = this->GetTokenString();
			
			if( Mode == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <On|Off>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			BYTE State = 3;
			
			if( strcmp(Mode, "on" ) == 0 )
			{
				State = 1;
			}
			else if( strcmp(Mode, "off") == 0 )
			{
				State = 0;
			}
			
			if( State >= FALSE && State <= TRUE )
			{
				gObjSetTradeOption(lpUser->m_Index, State);
				gObjSetDuelOption(lpUser->m_Index, State);
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, Mode);

			break;
		}
		case Command::PartyLeader:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);

			if(!lpTarget)
			{
				return;
			}

			if(!gParty.SetLeader(lpUser->m_Index,lpTarget->m_Index))
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::Move:
		{
			LPSTR MapName = this->GetTokenString();
			
			if( MapName == 0 )
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <MapName>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}
			
			if(lpUser->Teleport != 0)
			{
				GCServerMsgStringSend(lMsg.Get(MSGGET(6,68)), lpUser->m_Index, 1);
				return;
			}
			
			if((lpUser->m_IfState.use) != 0)
			{
				if(lpUser->m_IfState.type  == 3)
				{
					lpUser->TargetShopNumber = -1;
					lpUser->m_IfState.type = 0;
					lpUser->m_IfState.use = 0;
				}
			}
			
			if( lpUser->m_IfState.use > 0 )
			{
				GCServerMsgStringSend(lMsg.Get(MSGGET(6,68)),lpUser->m_Index, 1);
				return;
			}
			
			if(lpUser->m_PK_Level >= 5)
			{
				GCServerMsgStringSend(lMsg.Get(MSGGET(4,101)),lpUser->m_Index, 1);
				return;
			}
			
			gMoveCommand.Move(lpUser,MapName);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, MapName);

			break;
		}
		case Command::Post:
		{
			if(lpUser->ChatLimitTime > 0)
			{
				MsgOutput(lpUser->m_Index, lMsg.Get(MSGGET(4,223)),lpUser->ChatLimitTime);
				return;
			}

			if(strlen(Command) < 1)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Mensaje>",this->GetCommand(lpCommand->Index)->Text);
			}
			
			BroadCastMessageInfo lpRequest = {0};
			lpRequest.h.set((LPBYTE)&lpRequest,0xCD,sizeof(lpRequest));

			lpRequest.Type = 1;
			strcat(lpRequest.Text,&Text[strlen(Command) + 1]);
			CopyMemory(lpRequest.Sender,lpUser->Name,10);
			
			wsJServerCli.DataSend((PCHAR)&lpRequest,sizeof(BroadCastMessageInfo));

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, lpRequest.Text);

			break;
		}
		case Command::AddStr:
		case Command::AddAgi:
		case Command::AddVit:
		case Command::AddEne:
		case Command::AddCom:
		{
			int AddValue = this->GetTokenNumber();

			if((AddValue < 0) || (AddValue >= g_MaxStatValue))
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Puntos>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			if( lpUser->LevelUpPoint < AddValue )
			{
				MsgOutput(lpUser->m_Index,"No tienes puntos suficientes.");
				return;
			}

			if(lpCommand->Index == Command::AddCom && lpUser->Class != CLASS_DARKLORD)
			{
				MsgOutput(lpUser->m_Index,"Debes ser un Dark Lord/Lord Emperor para usar este comando.");
				return;
			}

			PMSG_LVPOINTADDRESULT pMsg;
			PHeadSubSetB((LPBYTE)&pMsg, 0xF3, 0x06, sizeof(pMsg));

			if( lpCommand->Index == Command::AddStr )
			{
				if( lpUser->Strength + AddValue > g_MaxStatValue )
				{
					return;
				}

				lpUser->Strength += AddValue;
				pMsg.NewValue = lpUser->Strength;
				pMsg.ResultType = 0x15;
			}
			else if( lpCommand->Index == Command::AddAgi )
			{
				if( lpUser->Dexterity + AddValue > g_MaxStatValue )
				{
					return;
				}

				lpUser->Dexterity += AddValue;
				pMsg.NewValue = lpUser->Dexterity;
				pMsg.ResultType = 0x16;
			}
			else if( lpCommand->Index == Command::AddVit )
			{
				if( lpUser->Vitality + AddValue > g_MaxStatValue )
				{
					return;
				}

				lpUser->Vitality += AddValue;
				pMsg.NewValue = lpUser->Vitality;
				lpUser->MaxLife += lpUser->VitalityToLife * AddValue;
				pMsg.MaxLifeAndMana = (WORD)(lpUser->MaxLife + lpUser->AddLife);
				pMsg.MAXHPANDMANA = (int)(lpUser->MaxLife + lpUser->AddLife);
				pMsg.ResultType = 0x17;
			}
			else if( lpCommand->Index == Command::AddEne )
			{
				if( lpUser->Energy + AddValue > g_MaxStatValue )
				{
					return;
				}

				lpUser->Energy += AddValue;
				pMsg.NewValue = lpUser->Energy;
				lpUser->MaxMana += lpUser->EnergyToMana * AddValue;
				pMsg.MaxLifeAndMana = (WORD)(lpUser->MaxMana + lpUser->AddMana);
				pMsg.MAXHPANDMANA = (int)(lpUser->MaxMana + lpUser->AddMana);
				pMsg.ResultType = 0x18;
			}
			else if( lpCommand->Index == Command::AddCom )
			{
				if( lpUser->Leadership + AddValue > g_MaxStatValue )
				{
					return;
				}

				lpUser->Leadership += AddValue;
				pMsg.NewValue = lpUser->Leadership;
				pMsg.ResultType = 0x19;
			}

			gObjCalCharacter(lpUser->m_Index);
			gObjSetBP(lpUser->m_Index);
			pMsg.wMaxShield = lpUser->iMaxShield + lpUser->iAddShield;
			pMsg.MaxBP = lpUser->MaxBP + lpUser->AddBP;
			pMsg.MAXSD = lpUser->iMaxShield + lpUser->iAddShield;
			lpUser->LevelUpPoint -= AddValue;
			pMsg.LvlUpPt = lpUser->LevelUpPoint;
			DataSend(lpUser->m_Index, (LPBYTE)&pMsg, pMsg.h.size);

			MsgOutput(lpUser->m_Index,"%d Punto(s) agregados.",AddValue);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, AddValue);

			break;
		}
		case Command::Offtrade:
		{
#if (ENABLE_CUSTOM_OFFLINETRADE == 1)
			g_OfflineTrade.ProcStart(lpUser);
#endif
			break;
		}
		case Command::MultiVault:
		{
			int MaxVault = m_ObjBill[lpUser->m_Index].GetMaxVault();

			if(MaxVault < 1)
			{
				MsgOutput(lpUser->m_Index,"No tienes acceso a baúles extras.");
				return;
			}

			int iVaultNumber = this->GetTokenNumber();

			if (iVaultNumber > MaxVault || iVaultNumber < 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <0~%d>",this->GetCommand(lpCommand->Index)->Text,MaxVault);
				return;
			}
			
			if(lpUser->pTransaction == 1)
			{
				MsgOutput(lpUser->m_Index,"Por favor, cierra %s antes.","el Trade");
				return;
			}

			if((lpUser->m_IfState.use == 1) && (lpUser->m_IfState.type == 7))
			{
				MsgOutput(lpUser->m_Index,"Por favor, cierra %s antes.","el Chaos Machine");
				return;
			}

			if((lpUser->m_ReqWarehouseOpen != 0) || (lpUser->WarehouseSave != 0))
			{
				MsgOutput(lpUser->m_Index,"Por favor, cierra %s antes.","el Baúl");
				return;
			}

			if(lpUser->m_IfState.use == 1)
			{
				MsgOutput(lpUser->m_Index,"Por favor, cierra %s antes.","la Shop");
				return;
			}

			lpUser->RecvSendWare = 1;
			gWareHouseSYSTEM.DBSendVaultInfo(lpUser->m_Index,lpUser->AccountID,(BYTE)iVaultNumber);

			gObjCloseSet(lpUser->m_Index, 1);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, iVaultNumber);

			break;
		}
		case Command::GuildWar:
		{
			LPSTR pId = this->GetTokenString();

			if ( pId != NULL )
			{
				if ( strlen(pId) >= 1 )
				{
					::GCGuildWarRequestResult(pId, lpUser->m_Index, 0);
				}
			}
			else
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Guild>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, pId);

			break;
		}
		case Command::BattleSoccer:
		{
			if ( gEnableBattleSoccer != FALSE )
			{
				LPSTR pId = this->GetTokenString();

				if ( pId != NULL )
				{
					if ( strlen(pId) >= 1 )
					{
						::GCGuildWarRequestResult(pId, lpUser->m_Index, 1);

						char Command[256];
						strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
						LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, pId);
					}
				}
				else
				{
					MsgOutput(lpUser->m_Index,"Uso: %s <Guild>",this->GetCommand(lpCommand->Index)->Text);
					return;
				}
			}

			break;
		}
		case Command::Reset:
		{
			if(!lpUser->IsInBattleGround && (lpUser->Teleport == 0) && (lpUser->m_IfState.use == 0))
			{
				if(g_ResetSystem.ProcReset(lpUser,ResetType::Normal,0,0) == false)
				{
					return;
				}
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::Evo:
		{
			if(!lpUser->IsInBattleGround && (lpUser->Teleport == 0) && (lpUser->m_IfState.use == 0))
			{
				switch(lpUser->DbClass)
				{
					case 1:		// Soul Master
					case 17:	// Blade Kinght
					case 33:	// Mouse Elf
					case 48:	// Magic Gladiator
					case 64:	// Dark Lord
					case 81:	// Bloody Summoner
					case 96:	// Rage Fighter
					{
						g_QuestInfo.QuestClear(lpUser,6);

						char Command[256];
						strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
						LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

						break;
					}
					default:
					{
						MsgOutput(lpUser->m_Index,"[Evo Command] Necesitas ser segunda clase para evolucionar.");

						return;
					}
				}
			}

			break;
		}
		case Command::Online:
		{
			if (lpUser->ChatLimitTime > 0)
			{
				MsgOutput(lpUser->m_Index, lMsg.Get(MSGGET(4, 223)), lpUser->ChatLimitTime);
				return;
			}

			int connectedPlayers = 0,NPCs = 0,monsters = 0,GMs = 0;

			for(int n=0;n < OBJMAX;n++)
			{
				if(gObj[n].m_Index <= 0) continue;
	
				if(gObj[n].Live != FALSE && gObj[n].Connected != PLAYER_EMPTY && gObj[n].Type == OBJ_USER)
				{
					if(gObj[n].Authority == 32)
					{
						GMs++;
					}

					connectedPlayers++;
				}
				else if(gObj[n].Type == OBJ_NPC)
				{
					NPCs++;
				}
				else
				{
					monsters++;
				}
			}

			MsgOutput
			(
				lpUser->m_Index,
				"Online: %d %s, %d %s, %d NPCs, %d Monstruos.",
				connectedPlayers,
				(connectedPlayers > 1) ? "Jugadores" : "Jugador",
				GMs,
				(GMs > 1) ? "GMs" : "GM",
				NPCs,
				monsters
			);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::AutoReset:
		{
			int ResLevel = this->GetTokenNumber();
			int MinLevel = g_ResetSystem.m_NormalInfo.m_GroupList[m_ObjBill[lpUser->m_Index].GetPayCode()].MinLevel;
			int MaxLevel = g_ResetSystem.m_NormalInfo.m_GroupList[m_ObjBill[lpUser->m_Index].GetPayCode()].MaxLevel;

			if((ResLevel >= MinLevel) && (ResLevel <= MaxLevel))
			{
				lpUser->m_AutoReset = !lpUser->m_AutoReset;
				
				if(lpUser->m_AutoReset == true)
				{
					lpUser->m_AutoResetLevel = ResLevel;
				}
				else
				{
					lpUser->m_AutoResetLevel = 0;
				}

				MsgOutput
				(
					lpUser->m_Index,
					"[Auto Reset] Auto Reset %s (Level %d): Usa %s nuevamente para %s.",
					lpUser->m_AutoReset ? "activado" : "desactivado",
					ResLevel,
					GetCommand(Command::AutoReset)->Text,
					lpUser->m_AutoReset ? "desactivar" : "activar"
				);

				char Command[256];
				strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
				LogAddTD("[CommandManager][%s][%s] %s %d", lpUser->AccountID, lpUser->Name, Command, ResLevel);
			}
			else
			{
				MsgOutput
				(
					lpUser->m_Index,
					"[Auto Reset] Digite %s <level> - (Nivel Mínimo %d, Máximo %d)",
					GetCommand(Command::AutoReset)->Text,
					MinLevel,
					MaxLevel
				);

				return;
			}

			break;
		}
		case Command::AutoAdd:
		{
			LPSTR Field = this->GetTokenString();
			
			if(Field != NULL)
			{
				switch(Field[0]) // Test
				{
					case 'f':
					case 's':
					{
						lpUser->m_AutoAdd = 0;

						break;
					}
					case 'd':
					case 'a':
					{
						lpUser->m_AutoAdd = 1;
						break;
					}
					case 'v':
					{
						lpUser->m_AutoAdd = 2;
						break;
					}
					case 'e':
					{
						lpUser->m_AutoAdd = 3;
						break;
					}
					case 'l':
					case 'c':
					{
						if(lpUser->Class == CLASS_DARKLORD)
						{
							lpUser->m_AutoAdd = 4;
						}
						else
						{
							lpUser->m_AutoAdd = -1;
							lpUser->m_AutoAddValue = 0;

							MsgOutput(lpUser->m_Index,"[Auto Add] Debes ser un Dark Lord/Lord Emperor para usar este comando.",1,g_MaxStatValue);
							return;
						}

						break;
					}
					case 'o':
					{
						lpUser->m_AutoAdd = -1;
						lpUser->m_AutoAddValue = 0;

						MsgOutput
						(
							lpUser->m_Index,
							"[Auto Add] Función desactivada: Usa %s <atributo> <valor> para activar.",
							GetCommand(Command::AutoAdd)->Text
						);

						char Command[256];
						strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
						LogAddTD("[CommandManager][%s][%s] %s off", lpUser->AccountID, lpUser->Name, Command);

						break;
					}
					default:
					{
						lpUser->m_AutoAdd = -1;
						lpUser->m_AutoAddValue = 0;

						MsgOutput
						(
							lpUser->m_Index,
							"[Auto Add] Atributo inválido: Usa %s <str|agi|vit|ene|cmd> <valor> para activar.",
							GetCommand(Command::AutoAdd)->Text
						);

						return;
					}
				}

				int AddValue = this->GetTokenNumber();

				if((AddValue > 0) && (AddValue <= g_MaxStatValue) && (lpUser->m_AutoAdd != -1))
				{
					lpUser->m_AutoAddValue = AddValue;

					MsgOutput(lpUser->m_Index,"[Auto Add] Agregando %d punto(s) automaticamente en %s.",lpUser->m_AutoAddValue,Field);
					MsgOutput(lpUser->m_Index,"[Auto Add] Digita %s off para desactivar.",GetCommand(Command::AutoAdd)->Text);

					char Command[256];
					strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
					LogAddTD("[CommandManager][%s][%s] %s on", lpUser->AccountID, lpUser->Name, Command);
				}
				else if(lpUser->m_AutoAdd >= 0)
				{
					lpUser->m_AutoAdd = -1;
					lpUser->m_AutoAddValue = 0;

					MsgOutput(lpUser->m_Index,"[Auto Add] El valor debe estar entre 1 y %d.",g_MaxStatValue);
					return;
				}
			}
			else
			{
				MsgOutput
				(
					lpUser->m_Index,
					"[Auto Add] Atributo inválido: Usa %s <str|agi|vit|ene|cmd> <valor> para activar.",
					GetCommand(Command::AutoReset)->Text
				);

				return;
			}

			break;
		}
		case Command::Kill:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(!lpTarget)
			{
				return;
			}

			lpTarget->Live = 0;
			lpTarget->m_State = 4;
			lpTarget->RegenTime = GetTickCount();
			lpTarget->DieRegen = 1;
			lpTarget->PathCount = 0;

			GCDiePlayerSend(lpTarget,lpTarget->m_Index,0,0);
			MsgOutput(lpTarget->m_Index,"Haz sido asesinado por %s (%s)",lpUser->Name,(lpUser->Authority >= 32) ? "Admin" : (lpUser->Authority == 0) ? "Player" : "GM");

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::OpenWare:
		{
			if(lpUser->pTransaction == 1)
			{
				MsgOutput(lpUser->m_Index,"Debes cerrar el Trade para usar el comando.");
				return;
			}

			if((lpUser->m_IfState.use == 1) && (lpUser->m_IfState.type == 7))
			{
				MsgOutput(lpUser->m_Index,"Debes cerrar el ChaosBox para usar el comando.");
				return;
			}

			if((lpUser->m_ReqWarehouseOpen != 0) || (lpUser->WarehouseSave != 0))
			{
				MsgOutput(lpUser->m_Index,"Debes cerrar el Baúl para usar el comando.");
				return;
			}

			if(lpUser->m_IfState.use > 0)
			{
				MsgOutput(lpUser->m_Index,"Debes cerrar la Shop para usar el comando.");
				return;
			}

			lpUser->m_ReqWarehouseOpen = 1;
			lpUser->m_IfState.type = 6;
			lpUser->m_IfState.use = 1;
			lpUser->m_IfState.state = 0;
			lpUser->WarehouseSave = TRUE;
			lpUser->WarehouseCount = 0;
			GDGetWarehouseList(lpUser->m_Index, lpUser->AccountID);

			MsgOutput(lpUser->m_Index,"Baúl abierto correctamente.");

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::PremiumInfo:
		{
			LPSTR szName = this->GetTokenString();

			LPOBJ lpTarget = (szName != 0) ? this->GetUserInfo(lpUser,szName) : lpUser;
			
			if(!lpTarget)
			{
				lpTarget = lpUser;
			}

			char szTime[64];
			sprintf_s(szTime,"Miembro Free.");

			if(m_ObjBill[lpTarget->m_Index].GetPayCode() > 0)
			{
				char szYear[5] = "";
				char szMonth[3] = "";
				char szDay[3] = "";
				char szHour[3] = "";
				char szMin[3] = "";

				strncpy(szYear,m_ObjBill[lpTarget->m_Index].GetEndsDays(),4);
				strncpy(szMonth,m_ObjBill[lpTarget->m_Index].GetEndsDays() + 4,2);
				strncpy(szDay,m_ObjBill[lpTarget->m_Index].GetEndsDays() + 6,2);
				strncpy(szHour,m_ObjBill[lpTarget->m_Index].GetEndsDays() + 8,2);
				strncpy(szMin,m_ObjBill[lpTarget->m_Index].GetEndsDays() + 10,2);

				sprintf_s
				(
					szTime,
					"VIP %s (Válido hasta el %s/%s/%s %s:%s)",
					m_ObjBill[lpTarget->m_Index].GetPremiumName(),
					szDay,
					szMonth,
					szYear,
					szHour,
					szMin
				);
			}

			MsgOutput(lpUser->m_Index,"Jugador (%s): %s",lpTarget->Name,szTime);

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
#if (__MARRIAGE_SYSTEM__ == 1)
		case Command::Marry:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(!lpTarget || lpUser->m_Index == lpTarget->m_Index)
			{
				return;
			}

			if(g_Marriage.CheckMarry(lpUser,lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::AcceptMarry:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(!lpTarget)
			{
				return;
			}

			if(g_Marriage.AcceptMarry(lpUser,lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::DenyMarry:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(!lpTarget || lpUser->m_Index == lpTarget->m_Index)
			{
				return;
			}

			if(g_Marriage.DenyMarry(lpUser,lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::ApproveMarry:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(!lpTarget)
			{
				return;
			}

			if(g_Marriage.ApproveMarry(lpUser,lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::IsMarry:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(!lpTarget)
			{
				return;
			}

			if(g_Marriage.IsMarry(lpUser,lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::MarryOnline:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(lpTarget == NULL)
			{
				return;
			}

			if(g_Marriage.MarryOnline(lpUser, lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::MarryDivorce:
		{
			LPSTR szName = this->GetTokenString();

			if(szName == 0)
			{
				MsgOutput(lpUser->m_Index,"Uso: %s <Player>",this->GetCommand(lpCommand->Index)->Text);
				return;
			}

			LPOBJ lpTarget = this->GetUserInfo(lpUser,szName);
			
			if(lpTarget == NULL)
			{
				return;
			}

			if(g_Marriage.DivorceMarry(lpUser, lpTarget) == FALSE)
			{
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s %s", lpUser->AccountID, lpUser->Name, Command, szName);

			break;
		}
		case Command::MarryTrace:
		{
			if(strlen(lpUser->MarryName) > 0)
			{
				LPOBJ lpTemp = gObjFind(lpUser->MarryName);

				if((lpTemp != NULL) && (lpTemp->Connected == PLAYER_PLAYING))
				{
					gObjTeleport(lpUser->m_Index,lpTemp->MapNumber,lpTemp->X,lpTemp->Y);
				}
				else
				{
					MsgOutput(lpUser->m_Index,"%s no se encuentra online.",lpUser->MarryName);
					return;
				}
			}
			else
			{
				MsgOutput(lpUser->m_Index,"No estás casado(a).",lpUser->MarryName);
				return;
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
		case Command::GrandReset:
		{
			if(!lpUser->IsInBattleGround && (lpUser->Teleport == 0) && (lpUser->m_IfState.use == 0))
			{
				if(g_ResetSystem.ProcReset(lpUser,ResetType::Grand,0,0) == false)
				{
					return;
				}
			}

			char Command[256];
			strcpy_s(Command, this->GetCommand(lpCommand->Index)->Text);
			LogAddTD("[CommandManager][%s][%s] %s", lpUser->AccountID, lpUser->Name, Command);

			break;
		}
#endif
	}

	if(lpCommand->Price > 0)
	{
		switch(lpCommand->PriceType)
		{
			case 0: //Zen
			{
				if(lpCommand->Index != Command::PKReset)
				{
					lpUser->Money -= lpCommand->Price;
					GCMoneySend(lpUser->m_Index, lpUser->Money);
				}

				break;
			}
			case 1: //WCoinC
			{
				lpUser->m_wcCashPoint =- lpCommand->Price;
				g_CashShop.GCCashPoint(lpUser);
				break;
			}
			case 2: //WCoinP
			{
				lpUser->m_wpCashPoint -= lpCommand->Price;
				g_CashShop.GCCashPoint(lpUser);
				break;
			}
			case 3: //WCoinG
			{
				lpUser->m_wgCashPoint -= lpCommand->Price;
				g_CashShop.GCCashPoint(lpUser);
				break;
			}
		}
	}
}

BYTE CommandManager::CheckCommand(LPOBJ lpUser, LPSTR Text)
{
	CommandInfo* lpCommand = this->GetCommand(Text);
	
	if( !lpCommand )
	{
		return 0;
	}
	
	if( lpUser->Authority < lpCommand->Access )
	{
		return 2;
	}
	
	if( lpCommand->Price > 0 )
	{
		switch(lpCommand->PriceType)
		{
		case 0: //Zen
			{
				if( lpUser->Money < lpCommand->Price )
				{
					return 3;
				}
			}
			break;
			
		case 1: //WCoinC
			{
				if( lpUser->m_wcCashPoint < lpCommand->Price )
				{
					return 3;
				}
			}
			break;
			
		case 2: //WCoinP
			{
				if( lpUser->m_wpCashPoint < lpCommand->Price )
				{
					return 3;
				}
			}
			break;
			
		case 3: //WCoinG
			{
				if( lpUser->m_wgCashPoint < lpCommand->Price )
				{
					return 3;
				}
			}
			break;
		}
	}
	
	if( lpCommand->PremiumAccess > 0 )
	{
		if( m_ObjBill[lpUser->m_Index].GetPayCode() < lpCommand->PremiumAccess )
		{
			return 4;
		}
	}
	
	if( lpUser->Level < lpCommand->MinLevel )
	{
		return 5;
	}
	
	if( lpUser->iResetCount < lpCommand->MinReset )
	{
		return 6;
	}

	return 1;
}

/*
	Added this gracefully message,
	because we need to send a MsgOutPut when player
	is not found or target nick is equal to player nick.

	If you need only to search object without message,
	use gObiFind(TargetName)
*/
LPOBJ CommandManager::GetUserInfo(LPOBJ lpUser,LPSTR UserName)
{
	for(int i = OBJ_STARTUSERINDEX;i < OBJMAX; i++)
	{
		if(gObj[i].Connected >= PLAYER_PLAYING)
		{
			if(gObj[i].Name[0] == *UserName)
			{
				if(strcmp(gObj[i].Name,UserName) == 0)
				{
					return &gObj[i];
				}
			}
		}
	}
	
	MsgOutput(lpUser->m_Index,lMsg.Get(MSGGET(13,198)),UserName);

	return NULL;
}

LPSTR CommandManager::GetTokenString()
{
	char Separator[2] = " ";
	return strtok(0, Separator);
}

int CommandManager::GetTokenNumber()
{
	char Separator[2] = " ";
	LPSTR Token = strtok(0, Separator);
	
	if( Token != NULL )
	{
		return atoi(Token);
	}
	
	return -1;
}

CommandInfo* CommandManager::GetCommand(int Index)
{
	for( int i = 0; i < this->m_CommandInfo.size(); i++ )
	{
		if( this->m_CommandInfo[i].Index == Index )
		{
			return &m_CommandInfo[i];
		}
	}
	
	return NULL;
}

CommandInfo* CommandManager::GetCommand(LPSTR Text)
{
	for( int i = 0; i < this->m_CommandInfo.size(); i++ )
	{
		if( strcmp(this->m_CommandInfo[i].Text, Text) == 0 )
		{
			return &m_CommandInfo[i];
		}
	}
	
	return NULL;
}

pan03 · Mar 12, 2017

Someone can upload source code?

bikutoru123 · Mar 14, 2017

NbdtWJi - [Release] zTeam Season 8 Episode 2 (Source) - RaGEZONE Forums

It is not tidy, it has no error handling, I did it in 40 minutes, but I think it is much more useful than the zEventItemBag, for its autocomplete feature like Google does.

Download Link:

You must be registered to see links

Credits:
Bikutoru123
zEventItemBag

pan03 · Mar 15, 2017

you have source code this program?

MaxVoll · Mar 15, 2017

@Omaruu You can upload the source again please

Omaruu · Mar 27, 2017

Here my latest source:
Btw: High CPU/Memory usage on zMultiServer is becouse logs(THEY ARE DISABLED) you can enable them if you want in CQuery.cpp: ->

Code:

BOOL CQuery::Exec(LPCTSTR szSQL)

You must be registered to see links

josesp · Mar 27, 2017

Omaruu said:
Btw there is also Dupe Bug using MultiVaults.
Bug Information: Using T key(Quest Key and open vault then change vault -> causing items to duplicate in second vault).
Other Bug Information: Bug cant be fixed by adding vault prevention time/checks for if character is opened vault while change vault with command and etc wont work. When you press T Key it gives the problem that the gs thinks you are not using vault while you are using it(This normally works but when using T key not works.....) (Maybe lacking of quest system code makes this problem).

The only solution for now is this:
To fix it:

-> Open (CommandManager.cpp)
-> Search for Function:

Code:

case Command::MultiVault:

-> Search inside the function for this part of code:

Code:

if (iVaultNumber > 5 || iVaultNumber < 0) { GCServerMsgStringSend("Warehouse range: 0-5", lpUser->m_Index,1); return; }

-> After this part of code ADD:

Code:

gObjCloseSet(lpUser->m_Index, 1);

(This part of code will make after you use /vault to go on Select Character Screen with the new vault opened when you login back.)

P.p: I will share my full repack(latest) these days when I have some free time to remove my test code shits and etc.....

if(lpObj->WarehouseSave != 0) return;

if(lpObj->m_IfState.use > 0
&& lpObj->m_IfState.type == 6
&& lpObj->m_IfState.state == 1)
{
return;
}

if(lpObj->TargetShopNumber > 0) return;

Try to use Vault Checks to prevent that

Omaruu · Mar 27, 2017

josesp said:
Try to use Vault Checks to prevent that

Not work there is bug with Quest System.
When you press T button for Quests it automatically makes you m_IfState.use == 0.

pravednik · Apr 10, 2017

Omaruu said:
Here my latest source:
Btw: High CPU/Memory usage on zMultiServer is becouse logs(THEY ARE DISABLED) you can enable them if you want in CQuery.cpp: ->

Code:

BOOL CQuery::Exec(LPCTSTR szSQL)

You must be registered to see links

Update the link please

Omaruu · Apr 11, 2017

Here you are new link + new update:

You must be registered to see links

If someone wants can make mirror link.

pravednik · Apr 12, 2017

1>------ Построение начато: проект: zGameServer, Конфигурация: Release Win32 ------1>Построение начато 12.04.2017 6:42:52.1>InitializeBuildStatus:1> Создание "Release\zGameServer.unsuccessfulbuild", так как было задано "AlwaysCreate".1>ClCompile:1> StdAfx.cpp1> BlueEvent.cpp1>c:\users\Pravednik\desktop\12.04.2017\ex802_source\source\ItemSystemFor380.h(97): warning C4996: 'vsprintf': This function or variable may be unsafe. Consider using vsprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.1> c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\stdio.h(371): см. объявление "vsprintf"1>c:\users\Pravednik\desktop\12.04.2017\ex802_source\source\user.h(1414): error C2086: int OBJECTSTRUCT: