cube

[Jorila 3]

 

when i open the cube window, client syserr says:

 

0910 01:02:36376 :: CPythonNetworkStream::ServerCommand(c_szCommand=cube r_list 20381 28630,1/28631,1/28632,1/28633,1/28634,1/28635,1/28636,1/28637,1/28638,1/28639,1/28640,1/28641,1/28642,1/28643,1) - Strange Parameter Count : 5

 

is that a binary bug? how can i fix this?

Edited August 20, 2022 by Metin2 Dev
Core X - External 2 Internal

[Jorila 3]

hello? /:

[iRazer 9]

Can you post your cube.cpp?

[Jorila 3]

Spoiler

/*********************************************************************
 * date        : 2006.11.20
 * file        : cube.cpp
 * author      : mhh
 * description : 
 */

#define _cube_cpp_

#include "stdafx.h"
#include "constants.h"
#include "utils.h"
#include "log.h"
#include "char.h"
#include "dev_log.h"
#include "locale_service.h"
#include "item.h"
#include "item_manager.h"

#include <sstream>

extern int test_server;

#define RETURN_IF_CUBE_IS_NOT_OPENED(ch) if (!(ch)->IsCubeOpen()) return

/*--------------------------------------------------------*/
/*                   GLOBAL VARIABLES                     */
/*--------------------------------------------------------*/
static std::vector<CUBE_DATA*>    s_cube_proto;
static bool s_isInitializedCubeMaterialInformation = false;

/*--------------------------------------------------------*/
/*               Cube Material Information                */ 
/*--------------------------------------------------------*/
enum ECubeResultCategory
{
    CUBE_CATEGORY_POTION,                // ¾àÃÊ, Áø¾× µîµî..  (Æ÷¼ÇÀ¸·Î ƯÁ¤ÇÒ ¼ö ¾øÀ¸´Ï »ç¿ë ¾È ÇÔ. ¾àÃÊ°°Àº°Ç ´Ù °Á ±âŸ)
    CUBE_CATEGORY_WEAPON,                // ¹«±â
    CUBE_CATEGORY_ARMOR,                // ¹æ¾î±¸
    CUBE_CATEGORY_ACCESSORY,            // Àå½Å±¸
    CUBE_CATEGORY_ETC,                // ±âŸ µîµî...
};

typedef std::vector<CUBE_VALUE>    TCubeValueVector;

struct SCubeMaterialInfo
{
    SCubeMaterialInfo()
    {
        bHaveComplicateMaterial = false;
    };

    CUBE_VALUE            reward;                            // º¸»óÀÌ ¹¹³Ä
    TCubeValueVector    material;                        // Àç·áµéÀº ¹¹³Ä
    DWORD                gold;                            // µ·Àº ¾ó¸¶µå³Ä
    TCubeValueVector    complicateMaterial;                // º¹ÀâÇÑ-_- Àç·áµé

    // .. Ŭ¶óÀ̾ðÆ®¿¡¼­ Àç·á¸¦ º¸¿©ÁÖ±â À§ÇÏ¿© ¾à¼ÓÇÑ Æ÷¸Ë
    // 72723,1&72724,2&72730,1
    // 52001,1|52002,1|52003,1&72723,1&72724,5
    //    => ( 52001,1 or 52002,1 or 52003,1 ) and 72723,1 and 72724,5
    std::string            infoText;        
    bool                bHaveComplicateMaterial;        //
};

struct SItemNameAndLevel
{
    SItemNameAndLevel() { level = 0; }

    std::string        name;
    int                level;
};

// ÀڷᱸÁ¶³ª ÀÌ·±°Å º´½ÅÀ롂 ÀÌÇØÁ»... ´©±¸¶«¿¡ ¿µÈ¥ÀÌ ¾ø´Â »óÅ¿¡¼­ ¸¸µé¾ú¾¸
typedef std::vector<SCubeMaterialInfo>                                TCubeResultList;
typedef boost::unordered_map<DWORD, TCubeResultList>                TCubeMapByNPC;                // °¢°¢ÀÇ NPCº°·Î ¾î¶² °É ¸¸µé ¼ö ÀÖ°í Àç·á°¡ ¹ºÁö...
typedef boost::unordered_map<DWORD, std::string>                    TCubeResultInfoTextByNPC;    // °¢°¢ÀÇ NPCº°·Î ¸¸µé ¼ö ÀÖ´Â ¸ñ·ÏÀ» Á¤ÇØÁø Æ÷¸ËÀ¸·Î Á¤¸®ÇÑ Á¤º¸

TCubeMapByNPC cube_info_map;
TCubeResultInfoTextByNPC cube_result_info_map_by_npc;                // ³×ÀÌ¹Ö Á¸³ª º´½Å°°´Ù ¤»¤»¤»

class CCubeMaterialInfoHelper
{
public:
public:
};

/*--------------------------------------------------------*/
/*                  STATIC FUNCTIONS                      */ 
/*--------------------------------------------------------*/
 // ÇÊ¿äÇÑ ¾ÆÀÌÅÛ °³¼ö¸¦ °¡Áö°íÀִ°¡?
static bool FN_check_item_count (LPITEM *items, DWORD item_vnum, int need_count)
{
    int    count = 0;

    // for all cube
    for (int i=0; i<CUBE_MAX_NUM; ++i)
    {
        if (NULL==items)    continue;

        if (item_vnum==items->GetVnum())
        {
            count += items->GetCount();
        }
    }

    return (count>=need_count);
}

// Å¥ºê³»ÀÇ Àç·á¸¦ Áö¿î´Ù.
static void FN_remove_material (LPITEM *items, DWORD item_vnum, int need_count)
{
    int        count    = 0;
    LPITEM    item    = NULL;

    // for all cube
    for (int i=0; i<CUBE_MAX_NUM; ++i)
    {
        if (NULL==items)    continue;

        item = items;
        if (item_vnum==item->GetVnum())
        {
            count += item->GetCount();

            if (count>need_count)
            {
                item->SetCount(count-need_count);
                return;
            }
            else
            {
                item->SetCount(0);
                items = NULL;
            }
        }
    }
}

static CUBE_DATA* FN_find_cube (LPITEM *items, WORD npc_vnum)
{
    DWORD    i, end_index;

    if (0==npc_vnum)    return NULL;

    // FOR ALL CUBE_PROTO
    end_index = s_cube_proto.size();
    for (i=0; i<end_index; ++i)
    {
        if ( s_cube_proto->can_make_item(items, npc_vnum) )
            return s_cube_proto;
    }

    return NULL;
}

static bool FN_check_valid_npc( WORD vnum )
{
    for ( std::vector<CUBE_DATA*>::iterator iter = s_cube_proto.begin(); iter != s_cube_proto.end(); iter++ )
    {
        if ( std::find((*iter)->npc_vnum.begin(), (*iter)->npc_vnum.end(), vnum) != (*iter)->npc_vnum.end() )
            return true;
    }

    return false;
}

// Å¥ºêµ¥ÀÌŸ°¡ ¿Ã¹Ù¸£°Ô ÃʱâÈ­ µÇ¾ú´ÂÁö üũÇÑ´Ù.
static bool FN_check_cube_data (CUBE_DATA *cube_data)
{
    DWORD    i = 0;
    DWORD    end_index = 0;

    end_index = cube_data->npc_vnum.size();
    for (i=0; i<end_index; ++i)
    {
        if ( cube_data->npc_vnum == 0 )    return false;
    }

    end_index = cube_data->item.size();
    for (i=0; i<end_index; ++i)
    {
        if ( cube_data->item.vnum == 0 )        return false;
        if ( cube_data->item.count == 0 )    return false;
    }

    end_index = cube_data->reward.size();
    for (i=0; i<end_index; ++i)
    {
        if ( cube_data->reward.vnum == 0 )    return false;
        if ( cube_data->reward.count == 0 )    return false;
    }
    return true;
}

