Custom Ranking New V2 Lado Main

[Dakosmu]

Custom Ranking New V2 Lado Main

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

stdafx.h

Código [Seleccionar] Expandir

#define RANKING_NEW                    1

Ranking.cpp

Ranking.cpp

Ranking.h

Ranking.h

Protocol.h

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
struct UP_SEND_REQ
{
    PSBMSG_HEAD h;
};
#endif

Protocol.h

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
        case 0xFE:    gRanking.RecvInfo((DGCharTop*)lpMsg);            break;
        case 0x50:    gRanking.RecvInfoWC((DGCharTopWC*)lpMsg);        break;
        case 0x59:    gRanking.RecvInfoBC((DGCharTopBC*)lpMsg);        break;
        case 0x60:    gRanking.RecvInfoDC((DGCharTopDC*)lpMsg);        break;
        case 0x71:    gRanking.RecvInfoCC((DGCharTopCC*)lpMsg);        break;
        case 0x72:    gRanking.RecvInfoPoint((DGCharTopPoint*)lpMsg);    break;
        case 0x73:    gRanking.RecvInfoPK((DGCharTopPK*)lpMsg);        break;
        case 0x74:    gRanking.RecvInfoMT((DGCharTopMT*)lpMsg);        break;
        case 0x75:    gRanking.RecvInfoGD((DGCharTopGD*)lpMsg);        break;

        case 0x76:    gRanking.RecvInfoDW((DGCharTopDW*)lpMsg);        break;
        case 0x77:    gRanking.RecvInfoDK((DGCharTopDK*)lpMsg);        break;
        case 0x7D:    gRanking.RecvInfoEF((DGCharTopEF*)lpMsg);        break;
        case 0x79:    gRanking.RecvInfoMG((DGCharTopMG*)lpMsg);        break;
        case 0x7A:    gRanking.RecvInfoDL((DGCharTopDL*)lpMsg);        break;
        case 0x7B:    gRanking.RecvInfoSU((DGCharTopSU*)lpMsg);        break;
        case 0x7C:    gRanking.RecvInfoRF((DGCharTopRF*)lpMsg);        break;
        case 0x7E:    gRanking.RecvInfoDVT((DGCharTopDVT*)lpMsg);        break;

#endif

Interface.h

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
            eCONFIRM_MUUN,
            eCONFIRM_MUUNBTN_OK,
            eCONFIRM_MUUNBTN_CANCEL,
            ChonTopAll,
            ChonTopWC,
            ChonTopEvent,
            ChonTopMaster,
            ChonTopGuild,
            eMAIN_RANKING,
            ChonTopDW,
            ChonTopDK,
            ChonTopEF,
            ChonTopMG,
            ChonTopDL,
            ChonTopSU,
            ChonTopRF,
#endif

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
    int SPKText(DWORD Color, int PosX, int PosY, int Width, int Align, LPCSTR Text, ...);
    bool IsWorkZone2(float X, float Y, float MaxX, float MaxY);

#endif

Interface.cpp

void Interface::Load()

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
    gRanking.BingImg();
#endif

