Erro ao adicionar um evento

Oi galera gostaria de uma ajuda sou leigo nesse assunto de programação estou tentando colocar um evento automático de (Matamata) mas esta dando uns erros Segue abaixo o Print do erro


[Only registered and activated users can see links. Click Here To Register...]



Segue a baixo os codigos que usei

Matamata.cpp

Código:

---

#include "StdAfx.h"


cMataMata cMata;


void cMataMata::ResetMEvent()
{
InitTime = 0;
InitSeconds = 0;
TimeStage = 0;
SecondsStage = 0;
pCount = 0;
mtRunning = false;
Activated = false;
NextStage = false;
Finalize = false;
CurStage = 0;
TotalStages = 0;


for (int m = 0; m < MAXMTSTAGE; m++)
{
sMata[m].InCurse = false;
sMata[m].playerCount = 0;
sMata[m].InRound[0] = -1;
sMata[m].InRound[1] = -1;


for (int x = 4800; x < 5800; x++)
{
psPlayer[x].inMataEvent = 0;
psPlayer[x].WinnerLoser = 0;
psPlayer[x].MoveTime = 0;
psPlayer[x].pFighting = false;
psPlayer[x].pWaiting = false;
psPlayer[x].pScore = 0;
psPlayer[x].Index = -1;
psPlayer[x].pStage = 0;
sMata[m].sPlayer[x].Index = 0;
}
}
}


void cMataMata::Load()
{
ResetMEvent();
}


void cMataMata::GmCmdInit(LPOBJ lpObj, char* msg)
{
int aIndex = lpObj->m_Index;
int TempTime = atoi(msg);




if (TempTime < 1)
{
MsgOutput(aIndex, "Erro na configuração do evento!");
return;
}


InitTime = TempTime * 60;


if (pObj[aIndex].mAutority < 1)
{
MsgOutput(aIndex, "Você não tem autoridade para isso.");
return;
}


else if (Activated == true)
{
MsgOutput(aIndex, "Mata-Mata já está ativado.");
return;
}
else if(mtRunning == true)
{
MsgOutput(aIndex, "Mata-Mata já está rolando.");
return;
}
else if (psPlayer[aIndex].inMataEvent != 0)
{
MsgOutput(aIndex, "Você já éstá ocupado");
return;
}
else
{
psPlayer[aIndex].inMataEvent = 2;
Activated = true;
CurStage = 1;
AllServerAnnounce("%s iniciou o Mata-Mata", lpObj->Name);
MsgOutputAll("digite [/ir] para participar");
}
}


void cMataMata::PlayerCmdIWant(LPOBJ lpObj)
{
int aIndex = lpObj->m_Index;


if (mtRunning == true)
{
MsgOutput(aIndex, "Mata-Mata já está rolando.");
return;
}
else if (Activated == false)
{
MsgOutput(aIndex, "Mata-Mata não está ativado.");
return;
}
else if (psPlayer[aIndex].inMataEvent != 0)
{
MsgOutput(aIndex, "Você já está %s", (sMata->sPlayer[aIndex].inMataEvent == 1) ? "no evento" : "ocupado");
return;
}
else if (psPlayer[aIndex].pWaiting == true)
{
MsgOutput(aIndex, "Você já está aguardando.");
return;
}
else
{

psPlayer[aIndex].pWaiting = true;
psPlayer[aIndex].pStage = CurStage;
psPlayer[aIndex].inMataEvent = 1;
int id = GetPlayerCount();
sMata[CurStage].aIndex[id] = aIndex;

MsgOutput(aIndex, "Você entrou no Mata-Mata %d", id);
MsgOutput(aIndex, "Fique atento que vai começar!");
gObjTeleport(aIndex, 6, 72, 160);
sMata[CurStage].playerCount++;
}
}