CUBE_DATA::CUBE_DATA()
{
    this->percent = 0;
    this->gold = 0;
}

// ÇÊ¿äÇÑ Àç·áÀÇ ¼ö·®À» ¸¸Á·ÇÏ´ÂÁö üũÇÑ´Ù.
bool CUBE_DATA::can_make_item (LPITEM *items, WORD npc_vnum)
{
    // ÇÊ¿äÇÑ Àç·á, ¼ö·®À» ¸¸Á·ÇÏ´ÂÁö üũÇÑ´Ù.
    DWORD    i, end_index;
    DWORD    need_vnum;
    int        need_count;
    int        found_npc = false;

    // check npc_vnum
    end_index = this->npc_vnum.size();
    for (i=0; i<end_index; ++i)
    {
        if (npc_vnum == this->npc_vnum)
            found_npc = true;
    }
    if (false==found_npc)    return false;

    end_index = this->item.size();
    for (i=0; i<end_index; ++i)
    {
        need_vnum    = this->item.vnum;
        need_count    = this->item.count;

        if ( false==FN_check_item_count(items, need_vnum, need_count) )
            return false;
    }

    return true;
}

// Å¥ºê¸¦ µ¹·ÈÀ»¶§ ³ª¿À´Â ¾ÆÀÌÅÛÀÇ Á¾·ù¸¦ °áÁ¤ÇÔ
CUBE_VALUE* CUBE_DATA::reward_value ()
{
    int        end_index        = 0;
    DWORD    reward_index    = 0;

    end_index = this->reward.size();
    reward_index = number(0, end_index);
    reward_index = number(0, end_index-1);

    return &this->reward[reward_index];
}

// Å¥ºê¿¡ µé¾îÀÖ´Â Àç·á¸¦ Áö¿î´Ù
void CUBE_DATA::remove_material (LPCHARACTER ch)
{
    DWORD    i, end_index;
    DWORD    need_vnum;
    int        need_count;
    LPITEM    *items = ch->GetCubeItem();

    end_index = this->item.size();
    for (i=0; i<end_index; ++i)
    {
        need_vnum    = this->item.vnum;
        need_count    = this->item.count;

        FN_remove_material (items, need_vnum, need_count);
    }
}

void Cube_clean_item (LPCHARACTER ch)
{
    LPITEM    *cube_item;

    cube_item = ch->GetCubeItem();

    for (int i=0; i<CUBE_MAX_NUM; ++i)
    {
        if (NULL == cube_item)
            continue;

        cube_item = NULL;
    }
}

// Å¥ºêâ ¿­±â
void Cube_open (LPCHARACTER ch)
{
    if (false == s_isInitializedCubeMaterialInformation)
    {
        Cube_InformationInitialize();
    }

    if (NULL == ch)
        return;

    LPCHARACTER    npc;
    npc = ch->GetQuestNPC();
    if (NULL==npc)
    {
        if (test_server)
            dev_log(LOG_DEB0, "cube_npc is NULL");
        return;
    }

    if ( FN_check_valid_npc(npc->GetRaceNum()) == false )
    {
        if ( test_server == true )
        {
            dev_log(LOG_DEB0, "cube not valid NPC");
        }
        return;
    }

    if (ch->IsCubeOpen())
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì Á¦Á¶Ã¢ÀÌ ¿­·ÁÀÖ½À´Ï´Ù."));
        return;
    }
    if ( ch->GetExchange() || ch->GetMyShop() || ch->GetShopOwner() || ch->IsOpenSafebox() || ch->IsCubeOpen() )
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´Ù¸¥ °Å·¡Áß(â°í,±³È¯,»óÁ¡)¿¡´Â »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
        return;
    }

    long distance = DISTANCE_APPROX(ch->GetX() - npc->GetX(), ch->GetY() - npc->GetY());

    if (distance >= CUBE_MAX_DISTANCE)
    {
        sys_log(1, "CUBE: TOO_FAR: %s distance %d", ch->GetName(), distance);
        return;
    }

    Cube_clean_item(ch);
    ch->SetCubeNpc(npc);
    ch->ChatPacket(CHAT_TYPE_COMMAND, "cube open %d", npc->GetRaceNum());
}

// Å¥ºê ĵ½½
void Cube_close (LPCHARACTER ch)
{
    RETURN_IF_CUBE_IS_NOT_OPENED(ch);
    Cube_clean_item(ch);
    ch->SetCubeNpc(NULL);
    ch->ChatPacket(CHAT_TYPE_COMMAND, "cube close");
    dev_log(LOG_DEB0, "<CUBE> close (%s)", ch->GetName());
}

void Cube_init()
{
    CUBE_DATA * p_cube = NULL;
    std::vector<CUBE_DATA*>::iterator iter;

    char file_name[256+1];
    snprintf(file_name, sizeof(file_name), "%s/cube.txt", LocaleService_GetBasePath().c_str());

    sys_log(0, "Cube_Init %s", file_name);

    for (iter = s_cube_proto.begin(); iter!=s_cube_proto.end(); iter++)
    {
        p_cube = *iter;
        M2_DELETE(p_cube);
    }

    s_cube_proto.clear();

    if (false == Cube_load(file_name))
        sys_err("Cube_Init failed");
}

bool Cube_load (const char *file)
{
    FILE    *fp;
    char    one_line[256];
    int        value1, value2;
    const char    *delim = " \t\r\n";
    char    *v, *token_string;
    CUBE_DATA    *cube_data = NULL;
    CUBE_VALUE    cube_value = {0,0};

    if (0 == file || 0 == file[0])
        return false;

    if ((fp = fopen(file, "r")) == 0)
        return false;

    while (fgets(one_line, 256, fp))
    {
        value1 = value2 = 0;

        if (one_line[0] == '#')
            continue;

        token_string = strtok(one_line, delim);

        if (NULL == token_string)
            continue;

        // set value1, value2
        if ((v = strtok(NULL, delim)))
            str_to_number(value1, v);

        if ((v = strtok(NULL, delim)))
            str_to_number(value2, v);

        TOKEN("section")
        {
            cube_data = M2_NEW CUBE_DATA;
        }
        else TOKEN("npc")
        {
            cube_data->npc_vnum.push_back((WORD)value1);
        }
        else TOKEN("item")
        {
            cube_value.vnum        = value1;
            cube_value.count    = value2;

            cube_data->item.push_back(cube_value);
        }
        else TOKEN("reward")
        {
            cube_value.vnum        = value1;
            cube_value.count    = value2;

            cube_data->reward.push_back(cube_value);
        }
        else TOKEN("percent")
        {
            cube_data->percent = value1;
        }
        else TOKEN("gold")
        {
            // Á¦Á¶¿¡ ÇÊ¿äÇÑ ±Ý¾×
            cube_data->gold = value1;
        }
        else TOKEN("end")
        {
            // TODO : check cube data
            if (false == FN_check_cube_data(cube_data))
            {
                dev_log(LOG_DEB0, "something wrong");
                M2_DELETE(cube_data);
                continue;
            }
            s_cube_proto.push_back(cube_data);
        }
    }

    fclose(fp);
    return true;
}

static void FN_cube_print (CUBE_DATA *data, DWORD index)
{
    DWORD    i;
    dev_log(LOG_DEB0, "--------------------------------");
    dev_log(LOG_DEB0, "CUBE_DATA[%d]", index);

    for (i=0; i<data->npc_vnum.size(); ++i)
    {
        dev_log(LOG_DEB0, "\tNPC_VNUM[%d] = %d", i, data->npc_vnum);
    }
    for (i=0; i<data->item.size(); ++i)
    {
        dev_log(LOG_DEB0, "\tITEM[%d]   = (%d, %d)", i, data->item.vnum, data->item.count);
    }
    for (i=0; i<data->reward.size(); ++i)
    {
        dev_log(LOG_DEB0, "\tREWARD[%d] = (%d, %d)", i, data->reward.vnum, data->reward.count);
    }
    dev_log(LOG_DEB0, "\tPERCENT = %d", data->percent);
    dev_log(LOG_DEB0, "--------------------------------");
}