void Interface::LoadImages()

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
    pLoadImage("Custom\\SuperKhung\\Other\\BangSuKien.tga", 0x17904, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\SPK-logo.tga", 0x17905, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\Ranking.tga", 0x17906, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\Donate.tga", 0x17907, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\ButtonA.tga", 0x17908, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\ButtonB.tga", 0x17909, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\Exit.tga", 0x17910, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\LuckySpin.tga", 0x17911, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\CTC.tga", 0x17912, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\TMC.tga", 0x17913, 0x2601, 0x2901, 1, 0);
    pLoadImage("Custom\\SuperKhung\\Other\\Frame.tga", 50000, 0x2601, 0x2901, 1, 0);

#endif

void Interface::Work()

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
    gRanking.Draw();
#endif

if (GetKeyState(VK_ESCAPE) < 0)

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
            if (gRanking.Show == true)
            {
                gRanking.Show = false;
                pSetCursorFocus = false;
            }
#endif

MENU

this->Data[eMenu_OPT1].EventTick = GetTickCount()

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
    UP_SEND_REQ pRequest;
    pRequest.h.set(0xFD, 0x21, sizeof(pRequest));
    DataSend((BYTE*)&pRequest, pRequest.h.size);
    gRanking.Show = true;
#endif

Pegar al final de Interface.cpp

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
int Interface::SPKText(DWORD Color, int PosX, int PosY, int Width, int Align, LPCSTR Text, ...)
{
    char Buff[2048];
    int BuffLen = sizeof(Buff) - 1;
    ZeroMemory(Buff, BuffLen);

    va_list args;
    va_start(args, Text);
    int Len = vsprintf_s(Buff, BuffLen, Text, args);
    va_end(args);

    int LineCount = 0;

    char* Line = strtok(Buff, "\n");

    while (Line != NULL)
    {
        // Xá»Â� lý dấu phẩy cho số
        //std::string str = Line;
        //std::stringstream ss(str);
        //std::string token;
        //std::vector<std::string> tokens;
        //while (getline(ss, token, ' ')) {
        //    tokens.push_back(token);
        //}

        // Xác Ã,,‘ịnh số cần hiá»Æ'n thị dấu phẩy
        //std::string num_str = tokens.back();
        //int num = atoi(num_str.c_str());

        // Xóa số cuối cùng khá»Â�i tokens
        //tokens.pop_back();

        //// Tạo string má»›i có chứa dấu phẩy
        //std::string new_str = "";
        //if (num < 1000) {
        //    new_str = num_str;
        //}
        //else {
        //    int num_digit = num_str.size();
        //    int num_commas = (num_digit - 1) / 3;
        //    int start = 0;
        //    for (int i = 0; i < num_commas; i++) {
        //        int end = num_digit - 3 * (i + 1);
        //        new_str = "," + num_str.substr(end, 3) + new_str;
        //        start = end;
        //    }
        //    new_str = num_str.substr(0, start) + new_str;
        //}

        //// Thêm số có dấu phẩy vào tokens
        //tokens.push_back(new_str);

        //// Ghép các tokens lại thành string
        //std::string new_line = "";
        //for (int i = 0; i < tokens.size(); i++) {
        //    if (i != 0) new_line += " ";
        //    new_line += tokens[i];
        //}

        //// Hiá»Æ'n thị Ã,,‘oạn text vá»›i số có dấu phẩy
        //pDrawColorText(new_line.c_str(), PosX, PosY, Width, 0, Color, 0, Align);

        //PosY += 10;
        //Line = strtok(NULL, "\n");
    }

    return PosY;
}
bool Interface::IsWorkZone2(float X, float Y, float MaxX, float MaxY)
{
    if ((gObjUser.m_CursorX < X || gObjUser.m_CursorX > MaxX)
        || (gObjUser.m_CursorY < Y || gObjUser.m_CursorY > MaxY))
    {
        return false;
    }
    // ----
    return true;
}

#endif

Controller.h

class Controller

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
    WPARAM    wMouse;
#endif

Controlle.cpp

case WM_LBUTTONDOWN:

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
            gRanking.ClickRanking(wParam);
#endif

[Dakosmu]

LADO GAMESERVER

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

stdafx.h

Código [Seleccionar] Expandir

#define RANKING_NEW 1

CustomRanking.cpp

Código [Seleccionar] Expandir

#include "StdAfx.h"
#if(RANKING_NEW)
#include "CustomRanking.h"
#include "GameMain.h"
#include "DSProtocol.h"
#include "user.h"
#include "protocol.h"
#include "Util.h"
#include "Log.h"

cRanking gRanking;

void cRanking::SendDS()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x17, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDS(DGCharTop* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingChar[i].Name, Recv->tp[i].Name, 11);
this->RankingChar[i].Class = Recv->tp[i].Class;
this->RankingChar[i].level = Recv->tp[i].level;
this->RankingChar[i].Reset = Recv->tp[i].Reset;
this->RankingChar[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingChar[i].Time = Recv->tp[i].Time;
strncpy(this->RankingChar[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUser(LPOBJ lpObj)
{
DGCharTop2 sClient;
sClient.h.set(0xFE, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingChar[i].Name, 11);
sClient.tp[i].Class = this->RankingChar[i].Class;
sClient.tp[i].level = this->RankingChar[i].level;
sClient.tp[i].Reset = this->RankingChar[i].Reset;
sClient.tp[i].HoiSinh = this->RankingChar[i].HoiSinh;
sClient.tp[i].Time = this->RankingChar[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingChar[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

void cRanking::SendDSPoint()
{
BYTE send[4096];
GDTopPoint pMsg;
pMsg.h.set(0xD9, 0x29, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSPoint(DGCharTopPoint* Recv)
{
for (int iPoint = 0; iPoint < MAXTOP; iPoint++)
{
strncpy(this->RankingCharPoint[iPoint].Name, Recv->tp[iPoint].Name, 11);
this->RankingCharPoint[iPoint].IsPoint = Recv->tp[iPoint].IsPoint;
this->RankingCharPoint[iPoint].IsStr = Recv->tp[iPoint].IsStr;
this->RankingCharPoint[iPoint].IsAgi = Recv->tp[iPoint].IsAgi;
this->RankingCharPoint[iPoint].IsVit = Recv->tp[iPoint].IsVit;
this->RankingCharPoint[iPoint].IsEne = Recv->tp[iPoint].IsEne;
this->RankingCharPoint[iPoint].IsCmd = Recv->tp[iPoint].IsCmd;
}
}
void cRanking::SendUserPoint(LPOBJ lpObj)
{
DGCharTop2Point sClient;
sClient.h.set(0x72, sizeof(sClient));
for (int iPoint = 0; iPoint < MAXTOP; iPoint++)
{
strncpy(sClient.tp[iPoint].Name, this->RankingCharPoint[iPoint].Name, 11);
sClient.tp[iPoint].IsPoint = this->RankingCharPoint[iPoint].IsPoint;
sClient.tp[iPoint].IsStr = this->RankingCharPoint[iPoint].IsStr;
sClient.tp[iPoint].IsAgi = this->RankingCharPoint[iPoint].IsAgi;
sClient.tp[iPoint].IsVit = this->RankingCharPoint[iPoint].IsVit;
sClient.tp[iPoint].IsEne = this->RankingCharPoint[iPoint].IsEne;
sClient.tp[iPoint].IsCmd = this->RankingCharPoint[iPoint].IsCmd;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}
void cRanking::SendDSWC()
{
BYTE send[4096];
GDTopWC pMsg;
pMsg.h.set(0xD9, 0x18, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSWC(DGCharTopWC* Recv)
{
for (int iWC = 0; iWC < MAXTOP; iWC++)
{
strncpy(this->RankingCharWC[iWC].Name, Recv->tp[iWC].Name, 11);
this->RankingCharWC[iWC].gWCoinC = Recv->tp[iWC].gWCoinC;
this->RankingCharWC[iWC].gWCoinP = Recv->tp[iWC].gWCoinP;
this->RankingCharWC[iWC].gWCoinG = Recv->tp[iWC].gWCoinG;
this->RankingCharWC[iWC].gWCoinR = Recv->tp[iWC].gWCoinR;
}
}
void cRanking::SendUserWC(LPOBJ lpObj)
{
DGCharTop2WC sClient;
sClient.h.set(0x50, sizeof(sClient));
for (int iWC = 0; iWC < MAXTOP; iWC++)
{
strncpy(sClient.tp[iWC].Name, this->RankingCharWC[iWC].Name, 11);
sClient.tp[iWC].gWCoinC = this->RankingCharWC[iWC].gWCoinC;
sClient.tp[iWC].gWCoinP = this->RankingCharWC[iWC].gWCoinP;
sClient.tp[iWC].gWCoinG = this->RankingCharWC[iWC].gWCoinG;
sClient.tp[iWC].gWCoinR = this->RankingCharWC[iWC].gWCoinR;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}
void cRanking::SendDSBC()
{
BYTE send[4096];
GDTopBC pMsg;
pMsg.h.set(0xD9, 0x26, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSBC(DGCharTopBC* Recv)
{
for (int iBC = 0; iBC < MAXTOP; iBC++)
{
strncpy(this->RankingCharBC[iBC].Name, Recv->tp[iBC].Name, 11);
this->RankingCharBC[iBC].BloodCastle = Recv->tp[iBC].BloodCastle;
}
}
void cRanking::SendUserBC(LPOBJ lpObj)
{
DGCharTop2BC sClient;
sClient.h.set(0x59, sizeof(sClient));
for (int iBC = 0; iBC < MAXTOP; iBC++)
{
strncpy(sClient.tp[iBC].Name, this->RankingCharBC[iBC].Name, 11);
sClient.tp[iBC].BloodCastle = this->RankingCharBC[iBC].BloodCastle;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//Devil
void cRanking::SendDSDC()
{
BYTE send[4096];
GDTopDC pMsg;
pMsg.h.set(0xD9, 0x27, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSDC(DGCharTopDC* Recv)
{
for (int iDC = 0; iDC < MAXTOP; iDC++)
{
strncpy(this->RankingCharDC[iDC].Name, Recv->tp[iDC].Name, 11);
this->RankingCharDC[iDC].DevilSquare = Recv->tp[iDC].DevilSquare;
}
}
void cRanking::SendUserDC(LPOBJ lpObj)
{
DGCharTop2DC sClient;
sClient.h.set(0x60, sizeof(sClient));
for (int iDC = 0; iDC < MAXTOP; iDC++)
{
strncpy(sClient.tp[iDC].Name, this->RankingCharDC[iDC].Name, 11);
sClient.tp[iDC].DevilSquare = this->RankingCharDC[iDC].DevilSquare;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//Chaos
void cRanking::SendDSCC()
{
BYTE send[4096];
GDTopCC pMsg;
pMsg.h.set(0xD9, 0x28, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSCC(DGCharTopCC* Recv)
{
for (int iCC = 0; iCC < MAXTOP; iCC++)
{
strncpy(this->RankingCharCC[iCC].Name, Recv->tp[iCC].Name, 11);
this->RankingCharCC[iCC].ChaosCastle = Recv->tp[iCC].ChaosCastle;
}
}
void cRanking::SendUserCC(LPOBJ lpObj)
{
DGCharTop2CC sClient;
sClient.h.set(0x71, sizeof(sClient));
for (int iCC = 0; iCC < MAXTOP; iCC++)
{
strncpy(sClient.tp[iCC].Name, this->RankingCharCC[iCC].Name, 11);
sClient.tp[iCC].ChaosCastle = this->RankingCharCC[iCC].ChaosCastle;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

void cRanking::SendDSPK()
{
BYTE send[4096];
GDTopPK pMsg;
pMsg.h.set(0xD9, 0x2A, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSPK(DGCharTopPK* Recv)
{
for (int iPK = 0; iPK < MAXTOP; iPK++)
{
strncpy(this->RankingCharPK[iPK].Name, Recv->tp[iPK].Name, 11);
this->RankingCharPK[iPK].WinScore = Recv->tp[iPK].WinScore;
this->RankingCharPK[iPK].LoseScore = Recv->tp[iPK].LoseScore;
}
}
void cRanking::SendUserPK(LPOBJ lpObj)
{
DGCharTop2PK sClient;
sClient.h.set(0x73, sizeof(sClient));
for (int iPK = 0; iPK < MAXTOP; iPK++)
{
strncpy(sClient.tp[iPK].Name, this->RankingCharPK[iPK].Name, 11);
sClient.tp[iPK].WinScore = this->RankingCharPK[iPK].WinScore;
sClient.tp[iPK].LoseScore = this->RankingCharPK[iPK].LoseScore;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

void cRanking::SendDSMT()
{
BYTE send[4096];
GDTopMT pMsg;
pMsg.h.set(0xD9, 0x2B, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSMT(DGCharTopMT* Recv)
{
for (int iMT = 0; iMT < MAXTOP; iMT++)
{
strncpy(this->RankingCharMT[iMT].Name, Recv->tp[iMT].Name, 11);
this->RankingCharMT[iMT].Master = Recv->tp[iMT].Master;
this->RankingCharMT[iMT].PointMaster = Recv->tp[iMT].PointMaster;
}
}
void cRanking::SendUserMT(LPOBJ lpObj)
{
DGCharTop2MT sClient;
sClient.h.set(0x74, sizeof(sClient));
for (int iMT = 0; iMT < MAXTOP; iMT++)
{
strncpy(sClient.tp[iMT].Name, this->RankingCharMT[iMT].Name, 11);
sClient.tp[iMT].Master = this->RankingCharMT[iMT].Master;
sClient.tp[iMT].PointMaster = this->RankingCharMT[iMT].PointMaster;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

void cRanking::SendDSGD()
{
BYTE send[4096];
GDTopGD pMsg;
pMsg.h.set(0xD9, 0x2C, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSGD(DGCharTopGD* Recv)
{
for (int iGD = 0; iGD < MAXTOP; iGD++)
{
strncpy(this->RankingCharGD[iGD].Name, Recv->tp[iGD].Name, 11);
strncpy(this->RankingCharGD[iGD].Guild, Recv->tp[iGD].Guild, 11);
this->RankingCharGD[iGD].G_Score = Recv->tp[iGD].G_Score;
this->RankingCharGD[iGD].G_Level = Recv->tp[iGD].G_Level;
}
}
void cRanking::SendUserGD(LPOBJ lpObj)
{
DGCharTop2GD sClient;
sClient.h.set(0x75, sizeof(sClient));
for (int iGD = 0; iGD < MAXTOP; iGD++)
{
strncpy(sClient.tp[iGD].Name, this->RankingCharGD[iGD].Name, 11);
strncpy(sClient.tp[iGD].Guild, this->RankingCharGD[iGD].Guild, 11);
sClient.tp[iGD].G_Score = this->RankingCharGD[iGD].G_Score;
sClient.tp[iGD].G_Level = this->RankingCharGD[iGD].G_Level;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//DW
void cRanking::SendDSDW()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x2D, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSDW(DGCharTopDW* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharDW[i].Name, Recv->tp[i].Name, 11);
this->RankingCharDW[i].Class = Recv->tp[i].Class;
this->RankingCharDW[i].level = Recv->tp[i].level;
this->RankingCharDW[i].Reset = Recv->tp[i].Reset;
this->RankingCharDW[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharDW[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharDW[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserDW(LPOBJ lpObj)
{
DGCharTop2DW sClient;
sClient.h.set(0x76, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharDW[i].Name, 11);
sClient.tp[i].Class = this->RankingCharDW[i].Class;
sClient.tp[i].level = this->RankingCharDW[i].level;
sClient.tp[i].Reset = this->RankingCharDW[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharDW[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharDW[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharDW[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//DK
void cRanking::SendDSDK()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x2E, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSDK(DGCharTopDK* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharDK[i].Name, Recv->tp[i].Name, 11);
this->RankingCharDK[i].Class = Recv->tp[i].Class;
this->RankingCharDK[i].level = Recv->tp[i].level;
this->RankingCharDK[i].Reset = Recv->tp[i].Reset;
this->RankingCharDK[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharDK[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharDK[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserDK(LPOBJ lpObj)
{
DGCharTop2DK sClient;
sClient.h.set(0x77, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharDK[i].Name, 11);
sClient.tp[i].Class = this->RankingCharDK[i].Class;
sClient.tp[i].level = this->RankingCharDK[i].level;
sClient.tp[i].Reset = this->RankingCharDK[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharDK[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharDK[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharDK[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//EF
void cRanking::SendDSEF()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x2F, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSEF(DGCharTopEF* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharEF[i].Name, Recv->tp[i].Name, 11);
this->RankingCharEF[i].Class = Recv->tp[i].Class;
this->RankingCharEF[i].level = Recv->tp[i].level;
this->RankingCharEF[i].Reset = Recv->tp[i].Reset;
this->RankingCharEF[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharEF[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharEF[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserEF(LPOBJ lpObj)
{
DGCharTop2EF sClient;
sClient.h.set(0x7D, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharEF[i].Name, 11);
sClient.tp[i].Class = this->RankingCharEF[i].Class;
sClient.tp[i].level = this->RankingCharEF[i].level;
sClient.tp[i].Reset = this->RankingCharEF[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharEF[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharEF[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharEF[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//MG
void cRanking::SendDSMG()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x30, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSMG(DGCharTopMG* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharMG[i].Name, Recv->tp[i].Name, 11);
this->RankingCharMG[i].Class = Recv->tp[i].Class;
this->RankingCharMG[i].level = Recv->tp[i].level;
this->RankingCharMG[i].Reset = Recv->tp[i].Reset;
this->RankingCharMG[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharMG[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharMG[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserMG(LPOBJ lpObj)
{
DGCharTop2MG sClient;
sClient.h.set(0x79, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharMG[i].Name, 11);
sClient.tp[i].Class = this->RankingCharMG[i].Class;
sClient.tp[i].level = this->RankingCharMG[i].level;
sClient.tp[i].Reset = this->RankingCharMG[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharMG[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharMG[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharMG[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//DL
void cRanking::SendDSDL()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x31, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSDL(DGCharTopDL* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharDL[i].Name, Recv->tp[i].Name, 11);
this->RankingCharDL[i].Class = Recv->tp[i].Class;
this->RankingCharDL[i].level = Recv->tp[i].level;
this->RankingCharDL[i].Reset = Recv->tp[i].Reset;
this->RankingCharDL[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharDL[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharDL[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserDL(LPOBJ lpObj)
{
DGCharTop2DL sClient;
sClient.h.set(0x7A, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharDL[i].Name, 11);
sClient.tp[i].Class = this->RankingCharDL[i].Class;
sClient.tp[i].level = this->RankingCharDL[i].level;
sClient.tp[i].Reset = this->RankingCharDL[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharDL[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharDL[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharDL[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//SU
void cRanking::SendDSSU()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x32, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSSU(DGCharTopSU* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharSU[i].Name, Recv->tp[i].Name, 11);
this->RankingCharSU[i].Class = Recv->tp[i].Class;
this->RankingCharSU[i].level = Recv->tp[i].level;
this->RankingCharSU[i].Reset = Recv->tp[i].Reset;
this->RankingCharSU[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharSU[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharSU[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserSU(LPOBJ lpObj)
{
DGCharTop2SU sClient;
sClient.h.set(0x7B, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharSU[i].Name, 11);
sClient.tp[i].Class = this->RankingCharSU[i].Class;
sClient.tp[i].level = this->RankingCharSU[i].level;
sClient.tp[i].Reset = this->RankingCharSU[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharSU[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharSU[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharSU[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//RF
void cRanking::SendDSRF()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x33, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSRF(DGCharTopRF* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharRF[i].Name, Recv->tp[i].Name, 11);
this->RankingCharRF[i].Class = Recv->tp[i].Class;
this->RankingCharRF[i].level = Recv->tp[i].level;
this->RankingCharRF[i].Reset = Recv->tp[i].Reset;
this->RankingCharRF[i].HoiSinh = Recv->tp[i].HoiSinh;
this->RankingCharRF[i].Time = Recv->tp[i].Time;
strncpy(this->RankingCharRF[i].Guild, Recv->tp[i].Guild, 9);
}
}
void cRanking::SendUserRF(LPOBJ lpObj)
{
DGCharTop2RF sClient;
sClient.h.set(0x7C, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharRF[i].Name, 11);
sClient.tp[i].Class = this->RankingCharRF[i].Class;
sClient.tp[i].level = this->RankingCharRF[i].level;
sClient.tp[i].Reset = this->RankingCharRF[i].Reset;
sClient.tp[i].HoiSinh = this->RankingCharRF[i].HoiSinh;
sClient.tp[i].Time = this->RankingCharRF[i].Time;
strncpy(sClient.tp[i].Guild, this->RankingCharRF[i].Guild, 9);
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}

//RF
void cRanking::SendDSDVT()
{
BYTE send[4096];
GDTop pMsg;
pMsg.h.set(0xD9, 0x34, 0);
int size = sizeof(pMsg);
pMsg.Result = 1;
pMsg.h.size[0] = SET_NUMBERHB(size);
pMsg.h.size[1] = SET_NUMBERLB(size);
memcpy(send, &pMsg, sizeof(pMsg));
gDataServerConnection.DataSend(send, size);
}

void cRanking::RecvDSDVT(DGCharTopDVT* Recv)
{
for (int i = 0; i < MAXTOP; i++)
{
strncpy(this->RankingCharDVT[i].Name, Recv->tp[i].Name, 11);
this->RankingCharDVT[i].Devote = Recv->tp[i].Devote;
}
}
void cRanking::SendUserDVT(LPOBJ lpObj)
{
DGCharTop2DVT sClient;
sClient.h.set(0x7E, sizeof(sClient));
for (int i = 0; i < MAXTOP; i++)
{
strncpy(sClient.tp[i].Name, this->RankingCharDVT[i].Name, 11);
sClient.tp[i].Devote = this->RankingCharDVT[i].Devote;
}
DataSend(lpObj->Index, (BYTE*)&sClient, sizeof(sClient));
}
#endif

CustomRanking.h

Código [Seleccionar] Expandir

#pragma once
#include "stdafx.h"
#include "protocol.h"
#if(RANKING_NEW)
#define MAXTOP 100

struct GDTop
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTop
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTop
{
PSWMSG_HEAD h;
CharTop tp[MAXTOP];
};

struct DGCharTop2
{
PWMSG_HEAD h;
CharTop tp[MAXTOP];
};
//Point
struct GDTopPoint
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopPoint
{
char Name[11];
int IsPoint;
int IsStr;
int IsAgi;
int IsVit;
int IsEne;
int IsCmd;
};
struct DGCharTopPoint
{
PSWMSG_HEAD h;
CharTopPoint tp[MAXTOP];
};
struct DGCharTop2Point
{
PWMSG_HEAD h;
CharTopPoint tp[MAXTOP];
};
struct GDTopWC
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopWC
{
char Name[11];
int gWCoinC;
int gWCoinP;
int gWCoinG;
int gWCoinR;
};
struct DGCharTopWC
{
PSWMSG_HEAD h;
CharTopWC tp[MAXTOP];
};
struct DGCharTop2WC
{
PWMSG_HEAD h;
CharTopWC tp[MAXTOP];
};
//Blood
struct GDTopBC
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopBC
{
char Name[11];
int BloodCastle;
};
struct DGCharTopBC
{
PSWMSG_HEAD h;
CharTopBC tp[MAXTOP];
};
struct DGCharTop2BC
{
PWMSG_HEAD h;
CharTopBC tp[MAXTOP];
};
//Devil
struct GDTopDC
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopDC
{
char Name[11];
int DevilSquare;
};
struct DGCharTopDC
{
PSWMSG_HEAD h;
CharTopDC tp[MAXTOP];
};
struct DGCharTop2DC
{
PWMSG_HEAD h;
CharTopDC tp[MAXTOP];
};
//Chaos
struct GDTopCC
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopCC
{
char Name[11];
int ChaosCastle;
};
struct DGCharTopCC
{
PSWMSG_HEAD h;
CharTopCC tp[MAXTOP];
};
struct DGCharTop2CC
{
PWMSG_HEAD h;
CharTopCC tp[MAXTOP];
};

struct GDTopPK
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopPK
{
char Name[11];
int WinScore;
int LoseScore;
};
struct DGCharTopPK
{
PSWMSG_HEAD h;
CharTopPK tp[MAXTOP];
};
struct DGCharTop2PK
{
PWMSG_HEAD h;
CharTopPK tp[MAXTOP];
};

struct GDTopMT
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopMT
{
char Name[11];
int Master;
int PointMaster;
};
struct DGCharTopMT
{
PSWMSG_HEAD h;
CharTopMT tp[MAXTOP];
};
struct DGCharTop2MT
{
PWMSG_HEAD h;
CharTopMT tp[MAXTOP];
};

struct GDTopGD
{
PSWMSG_HEAD h;
BYTE Result;
};
struct CharTopGD
{
char Name[11];
char Guild[11];
int G_Score;
int G_Level;
};
struct DGCharTopGD
{
PSWMSG_HEAD h;
CharTopGD tp[MAXTOP];
};
struct DGCharTop2GD
{
PWMSG_HEAD h;
CharTopGD tp[MAXTOP];
};

//DW
struct GDTopDW
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopDW
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopDW
{
PSWMSG_HEAD h;
CharTopDW tp[MAXTOP];
};

struct DGCharTop2DW
{
PWMSG_HEAD h;
CharTopDW tp[MAXTOP];
};

//DK
struct GDTopDK
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopDK
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopDK
{
PSWMSG_HEAD h;
CharTopDK tp[MAXTOP];
};

struct DGCharTop2DK
{
PWMSG_HEAD h;
CharTopDK tp[MAXTOP];
};

//EF
struct GDTopEF
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopEF
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopEF
{
PSWMSG_HEAD h;
CharTopEF tp[MAXTOP];
};

struct DGCharTop2EF
{
PWMSG_HEAD h;
CharTopEF tp[MAXTOP];
};

//MG
struct GDTopMG
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopMG
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopMG
{
PSWMSG_HEAD h;
CharTopMG tp[MAXTOP];
};

struct DGCharTop2MG
{
PWMSG_HEAD h;
CharTopMG tp[MAXTOP];
};

//DL
struct GDTopDL
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopDL
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopDL
{
PSWMSG_HEAD h;
CharTopDL tp[MAXTOP];
};

struct DGCharTop2DL
{
PWMSG_HEAD h;
CharTopDL tp[MAXTOP];
};

//SU
struct GDTopSU
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopSU
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopSU
{
PSWMSG_HEAD h;
CharTopSU tp[MAXTOP];
};

struct DGCharTop2SU
{
PWMSG_HEAD h;
CharTopSU tp[MAXTOP];
};

//RF
struct GDTopRF
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopRF
{
char Name[11];
BYTE Class;
int level;
int Reset;
int HoiSinh;
int Time;
char Guild[11];
};

struct DGCharTopRF
{
PSWMSG_HEAD h;
CharTopRF tp[MAXTOP];
};

struct DGCharTop2RF
{
PWMSG_HEAD h;
CharTopRF tp[MAXTOP];
};

struct GDTopDVT
{
PSWMSG_HEAD h;
BYTE Result;
};

struct CharTopDVT
{
char Name[11];
int Devote;
};

struct DGCharTopDVT
{
PSWMSG_HEAD h;
CharTopDVT tp[MAXTOP];
};

struct DGCharTop2DVT
{
PWMSG_HEAD h;
CharTopDVT tp[MAXTOP];
};

class cRanking
{
public:
void SendDS();
void RecvDS(DGCharTop* Recv);
void SendUser(LPOBJ lpObj);
CharTop RankingChar[MAXTOP];

void SendDSPoint();
void RecvDSPoint(DGCharTopPoint* Recv);
void SendUserPoint(LPOBJ lpObj);
CharTopPoint RankingCharPoint[MAXTOP];

void SendDSWC();
void RecvDSWC(DGCharTopWC* Recv);
void SendUserWC(LPOBJ lpObj);
CharTopWC RankingCharWC[MAXTOP];

void SendDSBC();
void RecvDSBC(DGCharTopBC* Recv);
void SendUserBC(LPOBJ lpObj);
CharTopBC RankingCharBC[MAXTOP];

void SendDSDC();
void RecvDSDC(DGCharTopDC* Recv);
void SendUserDC(LPOBJ lpObj);
CharTopDC RankingCharDC[MAXTOP];

void SendDSCC();
void RecvDSCC(DGCharTopCC* Recv);
void SendUserCC(LPOBJ lpObj);
CharTopCC RankingCharCC[MAXTOP];

void SendDSPK();
void RecvDSPK(DGCharTopPK* Recv);
void SendUserPK(LPOBJ lpObj);
CharTopPK RankingCharPK[MAXTOP];

void SendDSMT();
void RecvDSMT(DGCharTopMT* Recv);
void SendUserMT(LPOBJ lpObj);
CharTopMT RankingCharMT[MAXTOP];

void SendDSGD();
void RecvDSGD(DGCharTopGD* Recv);
void SendUserGD(LPOBJ lpObj);
CharTopGD RankingCharGD[MAXTOP];

//DW
void SendDSDW();
void RecvDSDW(DGCharTopDW* Recv);
void SendUserDW(LPOBJ lpObj);
CharTopDW RankingCharDW[MAXTOP];
//DK
void SendDSDK();
void RecvDSDK(DGCharTopDK* Recv);
void SendUserDK(LPOBJ lpObj);
CharTopDK RankingCharDK[MAXTOP];
//EF
void SendDSEF();
void RecvDSEF(DGCharTopEF* Recv);
void SendUserEF(LPOBJ lpObj);
CharTopEF RankingCharEF[MAXTOP];
//MG
void SendDSMG();
void RecvDSMG(DGCharTopMG* Recv);
void SendUserMG(LPOBJ lpObj);
CharTopMG RankingCharMG[MAXTOP];
//DL
void SendDSDL();
void RecvDSDL(DGCharTopDL* Recv);
void SendUserDL(LPOBJ lpObj);
CharTopDL RankingCharDL[MAXTOP];
//SU
void SendDSSU();
void RecvDSSU(DGCharTopSU* Recv);
void SendUserSU(LPOBJ lpObj);
CharTopSU RankingCharSU[MAXTOP];
//RF
void SendDSRF();
void RecvDSRF(DGCharTopRF* Recv);
void SendUserRF(LPOBJ lpObj);
CharTopRF RankingCharRF[MAXTOP];

//DVT
void SendDSDVT();
void RecvDSDVT(DGCharTopDVT* Recv);
void SendUserDVT(LPOBJ lpObj);
CharTopDVT RankingCharDVT[MAXTOP];

int FirstTime;
};
extern cRanking gRanking;
#endif

Buscar en DSProtocol.cp case 0x07:

Agregar

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
case 0xD9:
switch (((lpMsg[0] == 0xC1) ? lpMsg[3] : lpMsg[4]))
{
case 0x02: gRanking.RecvDS((DGCharTop*)lpMsg); break;
case 0x03: gRanking.RecvDSWC((DGCharTopWC*)lpMsg); break;

case 0x11: gRanking.RecvDSBC((DGCharTopBC*)lpMsg); break;
case 0x12: gRanking.RecvDSDC((DGCharTopDC*)lpMsg); break;
case 0x13: gRanking.RecvDSCC((DGCharTopCC*)lpMsg); break;
case 0x14: gRanking.RecvDSPoint((DGCharTopPoint*)lpMsg); break;
case 0x15: gRanking.RecvDSPK((DGCharTopPK*)lpMsg); break;
case 0x16: gRanking.RecvDSMT((DGCharTopMT*)lpMsg); break;
case 0x17: gRanking.RecvDSGD((DGCharTopGD*)lpMsg); break;

case 0x18: gRanking.RecvDSDW((DGCharTopDW*)lpMsg); break;
case 0x19: gRanking.RecvDSDK((DGCharTopDK*)lpMsg); break;
case 0x1A: gRanking.RecvDSEF((DGCharTopEF*)lpMsg); break;
case 0x1B: gRanking.RecvDSMG((DGCharTopMG*)lpMsg); break;
case 0x1C: gRanking.RecvDSDL((DGCharTopDL*)lpMsg); break;
case 0x1D: gRanking.RecvDSSU((DGCharTopSU*)lpMsg); break;
case 0x1E: gRanking.RecvDSRF((DGCharTopRF*)lpMsg); break;
case 0x1F: gRanking.RecvDSDVT((DGCharTopDVT*)lpMsg); break;
#if(HeThongFlag)
case 0x05:
ThueFlag.RecvGDGetListBuy((DATAFLAG_LOAD_COUNT*)lpMsg);
break;
#endif
}
break;
#endif

GameMain.cpp

Buscar case QUEUE_TIMER_PICK_COMMAND:

Agregar

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
case QUEUE_TIMER_RANKING:
gRanking.SendDS();
gRanking.SendDSPoint();
gRanking.SendDSWC();
gRanking.SendDSBC();
gRanking.SendDSDC();
gRanking.SendDSCC();
gRanking.SendDSPK();
gRanking.SendDSMT();
gRanking.SendDSGD();

gRanking.SendDSDW();
gRanking.SendDSDK();
gRanking.SendDSEF();
gRanking.SendDSMG();
gRanking.SendDSDL();
gRanking.SendDSSU();
gRanking.SendDSRF();
gRanking.SendDSDVT();
break;
#endif

GameServer.cpp

Código [Seleccionar] Expandir

gQueueTimer.CreateTimer(QUEUE_TIMER_PICK_COMMAND,6000,&QueueTimerCallback);

Agregar

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
gQueueTimer.CreateTimer(QUEUE_TIMER_RANKING, 15000, &QueueTimerCallback);
#endif

Queue.cpp

Buscar QUEUE_TIMER_PICK_COMMAND = 10

Agregar

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
QUEUE_TIMER_RANKING = 11,
#endif

Protocol.cpp

Buscar case 0xBF:

Código [Seleccionar] Expandir

#if(RANKING_NEW)
case 0xFD:
switch (((lpMsg[0] == 0xC1) ? lpMsg[3] : lpMsg[4]))
{
case 0x21: gRanking.SendUser(lpObj); break;
case 0x22: gRanking.SendUserWC(lpObj); break;
case 0x30: gRanking.SendUserBC(lpObj); break;
case 0x31: gRanking.SendUserDC(lpObj); break;
case 0x32: gRanking.SendUserCC(lpObj); break;
case 0x33: gRanking.SendUserPoint(lpObj); break;
case 0x34: gRanking.SendUserPK(lpObj); break;
case 0x35: gRanking.SendUserMT(lpObj); break;
case 0x36: gRanking.SendUserGD(lpObj); break;

case 0x37: gRanking.SendUserDW(lpObj); break;
case 0x38: gRanking.SendUserDK(lpObj); break;
case 0x39: gRanking.SendUserEF(lpObj); break;
case 0x3A: gRanking.SendUserMG(lpObj); break;
case 0x3B: gRanking.SendUserDL(lpObj); break;
case 0x3C: gRanking.SendUserSU(lpObj); break;
case 0x3D: gRanking.SendUserRF(lpObj); break;
case 0x3E: gRanking.SendUserDVT(lpObj); break;
}
break;
#endif

[Dakosmu]

LADO DATASERVER

stdafx.h

Código [Seleccionar] Expandir

#define RANKING_NEW 1

DataServerProtocol.cpp

DENTRO DE        case 0xD9:
            switch(((lpMsg

• ==0xC1)?lpMsg[3]:lpMsg[4]))

{

Código [Seleccionar] Expandir

                #if(RANKING_NEW == 1)
            case 0x17:    CharacterRanking((GDTop*)lpMsg, index);                break;
            case 0x18:    CharacterRankingWC((GDTopWC*)lpMsg, index);            break;
               
            case 0x26:    CharacterRankingBC((GDTopBC*)lpMsg, index);            break;
            case 0x27:    CharacterRankingDC((GDTopDC*)lpMsg, index);            break;
            case 0x28:    CharacterRankingCC((GDTopCC*)lpMsg, index);            break;
            case 0x29:    CharacterRankingPoint((GDTopPoint*)lpMsg, index);    break;
            case 0x2A:    CharacterRankingPK((GDTopPK*)lpMsg, index);            break;
            case 0x2B:    CharacterRankingMT((GDTopMT*)lpMsg, index);            break;
            case 0x2C:    CharacterRankingGD((GDTopGD*)lpMsg, index);            break;
            case 0x2D:    CharacterRankingDW((GDTopDW*)lpMsg, index);            break;
            case 0x2E:    CharacterRankingDK((GDTopDK*)lpMsg, index);            break;
            case 0x2F:    CharacterRankingEF((GDTopEF*)lpMsg, index);            break;
            case 0x30:    CharacterRankingMG((GDTopMG*)lpMsg, index);            break;
            case 0x31:    CharacterRankingDL((GDTopDL*)lpMsg, index);            break;
            case 0x32:    CharacterRankingSU((GDTopSU*)lpMsg, index);            break;
            case 0x33:    CharacterRankingRF((GDTopRF*)lpMsg, index);            break;
            case 0x34:    CharacterRankingDVT((GDTopDVT*)lpMsg, index);        break;
            case 0x2D:    CharacterRankingDW((GDTopDW*)lpMsg, index);            break;
            case 0x2E:    CharacterRankingDK((GDTopDK*)lpMsg, index);            break;
            case 0x2F:    CharacterRankingEF((GDTopEF*)lpMsg, index);            break;
            case 0x30:    CharacterRankingMG((GDTopMG*)lpMsg, index);            break;
            case 0x31:    CharacterRankingDL((GDTopDL*)lpMsg, index);            break;
            case 0x32:    CharacterRankingSU((GDTopSU*)lpMsg, index);            break;
            case 0x33:    CharacterRankingRF((GDTopRF*)lpMsg, index);            break;
            case 0x34:    CharacterRankingDVT((GDTopDVT*)lpMsg, index);        break;
#endif

Código [Seleccionar] Expandir

#if (RANKING_NEW == 1)
void CharacterRanking(GDTop* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTop rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x02, sizeof(DGCharTop));

    if (gQueryManager.ExecQuery("EXEC EX_RANKING1") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTop));
}
void CharacterRankingWC(GDTopWC* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopWC rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x03, sizeof(DGCharTopWC));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPWC") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].gWCoinC = gQueryManager.GetAsInteger("WCoinC");
        rSend.tp[iCharCount].gWCoinP = gQueryManager.GetAsInteger("WCoinP");
        rSend.tp[iCharCount].gWCoinG = gQueryManager.GetAsInteger("GoblinPoint");
        rSend.tp[iCharCount].gWCoinR = gQueryManager.GetAsInteger("Ruud");
        iCharCount++;

        if (iCharCount >= MAXTOP)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopWC));
}
void CharacterRankingBC(GDTopBC* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopBC rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x11, sizeof(DGCharTopBC));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPBC") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].BloodCastle = gQueryManager.GetAsInteger("Score");
        iCharCount++;

        if (iCharCount >= 150)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopBC));
}
void CharacterRankingDC(GDTopDC* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopDC rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x12, sizeof(DGCharTopDC));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPDC") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].DevilSquare = gQueryManager.GetAsInteger("Score");
        iCharCount++;

        if (iCharCount >= 150)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopDC));
}
void CharacterRankingCC(GDTopCC* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopCC rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x13, sizeof(DGCharTopCC));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPCC") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].ChaosCastle = gQueryManager.GetAsInteger("Score");
        iCharCount++;

        if (iCharCount >= 150)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopCC));
}
void CharacterRankingPoint(GDTopPoint* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopPoint rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x14, sizeof(DGCharTopPoint));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPPC") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].IsPoint = gQueryManager.GetAsInteger("LevelUpPoint");
        rSend.tp[iCharCount].IsStr     = gQueryManager.GetAsInteger("Strength");
        rSend.tp[iCharCount].IsAgi     = gQueryManager.GetAsInteger("Dexterity");
        rSend.tp[iCharCount].IsVit     = gQueryManager.GetAsInteger("Vitality");
        rSend.tp[iCharCount].IsEne     = gQueryManager.GetAsInteger("Energy");
        rSend.tp[iCharCount].IsCmd     = gQueryManager.GetAsInteger("Leadership");
        iCharCount++;

        if (iCharCount >= MAXTOP)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopPoint));
}
void CharacterRankingPK(GDTopPK* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopPK rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x15, sizeof(DGCharTopPK));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPPK") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].WinScore    = gQueryManager.GetAsInteger("WinScore");
        rSend.tp[iCharCount].LoseScore     = gQueryManager.GetAsInteger("LoseScore");
        iCharCount++;

        if (iCharCount >= MAXTOP)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopPK));
}
void CharacterRankingMT(GDTopMT* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopMT rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x16, sizeof(DGCharTopMT));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPMT") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);
        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Master                = gQueryManager.GetAsInteger("MasterLevel");
        rSend.tp[iCharCount].PointMaster        = gQueryManager.GetAsInteger("MasterPoint");
        iCharCount++;

        if (iCharCount >= MAXTOP)
        {
            break;
        }

        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopMT));
}
void CharacterRankingGD(GDTopGD* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopGD rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x17, sizeof(DGCharTopGD));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPGD") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();
    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);
        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        char GuildName[11] = { 0 };
        gQueryManager.GetAsString("G_Master", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));       
        gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
        strncpy(rSend.tp[iCharCount].Guild, GuildName, sizeof(GuildName));
        rSend.tp[iCharCount].G_Score                = gQueryManager.GetAsInteger("G_Score");
        rSend.tp[iCharCount].G_Level                = gQueryManager.GetAsInteger("LevelDevote");
        iCharCount++;

        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopGD));
}
//DW
void CharacterRankingDW(GDTopDW* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopDW rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x18, sizeof(DGCharTopDW));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_DW") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopDW));
}
//DK
void CharacterRankingDK(GDTopDK* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopDK rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x19, sizeof(DGCharTopDK));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_DK") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopDK));
}
//EF
void CharacterRankingEF(GDTopEF* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopEF rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x1A, sizeof(DGCharTopEF));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_EF") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopEF));
}
//MG
void CharacterRankingMG(GDTopMG* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopMG rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x1B, sizeof(DGCharTopMG));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_MG") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopMG));
}
//DL
void CharacterRankingDL(GDTopDL* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopDL rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x1C, sizeof(DGCharTopDL));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_DL") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopDL));
}
//SU
void CharacterRankingSU(GDTopSU* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopSU rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x1D, sizeof(DGCharTopSU));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_SU") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopSU));
}
//RF
void CharacterRankingRF(GDTopRF* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopRF rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x1E, sizeof(DGCharTopRF));

    if (gQueryManager.ExecQuery("EXEC SPK_TOP_RF") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();

    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);

        if (iReturnCode < 0)
        {
            break;
        }

        char NickName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));
        rSend.tp[iCharCount].Class        = gQueryManager.GetAsInteger("Class");
        rSend.tp[iCharCount].level        = gQueryManager.GetAsInteger("cLevel");
        rSend.tp[iCharCount].Reset        = gQueryManager.GetAsInteger("ResetCount");
        rSend.tp[iCharCount].HoiSinh    = gQueryManager.GetAsInteger("MasterResetCount");
        rSend.tp[iCharCount].Time        = gQueryManager.GetAsInteger("Resets_Time");
        iCharCount++;
        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }

    gQueryManager.Close();

    for (int b = 0; b<iCharCount; b++)
    {
        char cName[11] = { 0 };
        strncpy(cName, rSend.tp[b].Name, sizeof(cName));

        if (gQueryManager.ExecQuery("EXEC EX_RANKING2 '%s'", cName) == 0 || gQueryManager.Fetch() == SQL_NO_DATA)
        {
            gQueryManager.Close();
        }
        else
        {
            char GuildName[9] = { 0 };
            gQueryManager.GetAsString("G_Name", GuildName, sizeof(GuildName));
            strncpy(rSend.tp[b].Guild, GuildName, sizeof(GuildName));
            gQueryManager.Close();
        }
    }
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopRF));
}

void CharacterRankingDVT(GDTopDVT* lpMsg, int pIndex)
{
    int iCharCount = 0;
    DGCharTopDVT rSend;
    ZeroMemory(&rSend, sizeof(rSend));
    rSend.h.set(0xD9, 0x1F, sizeof(DGCharTopDVT));

    if (gQueryManager.ExecQuery("EXEC SPK_TOPDVT") == FALSE)
    {
        gQueryManager.Close();
    }

    short i = gQueryManager.Fetch();
    while (i != SQL_NO_DATA && i != SQL_NULL_DATA)
    {
        int iReturnCode = gQueryManager.GetResult(1);
        if (iReturnCode < 0)
        {
            break;
        }
        char NickName[11] = { 0 };
        char GuildName[11] = { 0 };
        gQueryManager.GetAsString("Name", NickName, sizeof(NickName));
        strncpy(rSend.tp[iCharCount].Name, NickName, sizeof(NickName));       
        rSend.tp[iCharCount].Devote                = gQueryManager.GetAsInteger("Devote");
        iCharCount++;

        if (iCharCount >= MAXTOP)
        {
            break;
        }
        i = gQueryManager.Fetch();
    }
    gQueryManager.Close();
    gSocketManager.DataSend(pIndex, (BYTE*)&rSend, sizeof(DGCharTopDVT));
}
#endif

DataServerProtocol.h

Código [Seleccionar] Expandir

#if(RANKING_NEW == 1)
#define MAXTOP 100

struct GDTop
{
    PSWMSG_HEAD h;
    BYTE Result;
};

struct CharTop
{
    char Name[11];
    BYTE Class;
    int level;
    int Reset;
    int HoiSinh;
    int Time;
    char Guild[11];
};

struct DGCharTop
{
    PSWMSG_HEAD h;
    CharTop    tp[MAXTOP];
};
//----------------------------------------------------
struct GDTopPoint
{
    PSWMSG_HEAD h;
    BYTE Result;
};
struct CharTopPoint
{
    char Name[11];
    int IsPoint;
    int IsStr;
    int IsAgi;
    int IsVit;
    int IsEne;
    int IsCmd;
};
struct DGCharTopPoint
{
    PSWMSG_HEAD h;
    CharTopPoint    tp[MAXTOP];
};
#endif

Código [Seleccionar] Expandir

#if (RANKING_NEW == 1)
void CharacterRanking(GDTop* lpMsg, int pIndex);
void CharacterRankingPoint(GDTopPoint* lpMsg, int pIndex);
void CharacterRankingWC(GDTopWC* lpMsg, int pIndex);
void CharacterRankingBC(GDTopBC* lpMsg, int pIndex);
void CharacterRankingCC(GDTopCC* lpMsg, int pIndex);
void CharacterRankingDC(GDTopDC* lpMsg, int pIndex);
void CharacterRankingPK(GDTopPK* lpMsg, int pIndex);
void CharacterRankingMT(GDTopMT* lpMsg, int pIndex);
void CharacterRankingGD(GDTopGD* lpMsg, int pIndex);
void CharacterRankingDW(GDTopDW* lpMsg, int pIndex);
void CharacterRankingDK(GDTopDK* lpMsg, int pIndex);
void CharacterRankingEF(GDTopEF* lpMsg, int pIndex);
void CharacterRankingMG(GDTopMG* lpMsg, int pIndex);
void CharacterRankingDL(GDTopDL* lpMsg, int pIndex);
void CharacterRankingSU(GDTopSU* lpMsg, int pIndex);
void CharacterRankingRF(GDTopRF* lpMsg, int pIndex);
void CharacterRankingDVT(GDTopDVT* lpMsg, int pIndex);
#endif