void cMataMata::MataMataStart()
{

if (Activated == true && InitTime > 0)
InitSeconds++;


int TempRest;
TempRest = InitSeconds == (InitTime - 59) ? 1 : InitSeconds == (InitTime - 119) ? 2 : InitSeconds == (InitTime - 179) ? 3 : 4;
if (InitSeconds == (InitTime - 59) || InitSeconds == (InitTime - 119) || InitSeconds == (InitTime - 179) || InitSeconds == (InitTime - 239))
AllServerAnnounce("Mata-Mata começará em %d minuto(s)", TempRest);

if (InitSeconds == InitTime && mtRunning == false && Activated == true)
{
Activated = false;
InitSeconds = 0;
InitTime = 0;
TimeStage = 0;
SecondsStage = 0;
mtRunning = true;

sMata[CurStage].InCurse = true;
TotalStages = TotalStage();
AllServerAnnounce("MataMata Começou! %d", GetPlayerCount());
}


if (mtRunning == true)
{

if (NextStage == true)
{
if (TimeStage > 0)
SecondsStage++;


if (SecondsStage == TimeStage)
{
if (CurStage < TotalStages)
{
if (sMata[CurStage].InCurse == false)
{
CurStage++;
sMata[CurStage].InCurse = true;
TotalStages = TotalStage();


AllServerAnnounce("%s", (TotalStages - CurStage) == 0 ? "[Mata-mata]Última Rodada" : (TotalStages - CurStage) == 1 ? "[Mata-mata]Penultima Rodada" : "[Mata-mata]Próxima Rodada");
}
}
else
{
if (Finalize == true)
{
AllServerAnnounce("Mata-mata acabou!");
ResetMEvent();
}
}


NextStage = false;
TimeStage = 0;
SecondsStage = 0;
}
}
}
}


void cMataMata::SetPlayerToFight(LPOBJ lpObj)
{
int aIndex = lpObj->m_Index;

if (mtRunning == true && Activated == false && sMata[CurStage].InCurse == true)
{
if (lpObj->Connected == 3)
{
int TempContage = CountStagePlayer(CurStage);
int pRander;

if (TempContage > 1)
{
if (sMata[CurStage].InRound[0] == -1)
{
srand((unsigned)time(NULL));
pRander = 1 + (rand() % CountStagePlayer(CurStage));


if (psPlayer[aIndex].pWaiting == true && psPlayer[aIndex].pStage == CurStage)
{
if (sMata[CurStage].aIndex[pRander] == aIndex && psPlayer[aIndex].pFighting == false)
{
psPlayer[aIndex].pWaiting = false;
psPlayer[aIndex].pFighting = true;
gObjTeleport(aIndex, 6, 121, 115);
lpObj->PkLevel = 6;
GCPkLevelSend(aIndex, 6);
sMata[CurStage].InRound[0] = aIndex;


}
}
}
if (sMata[CurStage].InRound[1] == -1)
{
srand((unsigned)time(NULL));
pRander = 1 + (rand() % CountStagePlayer(CurStage));
if (psPlayer[aIndex].pWaiting == true && psPlayer[aIndex].pStage == CurStage)
{
if (sMata[CurStage].aIndex[pRander] == aIndex && psPlayer[aIndex].pFighting == false)
{
psPlayer[aIndex].pWaiting = false;
psPlayer[aIndex].pFighting = true;
gObjTeleport(aIndex, 6, 121, 116);
lpObj->PkLevel = 6;
GCPkLevelSend(aIndex, 6);
sMata[CurStage].InRound[1] = aIndex;
MsgOutputAll("%s X %s", gObj[sMata[CurStage].InRound[0]].Name, gObj[sMata[CurStage].InRound[1]].Name);
}
}
}
}
else if (TempContage == 1) // quando sobrar 1, joga ele pra próxima fase
{
srand((unsigned)time(NULL));
int TempCont = 1 + (rand() % CountStagePlayer(CurStage));


if (psPlayer[aIndex].pWaiting == true && psPlayer[aIndex].pStage == CurStage && psPlayer[aIndex].pFighting == false)
{


psPlayer[aIndex].pStage++;
sMata[psPlayer[aIndex].pStage].aIndex[CountStagePlayer(psPlayer[aIndex].pStage)] = aIndex;
MsgOutputAll("%s foi para próxima fase por W.O", lpObj->Name);
}
}
else
{

}
}
}
}