void Cube_print ()
{
    for (DWORD i=0; i<s_cube_proto.size(); ++i)
    {
        FN_cube_print(s_cube_proto, i);
    }
}

static bool FN_update_cube_status(LPCHARACTER ch)
{
    if (NULL == ch)
        return false;

    if (!ch->IsCubeOpen())
        return false;

    LPCHARACTER    npc = ch->GetQuestNPC();
    if (NULL == npc)
        return false;

    CUBE_DATA* cube = FN_find_cube(ch->GetCubeItem(), npc->GetRaceNum());

    if (NULL == cube)
    {
        ch->ChatPacket(CHAT_TYPE_COMMAND, "cube info 0 0 0");
        return false;
    }

    ch->ChatPacket(CHAT_TYPE_COMMAND, "cube info %d %d %d", cube->gold, 0, 0);
    return true;
}

// return new item
bool Cube_make (LPCHARACTER ch)
{
    // ÁÖ¾îÁø ¾ÆÀÌÅÛÀ» ÇÊ¿ä·ÎÇÏ´Â Á¶ÇÕÀ» ã´Â´Ù. (Å¥ºêµ¥ÀÌŸ·Î ĪÇÔ)
    // Å¥ºê µ¥ÀÌŸ°¡ ÀÖ´Ù¸é ¾ÆÀÌÅÛÀÇ Àç·á¸¦ üũÇÑ´Ù.
    // »õ·Î¿î ¾ÆÀÌÅÛÀ» ¸¸µç´Ù.
    // »õ·Î¿î ¾ÆÀÌÅÛ Áö±Þ

    LPCHARACTER    npc;
    int            percent_number = 0;
    CUBE_DATA    *cube_proto;
    LPITEM    *items;
    LPITEM    new_item;

    if (!(ch)->IsCubeOpen())
    {
        (ch)->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¦Á¶Ã¢ÀÌ ¿­·ÁÀÖÁö ¾Ê½À´Ï´Ù"));
        return false;
    }

    npc = ch->GetQuestNPC();
    if (NULL == npc)
    {
        return false;
    }

    items = ch->GetCubeItem();
    cube_proto = FN_find_cube(items, npc->GetRaceNum());

    if (NULL == cube_proto)
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¦Á¶ Àç·á°¡ ºÎÁ·ÇÕ´Ï´Ù"));
        return false;
    }

    if (ch->GetGold() < cube_proto->gold)
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ·ÀÌ ºÎÁ·Çϰųª ¾ÆÀÌÅÛÀÌ Á¦ÀÚ¸®¿¡ ¾ø½À´Ï´Ù."));    // ÀÌ ÅؽºÆ®´Â ÀÌ¹Ì ³Î¸® ¾²À̴°Ŷó Ãß°¡¹ø¿ª ÇÊ¿ä ¾øÀ½
        return false;
    }

    CUBE_VALUE    *reward_value = cube_proto->reward_value();

    // »ç¿ëµÇ¾ú´ø Àç·á¾ÆÀÌÅÛ »èÁ¦
    cube_proto->remove_material (ch);
    
    // Á¦Á¶½Ã ÇÊ¿äÇÑ °ñµå Â÷°¨
    if (0 < cube_proto->gold)
        ch->PointChange(POINT_GOLD, -(cube_proto->gold), false);

    percent_number = number(1,100);
    if ( percent_number<=cube_proto->percent)
    {
        // ¼º°ø
        ch->ChatPacket(CHAT_TYPE_COMMAND, "cube success %d %d", reward_value->vnum, reward_value->count);
        new_item = ch->AutoGiveItem(reward_value->vnum, reward_value->count);

        LogManager::instance().CubeLog(ch->GetPlayerID(), ch->GetX(), ch->GetY(),
                reward_value->vnum, new_item->GetID(), reward_value->count, 1);
        return true;
    }
    else
    {
        // ½ÇÆÐ
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¦Á¶¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));    // 2012.11.12 »õ·Î Ãß°¡µÈ ¸Þ¼¼Áö (locale_string.txt ¿¡ Ãß°¡ÇØ¾ß ÇÔ)
        ch->ChatPacket(CHAT_TYPE_COMMAND, "cube fail");
        LogManager::instance().CubeLog(ch->GetPlayerID(), ch->GetX(), ch->GetY(),
                reward_value->vnum, 0, 0, 0);
        return false;
    }

    return false;
}

// Å¥ºê¿¡ ÀÖ´Â ¾ÆÀÌÅÛµéÀ» Ç¥½Ã
void Cube_show_list (LPCHARACTER ch)
{
    LPITEM    *cube_item;
    LPITEM    item;

    RETURN_IF_CUBE_IS_NOT_OPENED(ch);

    cube_item = ch->GetCubeItem();

    for (int i=0; i<CUBE_MAX_NUM; ++i)
    {
        item = cube_item;
        if (NULL==item)    continue;

        ch->ChatPacket(CHAT_TYPE_INFO, "cube[%d]: inventory[%d]: %s",
                i, item->GetCell(), item->GetName());
    }
}

// Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛÀ» Å¥ºê¿¡ µî·Ï
void Cube_add_item (LPCHARACTER ch, int cube_index, int inven_index)
{
    // ¾ÆÀÌÅÛÀÌ Àִ°¡?
    // Å¥ºê³»ÀÇ ºóÀÚ¸® ã±â
    // Å¥ºê¼¼ÆÃ
    // ¸Þ½ÃÁö Àü¼Û
    LPITEM    item;
    LPITEM    *cube_item;

    RETURN_IF_CUBE_IS_NOT_OPENED(ch);

    if (inven_index<0 || INVENTORY_MAX_NUM<=inven_index)
        return;
    if (cube_index<0 || CUBE_MAX_NUM<=cube_index)
        return;

    item = ch->GetInventoryItem(inven_index);

    if (NULL==item)    return;

    cube_item = ch->GetCubeItem();

    // ÀÌ¹Ì ´Ù¸¥À§Ä¡¿¡ µî·ÏµÇ¾ú´ø ¾ÆÀÌÅÛÀÌ¸é ±âÁ¸ indext»èÁ¦
    for (int i=0; i<CUBE_MAX_NUM; ++i)
    {
        if (item==cube_item)
        {
            cube_item = NULL;
            break;
        }
    }

    cube_item[cube_index] = item;

    if (test_server)
        ch->ChatPacket(CHAT_TYPE_INFO, "cube[%d]: inventory[%d]: %s added",
                                    cube_index, inven_index, item->GetName());

    // ÇöÀç »óÀÚ¿¡ ¿Ã¶ó¿Â ¾ÆÀÌÅÛµé·Î ¹«¾ùÀ» ¸¸µé ¼ö ÀÖ´ÂÁö Ŭ¶óÀ̾ðÆ®¿¡ Á¤º¸ Àü´Þ
    // À» ÇÏ°í½Í¾úÀ¸³ª ±×³É ÇÊ¿äÇÑ °ñµå°¡ ¾ó¸¶ÀÎÁö Àü´Þ
    FN_update_cube_status(ch);

    return;
}

// Å¥ºê¿¡ÀÖ´Â ¾ÆÀÌÅÛÀ» Á¦°Å
void Cube_delete_item (LPCHARACTER ch, int cube_index)
{
    LPITEM    item;
    LPITEM    *cube_item;

    RETURN_IF_CUBE_IS_NOT_OPENED(ch);

    if (cube_index<0 || CUBE_MAX_NUM<=cube_index)    return;

    cube_item = ch->GetCubeItem();

    if ( NULL== cube_item[cube_index] )    return;

    item = cube_item[cube_index];
    cube_item[cube_index] = NULL;

    if (test_server)
        ch->ChatPacket(CHAT_TYPE_INFO, "cube[%d]: cube[%d]: %s deleted",
                cube_index, item->GetCell(), item->GetName());

    // ÇöÀç »óÀÚ¿¡ ¿Ã¶ó¿Â ¾ÆÀÌÅÛµé·Î ¹«¾ùÀ» ¸¸µé ¼ö ÀÖ´ÂÁö Ŭ¶óÀ̾ðÆ®¿¡ Á¤º¸ Àü´Þ
    // À» ÇÏ°í½Í¾úÀ¸³ª ±×³É ÇÊ¿äÇÑ °ñµå°¡ ¾ó¸¶ÀÎÁö Àü´Þ
    FN_update_cube_status(ch);

    return;
}

// ¾ÆÀÌÅÛ À̸§À» ÅëÇؼ­ ¼ø¼ö À̸§°ú °­È­·¹º§À» ºÐ¸®ÇÏ´Â ÇÔ¼ö (¹«½Ö°Ë+5 -> ¹«½Ö°Ë, 5)
SItemNameAndLevel SplitItemNameAndLevelFromName(const std::string& name)
{
    int level = 0;
    SItemNameAndLevel info;
    info.name = name;

    size_t pos = name.find("+");
    
    if (std::string::npos != pos)
    {
        const std::string levelStr = name.substr(pos + 1, name.size() - pos - 1);
        str_to_number(level, levelStr.c_str());

        info.name = name.substr(0, pos);
    }

    info.level = level;

    return info;
};