void cMataMata::SetPlayerEstage(LPOBJ lpObj, LPOBJ lpTarget)
{
int aIndex = lpObj->m_Index;
int tIndex = lpTarget->m_Index;
int Contp,TempCont;


if (mtRunning == true)
{
if (sMata[CurStage].InCurse == true)
{
if (psPlayer[aIndex].inMataEvent > 0 && psPlayer[tIndex].inMataEvent > 0 && psPlayer[aIndex].pFighting && psPlayer[tIndex].pFighting)
{
sMata[CurStage].sPlayer[aIndex].pScore++;
AllServerAnnounce("%s %d X %d %s", lpObj->Name, sMata[CurStage].sPlayer[aIndex].pScore, sMata[CurStage].sPlayer[tIndex].pScore, lpTarget->Name);

if (sMata[CurStage].sPlayer[aIndex].pScore == 3)
{

psPlayer[aIndex].pStage++;
TempCont = CountStagePlayer(psPlayer[aIndex].pStage);
psPlayer[aIndex].WinnerLoser = 1;
psPlayer[tIndex].WinnerLoser = 2;
psPlayer[aIndex].pFighting = false;
psPlayer[aIndex].pWaiting = false;
sMata[CurStage].sPlayer[aIndex].pScore = 0;
sMata[psPlayer[aIndex].pStage].aIndex[TempCont] = aIndex;



sMata[CurStage].sPlayer[tIndex].pScore = 0;
psPlayer[tIndex].inMataEvent = 0;
psPlayer[tIndex].pFighting = false;
psPlayer[tIndex].pWaiting = false;
psPlayer[tIndex].pStage = 0;

AllServerAnnounce("%s Venceu %s no Mata-mata", lpObj->Name,lpTarget->Name);

if (CountStagePlayer(CurStage) == 0)
{
if (CurStage == TotalStages)
{
AllServerAnnounce("%s Ganhou o Mata-mata", lpObj->Name);
TimeStage = 12;
Finalize = true;
NextStage = true;
}
else
{
TimeStage = 12;
if (GetPlayerCount() > 1)
{
NextStage = true;
sMata[CurStage].InCurse = false;
}
sMata[CurStage].InRound[0] = -1;
sMata[CurStage].InRound[1] = -1;
}
}
}
}
}
}
}


void cMataMata::MoveOfFightArea(LPOBJ lpObj)
{
int aIndex = lpObj->m_Index;
if (this->Activated == true || this->mtRunning)
{
if (psPlayer[aIndex].WinnerLoser != 0)
{
psPlayer[aIndex].MoveTime++;
if (psPlayer[aIndex].MoveTime >= 6)
{
if (psPlayer[aIndex].WinnerLoser == 1)
{


gObjTeleport(aIndex, 6, 72, 160);
psPlayer[aIndex].WinnerLoser = 0;
psPlayer[aIndex].MoveTime = 0;
psPlayer[aIndex].pWaiting = true;
}
else
{
lpObj->PkLevel = 3;
GCPkLevelSend(aIndex, 3);
gObjTeleport(aIndex, 6, 69, 93);
psPlayer[aIndex].WinnerLoser = 0;
psPlayer[aIndex].MoveTime = 0;
}

}
}
}
}


int cMataMata::CountStagePlayer(BYTE Stage)
{
int cont = 0;
if (this->Activated == true || this->mtRunning)
{
for (int i = 4800; i < 5800; i++)
{
if (gObj[i].Connected == 3)
{
if (psPlayer[i].inMataEvent == 1 && psPlayer[i].pStage == Stage)
{
cont++;
}
}
}
}
return cont;
}


int cMataMata::GetPlayerCount()
{
int cont = 0;
if (this->Activated == true || this->mtRunning)
{
for (int i = 4800; i < 5800; i++)
{
if (gObj[i].Connected == 3)
{
if (psPlayer[i].inMataEvent == 1)
{
cont++;
}
}
}
}
return cont;
}


int cMataMata::GetPlayerWaiting()
{
int cont = 0;
if (this->Activated == true || this->mtRunning)
{
for (int i = 4800; i < 5800; i++)
{
if (gObj[i].Connected == 3)
{
if (psPlayer[i].inMataEvent == 1 && psPlayer[i].pWaiting == true)
{
cont++;
}
}
}
}
return cont;
}


BYTE cMataMata::TotalStage()
{
int stage = 0;
int totalplayer = GetPlayerWaiting();




if (totalplayer >= 2)
{
if (totalplayer % 2 != 0)
stage = (totalplayer + 1) / 2;
else
stage = totalplayer / 2;
}
else
{
stage = 1;
}

return stage;
}

---

Matamata.h

Código:

---

#pragma once


#define MAXMTSTAGE 20
#define MAXMTPLAYER 20


struct sMTPlayer
{
BYTE inMataEvent; // 0 = no, 1 = player, 2 = gm
BYTE WinnerLoser; // 0 neutro, 1 = win, 2 = lose
bool pWaiting; // user
bool pFighting; // user
short pScore; // user
BYTE pStage; // user
int Index;


BYTE MoveTime;
};


struct sMataMata
{
sMTPlayer sPlayer[5800];
bool InCurse;
int aIndex[MAXMTPLAYER];
int InRound[2];
short playerCount;
};