bool FIsEqualCubeValue(const CUBE_VALUE& a, const CUBE_VALUE&
{
    return (a.vnum == b.vnum) && (a.count == b.count);
}

bool FIsLessCubeValue(const CUBE_VALUE& a, const CUBE_VALUE&
{
    return a.vnum < b.vnum;
}

void Cube_MakeCubeInformationText()
{
    // ÀÌÁ¦ Á¤¸®µÈ Å¥ºê °á°ú ¹× Àç·áµéÀÇ Á¤º¸·Î Ŭ¶óÀ̾ðÆ®¿¡ º¸³» ÁÙ Á¤º¸·Î º¯È¯ÇÔ.
    for (TCubeMapByNPC::iterator iter = cube_info_map.begin(); cube_info_map.end() != iter; ++iter)
    {
        const DWORD& npcVNUM = iter->first;
        TCubeResultList& resultList = iter->second;

        for (TCubeResultList::iterator resultIter = resultList.begin(); resultList.end() != resultIter; ++resultIter)
        {
            SCubeMaterialInfo& materialInfo = *resultIter;
            std::string& infoText = materialInfo.infoText;

            
            // À̳ðÀÌ ³ª»Û³ðÀ̾ß
            if (0 < materialInfo.complicateMaterial.size())
            {
                std::sort(materialInfo.complicateMaterial.begin(), materialInfo.complicateMaterial.end(), FIsLessCubeValue);
                std::sort(materialInfo.material.begin(), materialInfo.material.end(), FIsLessCubeValue);

                //// Áߺ¹µÇ´Â Àç·áµéÀ» Áö¿ò
                for (TCubeValueVector::iterator iter = materialInfo.complicateMaterial.begin(); materialInfo.complicateMaterial.end() != iter; ++iter)
                {
                    for (TCubeValueVector::iterator targetIter = materialInfo.material.begin(); materialInfo.material.end() != targetIter; ++targetIter)
                    {
                        if (*targetIter == *iter)
                        {
                            targetIter = materialInfo.material.erase(targetIter);
                        }
                    }
                }

                // 72723,1 or 72725,1 or ... ÀÌ·± ½ÄÀÇ ¾à¼ÓµÈ Æ÷¸ËÀ» ÁöÅ°´Â ÅؽºÆ®¸¦ »ý¼º
                for (TCubeValueVector::iterator iter = materialInfo.complicateMaterial.begin(); materialInfo.complicateMaterial.end() != iter; ++iter)
                {
                    char tempBuffer[128];
                    sprintf(tempBuffer, "%d,%d|", iter->vnum, iter->count);
                    
                    infoText += std::string(tempBuffer);
                }

                infoText.erase(infoText.size() - 1);

                if (0 < materialInfo.material.size())
                    infoText.push_back('&');
            }

            // Áߺ¹µÇÁö ¾Ê´Â ÀÏ¹Ý Àç·áµéµµ Æ÷¸Ë »ý¼º
            for (TCubeValueVector::iterator iter = materialInfo.material.begin(); materialInfo.material.end() != iter; ++iter)
            {
                char tempBuffer[128];
                sprintf(tempBuffer, "%d,%d&", iter->vnum, iter->count);
                infoText += std::string(tempBuffer);
            }

            infoText.erase(infoText.size() - 1);

            // ¸¸µé ¶§ °ñµå°¡ ÇÊ¿äÇÏ´Ù¸é °ñµåÁ¤º¸ Ãß°¡
            if (0 < materialInfo.gold)
            {
                char temp[128];
                sprintf(temp, "%d", materialInfo.gold);
                infoText += std::string("/") + temp;
            }

            //sys_err("\t\tNPC: %d, Reward: %d(%s)\n\t\t\tInfo: %s", npcVNUM, materialInfo.reward.vnum, ITEM_MANAGER::Instance().GetTable(materialInfo.reward.vnum)->szName, materialInfo.infoText.c_str());
        } // for resultList
    } // for npc
}

bool Cube_InformationInitialize()
{
    for (int i = 0; i < s_cube_proto.size(); ++i)
    {
        CUBE_DATA* cubeData = s_cube_proto;

        const std::vector<CUBE_VALUE>& rewards = cubeData->reward;

        // ÇϵåÄÚµù ¤¸¤µ
        if (1 != rewards.size())
        {
            sys_err("[CubeInfo] WARNING! Does not support multiple rewards (count: %d)", rewards.size());            
            continue;
        }
        //if (1 != cubeData->npc_vnum.size())
        //{
        //    sys_err("[CubeInfo] WARNING! Does not support multiple NPC (count: %d)", cubeData->npc_vnum.size());            
        //    continue;
        //}

        const CUBE_VALUE& reward = rewards.at(0);
        const WORD& npcVNUM = cubeData->npc_vnum.at(0);
        bool bComplicate = false;
        
        TCubeMapByNPC& cubeMap = cube_info_map;
        TCubeResultList& resultList = cubeMap[npcVNUM];
        SCubeMaterialInfo materialInfo;

        materialInfo.reward = reward;
        materialInfo.gold = cubeData->gold;
        materialInfo.material = cubeData->item;

        for (TCubeResultList::iterator iter = resultList.begin(); resultList.end() != iter; ++iter)
        {
            SCubeMaterialInfo& existInfo = *iter;

            // ÀÌ¹Ì Áߺ¹µÇ´Â º¸»óÀÌ µî·ÏµÇ¾î ÀÖ´Ù¸é ¾Æ¿¹ ´Ù¸¥ Á¶ÇÕÀ¸·Î ¸¸µå´Â °ÍÀÎÁö, 
            // °ÅÀÇ °°Àº Á¶ÇÕÀε¥ ƯÁ¤ ºÎºÐ¸¸ Ʋ¸° °ÍÀÎÁö ±¸ºÐÇÔ.
            // ¿¹¸¦µé¸é ƯÁ¤ ºÎºÐ¸¸ Ʋ¸° ¾ÆÀÌÅÛµéÀº ¾Æ·¡Ã³·³ Çϳª·Î ¹­¾î¼­ ÇϳªÀÇ °á°ú·Î º¸¿©ÁÖ±â À§ÇÔÀÓ:
            // ¿ë½ÅÁö°Ë:
            //        ¹«½Ö°Ë+5 ~ +9 x 1
            //        ºÓÀº Ä®ÀÚ·ç Á¶°¢ x1
            //        ³ì»ö °ËÀå½Ä Á¶°¢ x1
            if (reward.vnum == existInfo.reward.vnum)
            {
                for (TCubeValueVector::iterator existMaterialIter = existInfo.material.begin(); existInfo.material.end() != existMaterialIter; ++existMaterialIter)
                {
                    TItemTable* existMaterialProto = ITEM_MANAGER::Instance().GetTable(existMaterialIter->vnum);
                    if (NULL == existMaterialProto)
                    {
                        sys_err("There is no item(%u)", existMaterialIter->vnum);
                        return false;
                    }
                    SItemNameAndLevel existItemInfo = SplitItemNameAndLevelFromName(existMaterialProto->szName);

                    if (0 < existItemInfo.level)
                    {
                        // Áö±Ý Ãß°¡Çϴ ťºê °á°ú¹°ÀÇ Àç·á¿Í, ±âÁ¸¿¡ µî·ÏµÇ¾îÀÖ´ø Å¥ºê °á°ú¹°ÀÇ Àç·á Áß 
                        // Áߺ¹µÇ´Â ºÎºÐÀÌ ÀÖ´ÂÁö °Ë»öÇÑ´Ù
                        for (TCubeValueVector::iterator currentMaterialIter = materialInfo.material.begin(); materialInfo.material.end() != currentMaterialIter; ++currentMaterialIter)
                        {
                            TItemTable* currentMaterialProto = ITEM_MANAGER::Instance().GetTable(currentMaterialIter->vnum);
                            SItemNameAndLevel currentItemInfo = SplitItemNameAndLevelFromName(currentMaterialProto->szName);

                            if (currentItemInfo.name == existItemInfo.name)
                            {
                                bComplicate = true;
                                existInfo.complicateMaterial.push_back(*currentMaterialIter);

                                if (std::find(existInfo.complicateMaterial.begin(), existInfo.complicateMaterial.end(), *existMaterialIter) == existInfo.complicateMaterial.end())
                                    existInfo.complicateMaterial.push_back(*existMaterialIter);

                                //currentMaterialIter = materialInfo.material.erase(currentMaterialIter);

                                // TODO: Áߺ¹µÇ´Â ¾ÆÀÌÅÛ µÎ °³ ÀÌ»ó °ËÃâÇØ¾ß µÉ ¼öµµ ÀÖÀ½
                                break;
                            }
                        } // for currentMaterialIter
                    }    // if level
                }    // for existMaterialInfo
            }    // if (reward.vnum == existInfo.reward.vnum)

        }    // for resultList

        if (false == bComplicate)
            resultList.push_back(materialInfo);
    }

    Cube_MakeCubeInformationText();

    s_isInitializedCubeMaterialInformation = true;
    return true;
}

// Ŭ¶óÀ̾ðÆ®¿¡¼­ ¼­¹ö·Î : ÇöÀç NPC°¡ ¸¸µé ¼ö ÀÖ´Â ¾ÆÀÌÅÛµéÀÇ Á¤º¸(¸ñ·Ï)¸¦ ¿äû
void Cube_request_result_list(LPCHARACTER ch)
{
    RETURN_IF_CUBE_IS_NOT_OPENED(ch);

    LPCHARACTER    npc = ch->GetQuestNPC();
    if (NULL == npc)
        return;

    DWORD npcVNUM = npc->GetRaceNum();
    size_t resultCount = 0;

    std::string& resultText = cube_result_info_map_by_npc[npcVNUM];

    // ÇØ´ç NPC°¡ ¸¸µé ¼ö ÀÖ´Â ¸ñ·ÏÀÌ Á¤¸®µÈ °Ô ¾ø´Ù¸é ij½Ã¸¦ »ý¼º
    if (resultText.length() == 0)
    {
        resultText.clear();

        const TCubeResultList& resultList = cube_info_map[npcVNUM];
        for (TCubeResultList::const_iterator iter = resultList.begin(); resultList.end() != iter; ++iter)
        {
            const SCubeMaterialInfo& materialInfo = *iter;
            char temp[128];
            sprintf(temp, "%d,%d", materialInfo.reward.vnum, materialInfo.reward.count);

            resultText += std::string(temp) + "/";

            ++resultCount;
        }

        if (resultCount == 0) {
            return;
        }

        resultText.erase(resultText.size() - 1);

        // äÆà ÆÐŶÀÇ ÇѰ踦 ³Ñ¾î°¡¸é ¿¡·¯ ³²±è... ±âȹÀÚ ºÐµé ²² Á¶Á¤ÇØ´Þ¶ó°í ¿äûÇϰųª, ³ªÁß¿¡ ´Ù¸¥ ¹æ½ÄÀ¸·Î ¹Ù²Ù°Å³ª...
            int WildFantasytFIXED;
            if (resultText.size() < 20)
            {
                    WildFantasytFIXED = 20 - resultText.size();
            }
            else
            {
                    WildFantasytFIXED = resultText.size() - 20;
            }
            if (WildFantasytFIXED >= CHAT_MAX_LEN)
            {
                    sys_err("[CubeInfo] Too long cube result list text. (NPC: %d, FIXED_size_value_exygo: %d, length: %d)", npcVNUM, WildFantasytFIXED, resultText.size());
                    resultText.clear();
                    resultCount = 0;
            }

    }

    // ÇöÀç NPC°¡ ¸¸µé ¼ö ÀÖ´Â ¾ÆÀÌÅÛµéÀÇ ¸ñ·ÏÀ» ¾Æ·¡ Æ÷¸ËÀ¸·Î Àü¼ÛÇÑ´Ù.
    // (Server -> Client) /cube r_list npcVNUM resultCount vnum1,count1/vnum2,count2,/vnum3,count3/...
    // (Server -> Client) /cube r_list 20383 4 123,1/125,1/128,1/130,5
    
    ch->ChatPacket(CHAT_TYPE_COMMAND, "cube r_list %d %s", npcVNUM, resultText.c_str());
}

// 
void Cube_request_material_info(LPCHARACTER ch, int requestStartIndex, int requestCount)
{
    RETURN_IF_CUBE_IS_NOT_OPENED(ch);

    LPCHARACTER    npc = ch->GetQuestNPC();
    if (NULL == npc)
        return;

    DWORD npcVNUM = npc->GetRaceNum();
    std::string materialInfoText = "";

    int index = 0;
    bool bCatchInfo = false;

    const TCubeResultList& resultList = cube_info_map[npcVNUM];
    for (TCubeResultList::const_iterator iter = resultList.begin(); resultList.end() != iter; ++iter)
    {
        const SCubeMaterialInfo& materialInfo = *iter;

        if (index++ == requestStartIndex)
        {
            bCatchInfo = true;
        }
        
        if (bCatchInfo)
        {
            materialInfoText += materialInfo.infoText + "@";
        }

        if (index >= requestStartIndex + requestCount)
            break;
    }

    if (!bCatchInfo || materialInfoText.size() == 0)
    {
        sys_err("[CubeInfo] Can't find matched material info (NPC: %d, index: %d, request count: %d)", npcVNUM, requestStartIndex, requestCount);
        return;
    }

    materialInfoText.erase(materialInfoText.size() - 1);

    // 
    // (Server -> Client) /cube m_info start_index count 125,1|126,2|127,2|123,5&555,5&555,4/120000
    if (materialInfoText.size() - 20 >= CHAT_MAX_LEN)
    {
        sys_err("[CubeInfo] Too long material info. (NPC: %d, requestStart: %d, requestCount: %d, length: %d)", npcVNUM, requestStartIndex, requestCount, materialInfoText.size());
    }

    ch->ChatPacket(CHAT_TYPE_COMMAND, "cube m_info %d %d %s", requestStartIndex, requestCount, materialInfoText.c_str());

    
}

Here, please help s: and @iRazer

 

 

edit: this ist the binary part

Spoiler

 else if (!strcmpi(szCmd, "cube"))
 {
  if (TokenVector.size() < 2)
  {
   TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
   return;
  }

  if ("open" == TokenVector[1])
  {
   if (3 > TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
    return;
   }

   DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Open", Py_BuildValue("(i)", npcVNUM));
  }
  else if ("close" == TokenVector[1])
  {
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Close", Py_BuildValue("()"));
  }
  else if ("info" == TokenVector[1])
  {
   if (5 != TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
    return;
   }

   UINT gold = atoi(TokenVector[2].c_str());
   UINT itemVnum = atoi(TokenVector[3].c_str());
   UINT count = atoi(TokenVector[4].c_str());
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_UpdateInfo", Py_BuildValue("(iii)", gold, itemVnum, count));
  }
  else if ("success" == TokenVector[1])
  {
   if (4 != TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
    return;
   }

   UINT itemVnum = atoi(TokenVector[2].c_str());
   UINT count = atoi(TokenVector[3].c_str());
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Succeed", Py_BuildValue("(ii)", itemVnum, count));
  }
  else if ("fail" == TokenVector[1])
  {
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Failed", Py_BuildValue("()"));
  }
  else if ("r_list" == TokenVector[1])
  {
   //result list (/cube r_list npcVNUM resultCount resultText)
   //20383 4 72723,1/72725,1/72730.1/50001,5 <- ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºÐµÈ ¸®½ºÆ®¸¦ ÁÜ
   if (5 != TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, 5);
    return;
   }

   DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());

   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_ResultList", Py_BuildValue("(is)", npcVNUM, TokenVector[4].c_str()));
  } 

edit2: cube.txt:
 

 

Edited August 20, 2022 by Metin2 Dev
Core X - External 2 Internal

[Jorila 3]

help

[Cătălin 28]

Go in quest folder an search if u have cube.lua.

You must edit it too.

[Jorila 3]

i haven't a cube.lua

i have checked all files and i see its a binary mistake - look the binary-part. need help <.<

Spoiler

else if (!strcmpi(szCmd, "cube"))
 {
  if (TokenVector.size() < 2)
  {
   TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
   return;
  }

  if ("open" == TokenVector[1])
  {
   if (3 > TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
    return;
   }

   DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Open", Py_BuildValue("(i)", npcVNUM));
  }
  else if ("close" == TokenVector[1])
  {
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Close", Py_BuildValue("()"));
  }
  else if ("info" == TokenVector[1])
  {
   if (5 != TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
    return;
   }

   UINT gold = atoi(TokenVector[2].c_str());
   UINT itemVnum = atoi(TokenVector[3].c_str());
   UINT count = atoi(TokenVector[4].c_str());
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_UpdateInfo", Py_BuildValue("(iii)", gold, itemVnum, count));
  }
  else if ("success" == TokenVector[1])
  {
   if (4 != TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
    return;
   }

   UINT itemVnum = atoi(TokenVector[2].c_str());
   UINT count = atoi(TokenVector[3].c_str());
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Succeed", Py_BuildValue("(ii)", itemVnum, count));
  }
  else if ("fail" == TokenVector[1])
  {
   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Failed", Py_BuildValue("()"));
  }
  else if ("r_list" == TokenVector[1])
  {
   //result list (/cube r_list npcVNUM resultCount resultText)
   //20383 4 72723,1/72725,1/72730.1/50001,5 <- ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºÐµÈ ¸®½ºÆ®¸¦ ÁÜ
   if (5 != TokenVector.size())
   {
    TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, 5);
    return;
   }

   DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());

   PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_ResultList", Py_BuildValue("(is)", npcVNUM, TokenVector[4].c_str()));
  }

 

[Grimmjow 57]

This bug come when you make 2 item, make only one item and tell me if you see icon

[Jorila 3]

@Grimmjow

 

with one item  not works<.<

[Grimmjow 57]

Send me your PythonNetworkStreamCommand.cpp in project Userinterface

[Jorila 3]

Spoiler

#include "StdAfx.h"
#include "PythonNetworkStream.h"
#include "PythonNonPlayer.h"
#include "AbstractApplication.h"
#include "AbstractPlayer.h"
#include "AbstractCharacterManager.h"
#include "AbstractChat.h"
#include "InstanceBase.h"

#define ishan(ch)        (((ch) & 0xE0) > 0x90)
#define ishanasc(ch)    (isascii(ch) || ishan(ch))
#define ishanalp(ch)    (isalpha(ch) || ishan(ch))
#define isnhdigit(ch)    (!ishan(ch) && isdigit(ch))
#define isnhspace(ch)    (!ishan(ch) && isspace(ch))

#define LOWER(c)        (((c) >= 'A' && (c) <= 'Z') ? ((c) + ('a' - 'A')) : (c))
#define UPPER(c)        (((c) >= 'a' && (c) <= 'z') ? ((c) + ('A' - 'a')) : (c))

void SkipSpaces(char **string)
{
    for (; **string != '\0' && isnhspace((unsigned char) **string); ++(*string));
}

char *OneArgument(char *argument, char *first_arg)
{
    char mark = FALSE;

    if (!argument)
    {
        *first_arg = '\0';
        return NULL;
    }

    SkipSpaces(&argument);

    while (*argument)
    {
        if (*argument == '\"')
        {
            mark = !mark;
            ++argument;
            continue;
        }

        if (!mark && isnhspace((unsigned char) *argument))
            break;

        *(first_arg++) = LOWER(*argument);
        ++argument;
    }

    *first_arg = '\0';

    SkipSpaces(&argument);
    return (argument);
}

void AppendMonsterList(const CPythonNonPlayer::TMobTableList & c_rMobTableList, const char * c_szHeader, int iType)
{
    DWORD dwMonsterCount = 0;
    std::string strMonsterList = c_szHeader;

    CPythonNonPlayer::TMobTableList::const_iterator itor = c_rMobTableList.begin();
    for (; itor!=c_rMobTableList.end(); ++itor)
    {
        const CPythonNonPlayer::TMobTable * c_pMobTable = *itor;
        if (iType == c_pMobTable->bRank)
        {
            if (dwMonsterCount != 0)
                strMonsterList += ", ";
            strMonsterList += c_pMobTable->szLocaleName;
            if (++dwMonsterCount > 5)
                break;
        }
    }
    if (dwMonsterCount > 0)
    {
        IAbstractChat& rkChat=IAbstractChat::GetSingleton();
        rkChat.AppendChat(CHAT_TYPE_INFO, strMonsterList.c_str());
    }
}

bool CPythonNetworkStream::ClientCommand(const char * c_szCommand)
{
    return false;
}

bool SplitToken(const char * c_szLine, CTokenVector * pstTokenVector, const char * c_szDelimeter = " ")
{
    pstTokenVector->reserve(10);
    pstTokenVector->clear();

    std::string stToken;
    std::string strLine = c_szLine;

    DWORD basePos = 0;

    do
    {
        int beginPos = strLine.find_first_not_of(c_szDelimeter, basePos);
        if (beginPos < 0)
            return false;

        int endPos;

        if (strLine[beginPos] == '"')
        {
            ++beginPos;
            endPos = strLine.find_first_of("\"", beginPos);

            if (endPos < 0)
                return false;
            
            basePos = endPos + 1;
        }
        else
        {
            endPos = strLine.find_first_of(c_szDelimeter, beginPos);
            basePos = endPos;
        }

        pstTokenVector->push_back(strLine.substr(beginPos, endPos - beginPos));

        // Ãß°¡ ÄÚµå. ¸ÇµÚ¿¡ ÅÇÀÌ ÀÖ´Â °æ¿ì¸¦ üũÇÑ´Ù. - [levites]
        if (int(strLine.find_first_not_of(c_szDelimeter, basePos)) < 0)
            break;
    } while (basePos < strLine.length());

    return true;
}