class cMataMata
{
public:
void Load();
void GmCmdInit(LPOBJ lpObj, char* msg);
void PlayerCmdIWant(LPOBJ lpObj);
void MataMataStart();
void SetPlayerEstage(LPOBJ lpObj, LPOBJ lpTarget);
void SetPlayerToFight(LPOBJ lpObj);
void MoveOfFightArea(LPOBJ lpObj);


private:


void ResetMEvent();

int GetPlayerCount();
int CountStagePlayer(BYTE Stage);
BYTE TotalStage();
int GetPlayerWaiting();

short InitTime;
short InitSeconds;


short TimeStage, SecondsStage;


int pCount;
BYTE CurStage;
BYTE TotalStages;
bool mtRunning;
bool Activated;
bool NextStage;
bool Finalize;
sMataMata sMata[MAXMTSTAGE];
sMTPlayer psPlayer[5800];

};


extern cMataMata cMata;

---

Você não declarou MsgOutput, MsgOutputAll nem AllServerAnnoun, da source que você removeu isto, da um F12 sobre cada função e veja a declaração que citei, e declara na sua custom.

Eu nao peguei esse codigo de nem uma Source ele foi postado aqui no forum

E valeu por me falar do F12 isso vai me ajudar a tentar pegar o OffTrade de uma Source para tentar colocar nessa

Certo, caso não encontre as declarações avise para podermos ajudar.

eu nao achei se poder ajuda agradeço

Bom, vamos la.

Arquivo .CPP

Código:

---

FUNCTION cFunctions;

void FUNCTION::SendMsgOut(DWORD aIndex,char *szMsg ...)
{
        char Text[150];
        va_list pArgs;
        va_start(pArgs, szMsg);
        vsprintf(Text,szMsg,pArgs);
        va_end(pArgs);
        GCServerMsgStringSend(Text, aIndex, 1);
}

void FUNCTION::SendMsgOutAll(char*Text, int type )
{
        for(int i=OBJECT_MIN;i<OBJECT_MAX;i++)
        {
                OBJECTSTRUCT *lpObj = (OBJECTSTRUCT*)OBJECT_POINTER(i);
               
                if(lpObj->Connected == 3)
                {
                  GCServerMsgStringSend(Text,i,type);
                }
        }
}

void FUNCTION::ConnectSystem(int aIndex)
{
        OBJECTSTRUCT * lpObj = (OBJECTSTRUCT*)OBJECT_POINTER(aIndex);

        char Message[150];
        sprintf(Message,"Ola [%s], Seja bem Vindo ao Servidor!",lpObj->Name);
        GCServerMsgStringSend(Message, aIndex,0);
}

---

Arquivo .H

Código:

---

class FUNCTION{
public:
        static void SendMsgOut(DWORD aIndex,char *szMsg ...);
        static void SendMsgOutAll(char*Text, int type );
        static void ConnectSystem(int aIndex);
};

extern FUNCTION cFunctions;

---

Para o ConnectSystem funcionar, você deve chamar ele no seu ProtocolCore na case 0x03

Só colocar isso aqui la FUNCTION::ConnectSystem(aIndex);


Obs; estou sem VS onde estou, fiz pelo Bloca de Notas, mais acho que é isso mesmo.

colocando o FUNCTION::ConnectSystem(aIndex); tiro aqueles erros agora esse codigo que vc colocou .cpp .h eu tenho que criar eles tipo Funçao.cpp ou colocar o .cpp junto com o matamata.cpp

Vi que agora ficou um outro erro no Arquivo matamata.cpp
[Only registered and activated users can see links. Click Here To Register...]




OBS: Obrigado pela ajuda que vc esta me dando

Bom desculpa pela demora, fui em um casamento cheguei tarde e não entrei.

Sim, você deve ter o arquivo functions.cpp e functions.h .

Bom provavelmente seu ponteiro de acesso a Struct não deve estar feito corretamente ou não foi declarado, então eu teria que ver o código.
você pode solucionar isso chamando o ponteiro na requisição citada ai, no caso o ponteiro correto seria da seguinte forma.

Código:

---

OBJECTSTRUCT * gObj = (OBJECTSTRUCT*)OBJECT_POINTER(aIndex);

---

Seria legal você passar seu Skype para melhor poder te ajudar.

pode add ai o Skype

SKYPE REMOVIDO

Atenção

Contatos devem ser enviados apenas via MP

Você precisa também fazer uma thread para rodar o sistema!