void CPythonNetworkStream::ServerCommand(char * c_szCommand)
{
    // #0000811: [M2EU] ÄܼÖâ ±â´É Â÷´Ü 
    if (strcmpi(c_szCommand, "ConsoleEnable") == 0)
        return;

    if (m_apoPhaseWnd[PHASE_WINDOW_GAME])
    {
        bool isTrue;
        if (PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
            "BINARY_ServerCommand_Run", 
            Py_BuildValue("(s)", c_szCommand),
            &isTrue
        ))
        {
            if (isTrue)
                return;
        }
    }
    else if (m_poSerCommandParserWnd)
    {
        bool isTrue;
        if (PyCallClassMemberFunc(m_poSerCommandParserWnd, 
            "BINARY_ServerCommand_Run", 
            Py_BuildValue("(s)", c_szCommand),
            &isTrue
        ))
        {
            if (isTrue)
                return;
        }
    }

    CTokenVector TokenVector;
    if (!SplitToken(c_szCommand, &TokenVector))
        return;
    if (TokenVector.empty())
        return;

    const char * szCmd = TokenVector[0].c_str();
    
    if (!strcmpi(szCmd, "quit"))
    {
        PostQuitMessage(0);
    }
    else if (!strcmpi(szCmd, "BettingMoney"))
    {
        if (2 != TokenVector.size())
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
            return;
        }

        //UINT uMoney= atoi(TokenVector[1].c_str());        
        
    }
    // GIFT NOTIFY
    else if (!strcmpi(szCmd, "gift"))
    {
        PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "Gift_Show", Py_BuildValue("()"));     
    }
    // CUBE
    else if (!strcmpi(szCmd, "cube"))
    {
        if (TokenVector.size() < 2)
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
            return;
        }

        if ("open" == TokenVector[1])
        {
            if (3 > TokenVector.size())
            {
                TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
                return;
            }

            DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());
            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Open", Py_BuildValue("(i)", npcVNUM));
        }
        else if ("close" == TokenVector[1])
        {
            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Close", Py_BuildValue("()"));
        }
        else if ("info" == TokenVector[1])
        {
            if (5 != TokenVector.size())
            {
                TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
                return;
            }

            UINT gold = atoi(TokenVector[2].c_str());
            UINT itemVnum = atoi(TokenVector[3].c_str());
            UINT count = atoi(TokenVector[4].c_str());
            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_UpdateInfo", Py_BuildValue("(iii)", gold, itemVnum, count));
        }
        else if ("success" == TokenVector[1])
        {
            if (4 != TokenVector.size())
            {
                TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
                return;
            }

            UINT itemVnum = atoi(TokenVector[2].c_str());
            UINT count = atoi(TokenVector[3].c_str());
            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Succeed", Py_BuildValue("(ii)", itemVnum, count));
        }
        else if ("fail" == TokenVector[1])
        {
            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Failed", Py_BuildValue("()"));
        }
        //else if ("r_list" == TokenVector[1])
        //{
            //result list (/cube r_list npcVNUM resultCount resultText)
            //20383 4 72723,1/72725,1/72730.1/50001,5 <- ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºÐµÈ ¸®½ºÆ®¸¦ ÁÜ
            //if (5 != TokenVector.size())
            //{
                //TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, 5);
                //return;
            //}

            //DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());

            //PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_ResultList", Py_BuildValue("(is)", npcVNUM, TokenVector[4].c_str()));
        //}
        else if ("m_info" == TokenVector[1])
        {
            // material list (/cube m_info requestStartIndex resultCount MaterialText)
            // ex) requestStartIndex: 0, resultCount : 5 - ÇØ´ç NPC°¡ ¸¸µé¼ö ÀÖ´Â ¾ÆÀÌÅÛ Áß 0~4¹ø°¿¡ ÇØ´çÇÏ´Â ¾ÆÀÌÅÛÀ» ¸¸µå´Â µ¥ ÇÊ¿äÇÑ ¸ðµç Àç·áµéÀÌ MaterialText¿¡ µé¾îÀÖÀ½
            // À§ ¿¹½Ãó·³ ¾ÆÀÌÅÛÀÌ ´Ù¼öÀÎ °æ¿ì ±¸ºÐÀÚ "@" ¹®ÀÚ¸¦ »ç¿ë
            // 0 5 125,1|126,2|127,2|123,5&555,5&555,4/120000 <- ÀÌ·±½ÄÀ¸·Î ¼­¹ö¿¡¼­ Ŭ¶ó·Î ¸®½ºÆ®¸¦ ÁÜ

            if (5 != TokenVector.size())
            {
                TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, 5);
                return;
            }

            UINT requestStartIndex = (UINT)atoi(TokenVector[2].c_str());
            UINT resultCount = (UINT)atoi(TokenVector[3].c_str());

            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_MaterialInfo", Py_BuildValue("(iis)", requestStartIndex, resultCount, TokenVector[4].c_str()));
        }
    }
    // CUEBE_END
    else if (!strcmpi(szCmd, "ObserverCount"))
    {
        if (2 != TokenVector.size())
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
            return;
        }

        UINT uObserverCount= atoi(TokenVector[1].c_str());                

        PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
            "BINARY_BettingGuildWar_UpdateObserverCount", 
            Py_BuildValue("(i)", uObserverCount)
        );
    }
    else if (!strcmpi(szCmd, "ObserverMode"))
    {        
        if (2 != TokenVector.size())
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
            return;
        }

        UINT uMode= atoi(TokenVector[1].c_str());
        
        IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
        rkPlayer.SetObserverMode(uMode ? true : false);

        PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
            "BINARY_BettingGuildWar_SetObserverMode", 
            Py_BuildValue("(i)", uMode)
        );
    }
    else if (!strcmpi(szCmd, "ObserverTeamInfo"))
    {        
    }
    else if (!strcmpi(szCmd, "StoneDetect"))
    {
        if (4 != TokenVector.size())
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
            return;
        }

        // vid distance(1-3) angle(0-360)
        DWORD dwVID = atoi(TokenVector[1].c_str());
        BYTE byDistance = atoi(TokenVector[2].c_str());
        float fAngle = atof(TokenVector[3].c_str());
        fAngle = fmod(540.0f - fAngle, 360.0f);
        Tracef("StoneDetect [VID:%d] [Distance:%d] [Angle:%d->%f]\n", dwVID, byDistance, atoi(TokenVector[3].c_str()), fAngle);

        IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();

        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(dwVID);
        if (!pInstance)
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Not Exist Instance", c_szCommand);
            return;
        }

        TPixelPosition PixelPosition;
        D3DXVECTOR3 v3Rotation(0.0f, 0.0f, fAngle);
        pInstance->NEW_GetPixelPosition(&PixelPosition);

        PixelPosition.y *= -1.0f;

        switch (byDistance)
        {
            case 0:
                CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/firecracker/find_out.mse");
                CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/firecracker/find_out.mse", PixelPosition, v3Rotation);
                break;
            case 1:
                CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/compass/appear_small.mse");
                CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/compass/appear_small.mse", PixelPosition, v3Rotation);
                break;
            case 2:
                CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/compass/appear_middle.mse");
                CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/compass/appear_middle.mse", PixelPosition, v3Rotation);
                break;
            case 3:
                CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/compass/appear_large.mse");
                CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/compass/appear_large.mse", PixelPosition, v3Rotation);
                break;
            default:
                TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Distance", c_szCommand);
                break;
        }

#ifdef _DEBUG
        IAbstractChat& rkChat=IAbstractChat::GetSingleton();
        rkChat.AppendChat(CHAT_TYPE_INFO, c_szCommand);
#endif
    }
    else if (!strcmpi(szCmd, "StartStaminaConsume"))
    {
        if (3 != TokenVector.size())
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
            return;
        }

        DWORD dwConsumePerSec = atoi(TokenVector[1].c_str());
        DWORD dwCurrentStamina = atoi(TokenVector[2].c_str());

        IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
        rPlayer.StartStaminaConsume(dwConsumePerSec, dwCurrentStamina);
    }
    
    else if (!strcmpi(szCmd, "StopStaminaConsume"))
    {
        if (2 != TokenVector.size())
        {
            TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, TokenVector.size());
            return;
        }

        DWORD dwCurrentStamina = atoi(TokenVector[1].c_str());

        IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
        rPlayer.StopStaminaConsume(dwCurrentStamina);
    }
    else if (!strcmpi(szCmd, "sms"))
    {
        IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
        rPlayer.SetMobileFlag(TRUE);
    }
    else if (!strcmpi(szCmd, "nosms"))
    {
        IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
        rPlayer.SetMobileFlag(FALSE);
    }
    else if (!strcmpi(szCmd, "mobile_auth"))
    {
        PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnMobileAuthority", Py_BuildValue("()"));
    }
    else if (!strcmpi(szCmd, "messenger_auth"))
    {
        const std::string & c_rstrName = TokenVector[1].c_str();
        PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnMessengerAddFriendQuestion", Py_BuildValue("(s)", c_rstrName.c_str()));
    }
    else if (!strcmpi(szCmd, "combo"))
    {
        int iFlag = atoi(TokenVector[1].c_str());
        IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
        rPlayer.SetComboSkillFlag(iFlag);
        m_bComboSkillFlag = iFlag ? true : false;
    }
    else if (!strcmpi(szCmd, "setblockmode"))
    {
        int iFlag = atoi(TokenVector[1].c_str());
        PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnBlockMode", Py_BuildValue("(i)", iFlag));
    }
    // Emotion Start
    else if (!strcmpi(szCmd, "french_kiss"))
    {
        int iVID1 = atoi(TokenVector[1].c_str());
        int iVID2 = atoi(TokenVector[2].c_str());

        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance1 = rkChrMgr.GetInstancePtr(iVID1);
        CInstanceBase * pInstance2 = rkChrMgr.GetInstancePtr(iVID2);
        if (pInstance1 && pInstance2)
            pInstance1->ActDualEmotion(*pInstance2, CRaceMotionData::NAME_FRENCH_KISS_START, CRaceMotionData::NAME_FRENCH_KISS_START);
    }
    else if (!strcmpi(szCmd, "kiss"))
    {
        int iVID1 = atoi(TokenVector[1].c_str());
        int iVID2 = atoi(TokenVector[2].c_str());

        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance1 = rkChrMgr.GetInstancePtr(iVID1);
        CInstanceBase * pInstance2 = rkChrMgr.GetInstancePtr(iVID2);
        if (pInstance1 && pInstance2)
            pInstance1->ActDualEmotion(*pInstance2, CRaceMotionData::NAME_KISS_START, CRaceMotionData::NAME_KISS_START);
    }
    else if (!strcmpi(szCmd, "slap"))
    {
        int iVID1 = atoi(TokenVector[1].c_str());
        int iVID2 = atoi(TokenVector[2].c_str());

        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance1 = rkChrMgr.GetInstancePtr(iVID1);
        CInstanceBase * pInstance2 = rkChrMgr.GetInstancePtr(iVID2);
        if (pInstance1 && pInstance2)
            pInstance1->ActDualEmotion(*pInstance2, CRaceMotionData::NAME_SLAP_HURT_START, CRaceMotionData::NAME_SLAP_HIT_START);
    }
    else if (!strcmpi(szCmd, "clap"))
    {
        int iVID = atoi(TokenVector[1].c_str());
        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
        if (pInstance)
            pInstance->ActEmotion(CRaceMotionData::NAME_CLAP);
    }
    else if (!strcmpi(szCmd, "cheer1"))
    {
        int iVID = atoi(TokenVector[1].c_str());
        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
        if (pInstance)
            pInstance->ActEmotion(CRaceMotionData::NAME_CHEERS_1);
    }
    else if (!strcmpi(szCmd, "cheer2"))
    {
        int iVID = atoi(TokenVector[1].c_str());
        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
        if (pInstance)
            pInstance->ActEmotion(CRaceMotionData::NAME_CHEERS_2);
    }
    else if (!strcmpi(szCmd, "dance1"))
    {
        int iVID = atoi(TokenVector[1].c_str());
        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
        if (pInstance)
            pInstance->ActEmotion(CRaceMotionData::NAME_DANCE_1);
    }
    else if (!strcmpi(szCmd, "dance2"))
    {
        int iVID = atoi(TokenVector[1].c_str());
        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
        if (pInstance)
            pInstance->ActEmotion(CRaceMotionData::NAME_DANCE_2);
    }
    else if (!strcmpi(szCmd, "dig_motion"))
    {
        int iVID = atoi(TokenVector[1].c_str());
        IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
        CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
        if (pInstance)
            pInstance->ActEmotion(CRaceMotionData::NAME_DIG);
    }
    // Emotion End
    else
    {
        static std::map<std::string, int> s_emotionDict;

        static bool s_isFirst = true;
        if (s_isFirst)
        {
            s_isFirst = false;

            s_emotionDict["dance3"] = CRaceMotionData::NAME_DANCE_3;
            s_emotionDict["dance4"] = CRaceMotionData::NAME_DANCE_4;
            s_emotionDict["dance5"] = CRaceMotionData::NAME_DANCE_5;
            s_emotionDict["dance6"] = CRaceMotionData::NAME_DANCE_6;
            s_emotionDict["congratulation"] = CRaceMotionData::NAME_CONGRATULATION;
            s_emotionDict["forgive"] = CRaceMotionData::NAME_FORGIVE;
            s_emotionDict["angry"] = CRaceMotionData::NAME_ANGRY;
            s_emotionDict["attractive"] = CRaceMotionData::NAME_ATTRACTIVE;
            s_emotionDict["sad"] = CRaceMotionData::NAME_SAD;
            s_emotionDict["shy"] = CRaceMotionData::NAME_SHY;
            s_emotionDict["cheerup"] = CRaceMotionData::NAME_CHEERUP;
            s_emotionDict["banter"] = CRaceMotionData::NAME_BANTER;
            s_emotionDict["joy"] = CRaceMotionData::NAME_JOY;
        }

        std::map<std::string, int>::iterator f = s_emotionDict.find(szCmd);
        if (f == s_emotionDict.end())
        {
            TraceError("Unknown Server Command %s | %s", c_szCommand, szCmd);
        }
        else
        {
            int emotionIndex = f->second;

            int iVID = atoi(TokenVector[1].c_str());
            IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
            CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);

            if (pInstance)
                pInstance->ActEmotion(emotionIndex);
        }        
    }
}

@Grimmjow

[Grimmjow 57]

Try now

This is the hidden content, please

• Sign In
• or
• Sign Up

[Jorila 3]

 i cant click @Grimmjow

Edited August 20, 2022 by Metin2 Dev
Core X - External 2 Internal

[Grimmjow 57]

Wait i upload

This is the hidden content, please

• Sign In
• or
• Sign Up