Jump to content
×
×
  • Create New...
  • 0

Plusieurs problèmes Magasin hors ligne


Alan
 Share

Question

Bonjour à tous, 

J'ai suivi ce tuto afin d'implanter les magasins hors-ligne

 

1 - Je rencontre ce soucis côté serveur (files 2014 -42050)

erreur-db.png

J'ai du mal à comprendre car c'est un fichier auquel je n'ai pas touché et je ne sais pas comment le modifier. Voici le fichier en question

Citation

#include "stdafx.h"
#include "../../libgame/include/grid.h"
#include "constants.h"
#include "utils.h"
#include "config.h"
#include "desc.h"
#include "desc_manager.h"
#include "char.h"
#include "char_manager.h"
#include "item.h"
#include "item_manager.h"
#include "buffer_manager.h"
#include "packet.h"
#include "log.h"
#include "db.h"
#include "questmanager.h"
#include "monarch.h"
#include "mob_manager.h"
#include "locale_service.h"
#include "offlineshop.h"
#include "p2p.h"

COfflineShop::COfflineShop() : m_pkOfflineShopNPC(NULL)
{
    m_pGrid = M2_NEW CGrid(8, 8);
}

COfflineShop::~COfflineShop()
{
    TPacketGCShop pack;
    pack.header = HEADER_GC_OFFLINE_SHOP;
    pack.subheader = SHOP_SUBHEADER_GC_END;
    pack.size = sizeof(TPacketGCShop);

    Broadcast(&pack, sizeof(pack));

    for (GuestMapType::iterator it = m_map_guest.begin(); it != m_map_guest.end(); ++it)
    {
        LPCHARACTER ch = it->first;
        ch->SetOfflineShop(NULL);
    }

    M2_DELETE(m_pGrid);
}

void COfflineShop::SetOfflineShopNPC(LPCHARACTER npc)
{
    m_pkOfflineShopNPC = npc;
}

void COfflineShop::SetShopItems(TShopItemTable * pTable, BYTE bItemCount, LPCHARACTER ch)
{
    if (!ch)
        return;

    m_pGrid->Clear();

    m_offlineShopItemVector.resize(OFFLINE_SHOP_HOST_ITEM_MAX_NUM);
    memset(&m_offlineShopItemVector[0], 0, sizeof(OFFLINE_SHOP_ITEM) * m_offlineShopItemVector.size());

    for (int i = 0; i < bItemCount; ++i)
    {
        int iPos;
        LPITEM pkItem = ch->GetItem(pTable->pos);

        if (!pkItem)
        {
            sys_err("COfflineShop::SetShopItems: cannot find item on pos (%d, %d) (name: %s)", pTable->pos.window_type, pTable->pos.cell, ch->GetName());
            continue;
        }

        if(pkItem->IsEquipped() == true || pkItem->isLocked() == true || pkItem->IsExchanging())
            continue;

        const TItemTable * item_table = pkItem->GetProto();

        if (!item_table)
        {
            sys_err("COfflineShop::SetShopItems: no item table by item vnum #%d", pTable->vnum);
            continue;
        }

        if (IS_SET(item_table->dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP))
            continue;

        iPos = pTable->display_pos;

        if (iPos < 0)
        {
            sys_err("COfflineShop::SetShopItems: not enough shop window!");
            continue;
        }

        //sys_log(0, "COfflineShop::SetShopItems: use position %d", iPos);

        if (!m_pGrid->IsEmpty(iPos, 1, pkItem->GetSize()))
        {
            sys_err("COfflineShop::SetShopItems: not empty position offline shop %s[%d]", ch->GetName(), ch->GetPlayerID());
            continue;
        }

        m_pGrid->Put(iPos, 1, pkItem->GetSize());

        /* memory part begin */
        OFFLINE_SHOP_ITEM & offShopItem = m_offlineShopItemVector[iPos];

        //////////
        // bIsSold already declared as = false in offlineshop.h
        offShopItem.owner_id = ch->GetPlayerID();
        offShopItem.pos = iPos;
        offShopItem.count = pkItem->GetCount();
        offShopItem.price = pTable->price;
        offShopItem.vnum = pkItem->GetVnum();

        for (int x = 0; x < ITEM_SOCKET_MAX_NUM; x++)
            offShopItem.alSockets[x] = pkItem->GetSocket(x);

        for (int x = 0; x < ITEM_ATTRIBUTE_MAX_NUM; x++)
        {
            offShopItem.aAttr[x].bType = pkItem->GetAttributeType(x);
            offShopItem.aAttr[x].sValue = pkItem->GetAttributeValue(x);
        }
        /* memory part end */

        /* query part begin */
        char szColumns[QUERY_MAX_LEN], szValues[QUERY_MAX_LEN];

        snprintf(szColumns, sizeof(szColumns),
        "owner_id, pos, count, price, vnum,"
        "socket0, socket1, socket2,"
        "attrtype0, attrvalue0, attrtype1, attrvalue1,"
        "attrtype2, attrvalue2, attrtype3, attrvalue3,"
        "attrtype4, attrvalue4, attrtype5, attrvalue5,"
        "attrtype6, attrvalue6");
        
        snprintf(szValues, sizeof(szValues), "%u, %d, %u, %u, %u, %ld, %ld, %ld, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d", 
            ch->GetPlayerID(), iPos, pkItem->GetCount(), pTable->price, pkItem->GetVnum(),
            pkItem->GetSocket(0), pkItem->GetSocket(1),
            pkItem->GetSocket(2),
            pkItem->GetAttributeType(0), pkItem->GetAttributeValue(0), pkItem->GetAttributeType(1), pkItem->GetAttributeValue(1),
            pkItem->GetAttributeType(2), pkItem->GetAttributeValue(2), pkItem->GetAttributeType(3), pkItem->GetAttributeValue(3),
            pkItem->GetAttributeType(4), pkItem->GetAttributeValue(4), pkItem->GetAttributeType(5), pkItem->GetAttributeValue(5),
            pkItem->GetAttributeType(6), pkItem->GetAttributeValue(6));

        char szInsertQuery[QUERY_MAX_LEN];
        snprintf(szInsertQuery, sizeof(szInsertQuery), "INSERT INTO %soffline_shop_item (%s) VALUES (%s)", get_table_postfix(), szColumns, szValues);
        std::unique_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery(szInsertQuery));
        /* query part end */

        /* log for web */
        LogManager::instance().OfflineShopLog(ch->GetDesc()->GetAccountTable().id, pkItem->GetName(), "PUT");
        /* end log for web */

        ITEM_MANAGER::instance().RemoveItem(pkItem);

        ++pTable;
    }
}

void COfflineShop::PutItem(LPCHARACTER ch, TItemPos item_pos, int iPrice)
{
    if (!ch || !ch->CanHandleItem())
        return;

    LPITEM pkItem = ch->GetItem(item_pos);

    if (!pkItem)
        return;

    if (pkItem->IsEquipped() == true || pkItem->isLocked() == true || pkItem->IsExchanging())
        return;

    const TItemTable * item_table = pkItem->GetProto();

    if (!item_table)
        return;

    if (IS_SET(item_table->dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP))
        return;

    int iPos = m_pGrid->FindBlank(1, item_table->bSize);

    if (iPos < 0)
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You don't have enough space to put your item!"));
        return;
    }

    if (!m_pGrid->IsEmpty(iPos, 1, item_table->bSize))
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You don't have enough space to put your item!"));
        return;
    }

    m_pGrid->Put(iPos, 1, item_table->bSize);

    /* memory part begin */
    OFFLINE_SHOP_ITEM & offShopItem = m_offlineShopItemVector[iPos];

    //////////
    // bIsSold already declared as = false in offlineshop.h
    offShopItem.owner_id = ch->GetPlayerID();
    offShopItem.pos = iPos;
    offShopItem.count = pkItem->GetCount();
    offShopItem.price = iPrice;
    offShopItem.vnum = pkItem->GetVnum();

    for (int x = 0; x < ITEM_SOCKET_MAX_NUM; x++)
        offShopItem.alSockets[x] = pkItem->GetSocket(x);

    for (int x = 0; x < ITEM_ATTRIBUTE_MAX_NUM; x++)
    {
        offShopItem.aAttr[x].bType = pkItem->GetAttributeType(x);
        offShopItem.aAttr[x].sValue = pkItem->GetAttributeValue(x);
    }
    /* memory part end */
    
    /* query part begin */
    char szColumns[QUERY_MAX_LEN], szValues[QUERY_MAX_LEN];

    snprintf(szColumns, sizeof(szColumns),
        "owner_id, pos, count, price, vnum,"
        "socket0, socket1, socket2,"
        "attrtype0, attrvalue0, attrtype1, attrvalue1,"
        "attrtype2, attrvalue2, attrtype3, attrvalue3,"
        "attrtype4, attrvalue4, attrtype5, attrvalue5,"
        "attrtype6, attrvalue6");

    snprintf(szValues, sizeof(szValues), "%u, %d, %u, %u, %u, %ld, %ld, %ld, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d",
        ch->GetPlayerID(), iPos, pkItem->GetCount(), iPrice, pkItem->GetVnum(),
        pkItem->GetSocket(0), pkItem->GetSocket(1),
        pkItem->GetSocket(2),
        pkItem->GetAttributeType(0), pkItem->GetAttributeValue(0), pkItem->GetAttributeType(1), pkItem->GetAttributeValue(1),
        pkItem->GetAttributeType(2), pkItem->GetAttributeValue(2), pkItem->GetAttributeType(3), pkItem->GetAttributeValue(3),
        pkItem->GetAttributeType(4), pkItem->GetAttributeValue(4), pkItem->GetAttributeType(5), pkItem->GetAttributeValue(5),
        pkItem->GetAttributeType(6), pkItem->GetAttributeValue(6));

    char szInsertQuery[QUERY_MAX_LEN];
    snprintf(szInsertQuery, sizeof(szInsertQuery), "INSERT INTO %soffline_shop_item (%s) VALUES (%s)", get_table_postfix(), szColumns, szValues);
    std::unique_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery(szInsertQuery));
    /* query part end */

    /* log for web */
    LogManager::instance().OfflineShopLog(ch->GetDesc()->GetAccountTable().id, pkItem->GetName(), "PUT_REMOTE");
    /* end log for web */

    BroadcastUpdateItem(iPos);

    ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Item %s has been successfully added to your offline shop, price: %d."), pkItem->GetName(), iPrice);
    
    ITEM_MANAGER::instance().RemoveItem(pkItem);
}

bool COfflineShop::AddGuest(LPCHARACTER ch, LPCHARACTER npc)
{
    if (!ch || ch->GetExchange() || ch->GetShop() || ch->GetMyShop() || ch->GetOfflineShop())
        return false;

    ch->SetOfflineShop(this);
    m_map_guest.insert(GuestMapType::value_type(ch, false));

    TPacketGCShop pack;
    pack.header = HEADER_GC_OFFLINE_SHOP;
    pack.subheader = SHOP_SUBHEADER_GC_START;

    TPacketGCOfflineShopStart pack2;
    memset(&pack2, 0, sizeof(pack2));
    pack2.owner_vid = npc->GetVID();

    for (DWORD i = 0; i < m_offlineShopItemVector.size() && i < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++i)
    {
        const OFFLINE_SHOP_ITEM & offShopItem = m_offlineShopItemVector[i];

        pack2.items[i].count = offShopItem.count;
        pack2.items[i].price = offShopItem.price;
        pack2.items[i].vnum = offShopItem.vnum;
        pack2.items[i].bIsSold = offShopItem.bIsSold;
        strncpy(pack2.items[i].buyerName, offShopItem.buyerName, CHARACTER_NAME_MAX_LEN);

        for (int x = 0; x < ITEM_SOCKET_MAX_NUM; x++)
            pack2.items[i].alSockets[x] = offShopItem.alSockets[x];
    
        for (int x = 0; x < ITEM_ATTRIBUTE_MAX_NUM; x++)
        {
            const TPlayerItemAttribute & c_rItemAttr = offShopItem.aAttr[x];
            
            pack2.items[i].aAttr[x].bType = c_rItemAttr.bType;
            pack2.items[i].aAttr[x].sValue = c_rItemAttr.sValue;
        }
    }

    pack.size = sizeof(pack)+sizeof(pack2);
    ch->GetDesc()->BufferedPacket(&pack, sizeof(TPacketGCShop));
    ch->GetDesc()->Packet(&pack2, sizeof(TPacketGCOfflineShopStart));
    return true;
}

void COfflineShop::RemoveGuest(LPCHARACTER ch)
{
    if (ch->GetOfflineShop() != this)
        return;

    m_map_guest.erase(ch);
    ch->SetOfflineShop(NULL);

    TPacketGCShop pack;
    pack.header = HEADER_GC_OFFLINE_SHOP;
    pack.subheader = SHOP_SUBHEADER_GC_END;
    pack.size = sizeof(TPacketGCShop);

    ch->GetDesc()->Packet(&pack, sizeof(pack));
}

void COfflineShop::RemoveAllGuest()
{
    TPacketGCShop pack;
    pack.header = HEADER_GC_OFFLINE_SHOP;
    pack.subheader = SHOP_SUBHEADER_GC_END;
    pack.size = sizeof(TPacketGCShop);

    Broadcast(&pack, sizeof(pack));

    for (GuestMapType::iterator it = m_map_guest.begin(); it != m_map_guest.end(); ++it)
    {
        LPCHARACTER ch = it->first;
        ch->SetOfflineShop(NULL);
    }
}

void COfflineShop::Destroy(LPCHARACTER npc)
{
    RemoveAllGuest();
    M2_DESTROY_CHARACTER(npc);
}

void COfflineShop::GiveBackMyItems(LPCHARACTER ch)
{
    if (!ch)
        return;

    RemoveAllGuest();

    /* cleanup begin */
    DBManager::instance().DirectQuery("DELETE FROM %soffline_shop_item WHERE owner_id = %u", get_table_postfix(), ch->GetPlayerID());
    /* cleanup end */

    for (DWORD i = 0; i < m_offlineShopItemVector.size() && i < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++i)
    {
        const OFFLINE_SHOP_ITEM & r_item = m_offlineShopItemVector[i];

        if (r_item.bIsSold || !r_item.vnum)
            continue;

        LPITEM pItem = ITEM_MANAGER::instance().CreateItem(r_item.vnum, r_item.count);
        
        if (pItem)
        {
            pItem->SetSockets(r_item.alSockets);
            pItem->SetAttributes(r_item.aAttr);

            int cell;
            cell = ch->GetEmptyInventory(pItem->GetSize());

            if (cell != -1)
            {
                pItem->AddToCharacter(ch, TItemPos(INVENTORY, cell));
            }
            else
            {
                pItem->AddToGround(ch->GetMapIndex(), ch->GetXYZ());
                pItem->StartDestroyEvent();
                pItem->SetOwnership(ch, 60);
            }

            /* log for web */
            LogManager::instance().OfflineShopLog(ch->GetDesc()->GetAccountTable().id, pItem->GetName(), "GIVE_BACK");
            /* end log for web */
        }
    }
}

int COfflineShop::Buy(LPCHARACTER ch, BYTE bPos)
{
    //if (!ch)
    //    return SHOP_SUBHEADER_GC_END;
    
    if (ch->GetOfflineShopOwner()->GetOfflineShopRealOwner() == ch->GetPlayerID())
    {
        ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't buy anything from your offline shop."));
        return SHOP_SUBHEADER_GC_OK;
    }

    if (bPos >= m_offlineShopItemVector.size())
    {
        sys_log(0, "COfflineShop::Buy: invalid position %d : %s", bPos, ch->GetName());
        return SHOP_SUBHEADER_GC_INVALID_POS;
    }

    //sys_log(0, "COfflineShop::Buy: name: %s, pos: %d", ch->GetName(), bPos);

    GuestMapType::iterator it = m_map_guest.find(ch);
    if (it == m_map_guest.end())
        return SHOP_SUBHEADER_GC_END;

    OFFLINE_SHOP_ITEM & r_item = m_offlineShopItemVector[bPos];

    if (r_item.bIsSold)
        return SHOP_SUBHEADER_GC_SOLD_OUT;

    DWORD dwPrice = r_item.price;

    if (r_item.price < 0)
        return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY;

    if (ch->GetGold() < static_cast<int>(dwPrice))
        return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY;

    LPITEM item = ITEM_MANAGER::instance().CreateItem(r_item.vnum, r_item.count);

    if (!item)
        return SHOP_SUBHEADER_GC_END;

    int iEmptyPos = ch->GetEmptyInventory(item->GetSize());

    if (iEmptyPos < 0)
    {
        M2_DESTROY_ITEM(item);
        return SHOP_SUBHEADER_GC_INVENTORY_FULL;
    }

    ch->PointChange(POINT_GOLD, -dwPrice, false);
    r_item.bIsSold = true;
    strncpy(r_item.buyerName, ch->GetName(), CHARACTER_NAME_MAX_LEN);

    item->SetSockets(r_item.alSockets);
    item->SetAttributes(r_item.aAttr);

    item->AddToCharacter(ch, TItemPos(INVENTORY, iEmptyPos));

    DBManager::instance().DirectQuery("UPDATE player.player SET gold_offlineshop = gold_offlineshop + %u WHERE id = %u", dwPrice, ch->GetOfflineShopOwner()->GetOfflineShopRealOwner());
    DBManager::instance().DirectQuery("DELETE FROM %soffline_shop_item WHERE owner_id = %u AND pos = %d AND vnum = %d LIMIT 1", get_table_postfix(), r_item.owner_id, bPos, r_item.vnum);

    LogManager::instance().OfflineShopLog(ch->GetOfflineShopOwner()->GetOfflineShopRealOwnerAccountID(), item->GetName(), "SELL");

    BroadcastUpdateItem(bPos);

    ch->SetMyOfflineShopTime();
    ch->Save();

    LPCHARACTER tch = CHARACTER_MANAGER::instance().FindByPID(ch->GetOfflineShopOwner()->GetOfflineShopRealOwner());

    if (tch)
    {
        char msg[CHAT_MAX_LEN + 1];
        snprintf(msg, sizeof(msg), LC_TEXT("Your item %s sold, buyer is: %s."), item->GetName(), ch->GetName());

        LPDESC pkVictimDesc = tch->GetDesc();

        if (pkVictimDesc)
        {
            TPacketGCWhisper pack;

            int len = MIN(CHAT_MAX_LEN, strlen(msg) + 1);

            pack.bHeader = HEADER_GC_WHISPER;
            pack.wSize = sizeof(TPacketGCWhisper) + len;
            pack.bType = WHISPER_TYPE_SYSTEM;
            strlcpy(pack.szNameFrom, "[Market Tezgahý]", sizeof(pack.szNameFrom));

            TEMP_BUFFER buf;

            buf.write(&pack, sizeof(TPacketGCWhisper));
            buf.write(msg, len);

            pkVictimDesc->Packet(buf.read_peek(), buf.size());
        }

        //tch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Market Tezgâhýndan nesne satýldý: %s."), item->GetName());
    }
    else
    {
        // P2P_FIND

        TPacketGGOfflineShopMessage p;
        p.bHeader = HEADER_GG_OFFLINE_SHOP_SEND_MESSAGE;
        p.dwTargetPID = ch->GetOfflineShopOwner()->GetOfflineShopRealOwner();
        strlcpy(p.szItemName, item->GetName(), sizeof(p.szItemName));
        strlcpy(p.szName, ch->GetName(), sizeof(p.szName));
        P2P_MANAGER::instance().Send(&p, sizeof(TPacketGGOfflineShopMessage));
    }

    return (SHOP_SUBHEADER_GC_OK);
}

void COfflineShop::BroadcastUpdateItem(BYTE bPos)
{
    TPacketGCShop pack;
    TPacketGCShopUpdateOfflineItem pack2;

    TEMP_BUFFER buf;

    pack.header = HEADER_GC_OFFLINE_SHOP;
    pack.subheader = SHOP_SUBHEADER_GC_UPDATE_ITEM;
    pack.size = sizeof(pack) + sizeof(pack2);

    OFFLINE_SHOP_ITEM & r_item = m_offlineShopItemVector[bPos];

    pack2.item.count = r_item.count;
    pack2.item.price = r_item.price;
    pack2.item.vnum = r_item.vnum;
    pack2.item.bIsSold = r_item.bIsSold;
    pack2.pos = r_item.pos;
    strncpy(pack2.item.buyerName, r_item.buyerName, CHARACTER_NAME_MAX_LEN);

    for (int x = 0; x < ITEM_SOCKET_MAX_NUM; x++)
        pack2.item.alSockets[x] = r_item.alSockets[x];

    for (int x = 0; x < ITEM_ATTRIBUTE_MAX_NUM; x++)
    {
        const TPlayerItemAttribute & c_rItemAttr = r_item.aAttr[x];

        pack2.item.aAttr[x].bType = c_rItemAttr.bType;
        pack2.item.aAttr[x].sValue = c_rItemAttr.sValue;
    }

    buf.write(&pack, sizeof(pack));
    buf.write(&pack2, sizeof(pack2));
    Broadcast(buf.read_peek(), buf.size());
}

void COfflineShop::Broadcast(const void * data, int bytes)
{
    for (GuestMapType::iterator it = m_map_guest.begin(); it != m_map_guest.end(); ++it)
    {
        LPCHARACTER ch = it->first;
        if (ch->GetDesc())
            ch->GetDesc()->Packet(data, bytes);
    }
}
 

2 - A la fin je dois créer une table dans la base de donnée "player". Cependant je ne sais pas comment la configurer comme l'indique le tuto. Je vous partage les instructions

Citation

Créez "gold_offlineshop" dans la table des joueurs. bigint - 25 - non nul - "0" par défaut

Quelqu'un aurait-il la gentillesse de m'éclairer ? :) 

Merci d'avance, 

 

Alan

 

 

 

 

 

Edited by Funky Emulation
Core X - External 2 Internal
Link to comment
Share on other sites

  • Answers 3
  • Created
  • Last Reply

Top Posters For This Question

Top Posters For This Question

3 answers to this question

Recommended Posts

  • 0

@ ASIKOOen effet c'était pas top, c'est un peu mieux maintenant même si ce n'est plus le même problème car je l'ai réglé après pas mal de recherche. Mais sur celui-là je bloque complètement :( 

Pas mal de chose à adapter pour que ça puisse compiler sur ces files (ex : remplacer les auto_ptr par unique_ptr, TR1_NS:: par std:: etc...). 

Link to comment
Share on other sites

  • 0

Update : L'ensemble des problèmes côté serveur semble réglé. 

J'ai par contre un bug côté client. Je parviens à me connecter mais lorsque je click sur l'inventaire le client crash. Voici ce que j'ai dans le syserr....

Citation

0731 13:51:19770 :: Traceback (most recent call last):

0731 13:51:19770 ::   File "game.py", line 2106, in BINARY_OfflineShop_UpdateOnlinePlayerCount

0731 13:51:19770 ::   File "uiMiniMap.py", line 496, in UpdateOnlinePlayerCount

0731 13:51:19771 :: AttributeError
0731 13:51:19771 :: : 
0731 13:51:19771 :: 'module' object has no attribute 'PrettyNumber'
0731 13:51:19771 :: 

0731 13:51:19771 :: Traceback (most recent call last):

0731 13:51:19771 ::   File "game.py", line 2110, in BINARY_OfflineShop_UpdateOnlineShopCount

0731 13:51:19771 ::   File "uiMiniMap.py", line 499, in UpdateOnlineShopCount

0731 13:51:19771 :: AttributeError
0731 13:51:19771 :: : 
0731 13:51:19771 :: 'module' object has no attribute 'PrettyNumber'
0731 13:51:19771 :: 

J'ai recherché l'erreur mais je ne parviens pas à la trouver, le problème semble venir de uiminimap.py :

Citation

import ui
import uiScriptLocale
import wndMgr
import player
import miniMap
import localeInfo
import net
import app
import colorInfo
import constInfo
import background

class MapTextToolTip(ui.Window):
    def __init__(self):            
        ui.Window.__init__(self)

        textLine = ui.TextLine()
        textLine.SetParent(self)
        textLine.SetHorizontalAlignCenter()
        textLine.SetOutline()
        textLine.SetHorizontalAlignRight()
        textLine.Show()
        self.textLine = textLine

    def __del__(self):            
        ui.Window.__del__(self)

    def SetText(self, text):
        self.textLine.SetText(text)

    def SetTooltipPosition(self, PosX, PosY):
        if localeInfo.IsARABIC():
            w, h = self.textLine.GetTextSize()
            self.textLine.SetPosition(PosX - w - 5, PosY)
        else:
            self.textLine.SetPosition(PosX - 5, PosY)

    def SetTextColor(self, TextColor):
        self.textLine.SetPackedFontColor(TextColor)

    def GetTextSize(self):
        return self.textLine.GetTextSize()

class AtlasWindow(ui.ScriptWindow):

    class AtlasRenderer(ui.Window):
        def __init__(self):
            ui.Window.__init__(self)
            self.AddFlag("not_pick")

        def OnUpdate(self):
            miniMap.UpdateAtlas()

        def OnRender(self):
            (x, y) = self.GetGlobalPosition()
            fx = float(x)
            fy = float(y)
            miniMap.RenderAtlas(fx, fy)

        def HideAtlas(self):
            miniMap.HideAtlas()

        def ShowAtlas(self):
            miniMap.ShowAtlas()

    def __init__(self):
        self.tooltipInfo = MapTextToolTip()
        self.tooltipInfo.Hide()
        self.infoGuildMark = ui.MarkBox()
        self.infoGuildMark.Hide()
        self.AtlasMainWindow = None
        self.mapName = ""
        self.board = 0

        ui.ScriptWindow.__init__(self)

    def __del__(self):
        ui.ScriptWindow.__del__(self)

    def SetMapName(self, mapName):
        if 949==app.GetDefaultCodePage():
            try:
                self.board.SetTitleName(localeInfo.MINIMAP_ZONE_NAME_DICT[mapName])
            except:
                pass

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "UIScript/AtlasWindow.py")
        except:
            import exception
            exception.Abort("AtlasWindow.LoadWindow.LoadScript")

        try:
            self.board = self.GetChild("board")

        except:
            import exception
            exception.Abort("AtlasWindow.LoadWindow.BindObject")

        self.AtlasMainWindow = self.AtlasRenderer()
        self.board.SetCloseEvent(self.Hide)
        self.AtlasMainWindow.SetParent(self.board)
        self.AtlasMainWindow.SetPosition(7, 30)
        self.tooltipInfo.SetParent(self.board)
        self.infoGuildMark.SetParent(self.board)
        self.SetPosition(wndMgr.GetScreenWidth() - 136 - 256 - 10, 0)
        self.Hide()

        miniMap.RegisterAtlasWindow(self)

    def Destroy(self):
        miniMap.UnregisterAtlasWindow()
        self.ClearDictionary()
        self.AtlasMainWindow = None
        self.tooltipAtlasClose = 0
        self.tooltipInfo = None
        self.infoGuildMark = None
        self.board = None

    def OnUpdate(self):

        if not self.tooltipInfo:
            return

        if not self.infoGuildMark:
            return

        self.infoGuildMark.Hide()
        self.tooltipInfo.Hide()

        if False == self.board.IsIn():
            return

        (mouseX, mouseY) = wndMgr.GetMousePosition()
        (bFind, sName, iPosX, iPosY, dwTextColor, dwGuildID) = miniMap.GetAtlasInfo(mouseX, mouseY)

        if False == bFind:
            return

        if "empty_guild_area" == sName:
            sName = localeInfo.GUILD_EMPTY_AREA

        if localeInfo.IsARABIC() and sName[-1].isalnum():
            self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))                        
        else:
            self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))
            
        (x, y) = self.GetGlobalPosition()
        self.tooltipInfo.SetTooltipPosition(mouseX - x, mouseY - y)
        self.tooltipInfo.SetTextColor(dwTextColor)
        self.tooltipInfo.Show()
        self.tooltipInfo.SetTop()

        if 0 != dwGuildID:
            textWidth, textHeight = self.tooltipInfo.GetTextSize()
            self.infoGuildMark.SetIndex(dwGuildID)
            self.infoGuildMark.SetPosition(mouseX - x - textWidth - 18 - 5, mouseY - y)
            self.infoGuildMark.Show()

    def Hide(self):
        if self.AtlasMainWindow:
            self.AtlasMainWindow.HideAtlas()
            self.AtlasMainWindow.Hide()
        ui.ScriptWindow.Hide(self)

    def Show(self):
        if self.AtlasMainWindow:
            (bGet, iSizeX, iSizeY) = miniMap.GetAtlasSize()
            if bGet:
                self.SetSize(iSizeX + 15, iSizeY + 38)

                if localeInfo.IsARABIC():
                    self.board.SetPosition(iSizeX+15, 0)

                self.board.SetSize(iSizeX + 15, iSizeY + 38)
                #self.AtlasMainWindow.SetSize(iSizeX, iSizeY)
                self.AtlasMainWindow.ShowAtlas()
                self.AtlasMainWindow.Show()
        ui.ScriptWindow.Show(self)

    def SetCenterPositionAdjust(self, x, y):
        self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)

    def OnPressEscapeKey(self):
        self.Hide()
        return True

def __RegisterMiniMapColor(type, rgb):
    miniMap.RegisterColor(type, rgb[0], rgb[1], rgb[2])

class MiniMap(ui.ScriptWindow):

    CANNOT_SEE_INFO_MAP_DICT = {
        "metin2_map_monkeydungeon" : False,
        "metin2_map_monkeydungeon_02" : False,
        "metin2_map_monkeydungeon_03" : False,
        "metin2_map_devilsCatacomb" : False,
    }

    def __init__(self):
        ui.ScriptWindow.__init__(self)

        self.__Initialize()

        miniMap.Create()
        miniMap.SetScale(2.0)

        self.AtlasWindow = AtlasWindow()
        self.AtlasWindow.LoadWindow()
        self.AtlasWindow.Hide()

        self.tooltipMiniMapOpen = MapTextToolTip()
        self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP)
        self.tooltipMiniMapOpen.Show()
        self.tooltipMiniMapClose = MapTextToolTip()
        self.tooltipMiniMapClose.SetText(localeInfo.UI_CLOSE)
        self.tooltipMiniMapClose.Show()
        self.tooltipScaleUp = MapTextToolTip()
        self.tooltipScaleUp.SetText(localeInfo.MINIMAP_INC_SCALE)
        self.tooltipScaleUp.Show()
        self.tooltipScaleDown = MapTextToolTip()
        self.tooltipScaleDown.SetText(localeInfo.MINIMAP_DEC_SCALE)
        self.tooltipScaleDown.Show()
        self.tooltipAtlasOpen = MapTextToolTip()
        self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_SHOW_AREAMAP)
        self.tooltipAtlasOpen.Show()
        self.tooltipInfo = MapTextToolTip()
        self.tooltipInfo.Show()

        if miniMap.IsAtlas():
            self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_SHOW_AREAMAP)
        else:
            self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_CAN_NOT_SHOW_AREAMAP)

        self.tooltipInfo = MapTextToolTip()
        self.tooltipInfo.Show()

        self.mapName = ""

        self.isLoaded = 0
        self.canSeeInfo = True
        
        # AUTOBAN
        self.imprisonmentDuration = 0
        self.imprisonmentEndTime = 0
        self.imprisonmentEndTimeText = ""
        # END_OF_AUTOBAN

    def __del__(self):
        miniMap.Destroy()
        ui.ScriptWindow.__del__(self)

    def __Initialize(self):
        self.positionInfo = 0
        self.observerCount = 0

        self.OpenWindow = 0
        self.CloseWindow = 0
        self.ScaleUpButton = 0
        self.ScaleDownButton = 0
        self.MiniMapHideButton = 0
        self.MiniMapShowButton = 0
        self.AtlasShowButton = 0
        self.playerCount = 0
        self.shopCount = 0

        self.tooltipMiniMapOpen = 0
        self.tooltipMiniMapClose = 0
        self.tooltipScaleUp = 0
        self.tooltipScaleDown = 0
        self.tooltipAtlasOpen = 0
        self.tooltipInfo = None
        self.serverInfo = None

    def SetMapName(self, mapName):
        self.mapName=mapName
        self.AtlasWindow.SetMapName(mapName)

        if self.CANNOT_SEE_INFO_MAP_DICT.has_key(mapName):
            self.canSeeInfo = False
            self.HideMiniMap()
            self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP_CANNOT_SEE)
        else:
            self.canSeeInfo = True
            self.ShowMiniMap()
            self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP)
            
    # AUTOBAN
    def SetImprisonmentDuration(self, duration):
        self.imprisonmentDuration = duration
        self.imprisonmentEndTime = app.GetGlobalTimeStamp() + duration                
        
        self.__UpdateImprisonmentDurationText()
        
    def __UpdateImprisonmentDurationText(self):
        restTime = max(self.imprisonmentEndTime - app.GetGlobalTimeStamp(), 0)
        
        imprisonmentEndTimeText = localeInfo.SecondToDHM(restTime)
        if imprisonmentEndTimeText != self.imprisonmentEndTimeText:
            self.imprisonmentEndTimeText = imprisonmentEndTimeText
            self.serverInfo.SetText("%s: %s" % (uiScriptLocale.AUTOBAN_QUIZ_REST_TIME, self.imprisonmentEndTimeText))
    # END_OF_AUTOBAN    

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)

    def __LoadWindow(self):
        if self.isLoaded == 1:
            return

        self.isLoaded = 1

        try:
            pyScrLoader = ui.PythonScriptLoader()
            if localeInfo.IsARABIC():
                pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "Minimap.py")
            else:
                pyScrLoader.LoadScriptFile(self, "UIScript/MiniMap.py")
        except:
            import exception
            exception.Abort("MiniMap.LoadWindow.LoadScript")

        try:
            self.OpenWindow = self.GetChild("OpenWindow")
            self.MiniMapWindow = self.GetChild("MiniMapWindow")
            self.ScaleUpButton = self.GetChild("ScaleUpButton")
            self.ScaleDownButton = self.GetChild("ScaleDownButton")
            self.MiniMapHideButton = self.GetChild("MiniMapHideButton")
            self.AtlasShowButton = self.GetChild("AtlasShowButton")
            self.CloseWindow = self.GetChild("CloseWindow")
            self.MiniMapShowButton = self.GetChild("MiniMapShowButton")
            self.positionInfo = self.GetChild("PositionInfo")
            self.observerCount = self.GetChild("ObserverCount")
            self.serverInfo = self.GetChild("ServerInfo")
            self.playerCount = self.GetChild("PlayerCount")
            self.shopCount = self.GetChild("ShopCount")
        except:
            import exception
            exception.Abort("MiniMap.LoadWindow.Bind")

        if constInfo.MINIMAP_POSITIONINFO_ENABLE==0:
            self.positionInfo.Hide()

        self.serverInfo.SetText(net.GetServerInfo())
        self.ScaleUpButton.SetEvent(ui.__mem_func__(self.ScaleUp))
        self.ScaleDownButton.SetEvent(ui.__mem_func__(self.ScaleDown))
        self.MiniMapHideButton.SetEvent(ui.__mem_func__(self.HideMiniMap))
        self.MiniMapShowButton.SetEvent(ui.__mem_func__(self.ShowMiniMap))

        if miniMap.IsAtlas():
            self.AtlasShowButton.SetEvent(ui.__mem_func__(self.ShowAtlas))

        (ButtonPosX, ButtonPosY) = self.MiniMapShowButton.GetGlobalPosition()
        self.tooltipMiniMapOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)

        (ButtonPosX, ButtonPosY) = self.MiniMapHideButton.GetGlobalPosition()
        self.tooltipMiniMapClose.SetTooltipPosition(ButtonPosX, ButtonPosY)

        (ButtonPosX, ButtonPosY) = self.ScaleUpButton.GetGlobalPosition()
        self.tooltipScaleUp.SetTooltipPosition(ButtonPosX, ButtonPosY)

        (ButtonPosX, ButtonPosY) = self.ScaleDownButton.GetGlobalPosition()
        self.tooltipScaleDown.SetTooltipPosition(ButtonPosX, ButtonPosY)

        (ButtonPosX, ButtonPosY) = self.AtlasShowButton.GetGlobalPosition()
        self.tooltipAtlasOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)

        self.ShowMiniMap()

    def Destroy(self):
        self.HideMiniMap()

        self.AtlasWindow.Destroy()
        self.AtlasWindow = None

        self.ClearDictionary()

        self.__Initialize()

    def UpdateObserverCount(self, observerCount):
        if observerCount>0:
            self.observerCount.Show()
        elif observerCount<=0:
            self.observerCount.Hide()

        self.observerCount.SetText(localeInfo.MINIMAP_OBSERVER_COUNT % observerCount)
        
    def OnUpdate(self):
        (x, y, z) = player.GetMainCharacterPosition()
        miniMap.Update(x, y)

        self.positionInfo.SetText("(%.0f, %.0f)" % (x/100, y/100))

        if self.tooltipInfo:
            if True == self.MiniMapWindow.IsIn():
                (mouseX, mouseY) = wndMgr.GetMousePosition()
                (bFind, sName, iPosX, iPosY, dwTextColor) = miniMap.GetInfo(mouseX, mouseY)
                if bFind == 0:
                    self.tooltipInfo.Hide()
                elif not self.canSeeInfo:
                    self.tooltipInfo.SetText("%s(%s)" % (sName, localeInfo.UI_POS_UNKNOWN))
                    self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
                    self.tooltipInfo.SetTextColor(dwTextColor)
                    self.tooltipInfo.Show()
                else:
                    if localeInfo.IsARABIC() and sName[-1].isalnum():
                        self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
                    else:
                        self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))
                    self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
                    self.tooltipInfo.SetTextColor(dwTextColor)
                    self.tooltipInfo.Show()
            else:
                self.tooltipInfo.Hide()
            
            # AUTOBAN
            if self.imprisonmentDuration:
                self.__UpdateImprisonmentDurationText()                
            # END_OF_AUTOBAN

        if True == self.MiniMapShowButton.IsIn():
            self.tooltipMiniMapOpen.Show()
        else:
            self.tooltipMiniMapOpen.Hide()

        if True == self.MiniMapHideButton.IsIn():
            self.tooltipMiniMapClose.Show()
        else:
            self.tooltipMiniMapClose.Hide()

        if True == self.ScaleUpButton.IsIn():
            self.tooltipScaleUp.Show()
        else:
            self.tooltipScaleUp.Hide()

        if True == self.ScaleDownButton.IsIn():
            self.tooltipScaleDown.Show()
        else:
            self.tooltipScaleDown.Hide()

        if True == self.AtlasShowButton.IsIn():
            self.tooltipAtlasOpen.Show()
        else:
            self.tooltipAtlasOpen.Hide()

    def OnRender(self):
        (x, y) = self.GetGlobalPosition()
        fx = float(x)
        fy = float(y)
        miniMap.Render(fx + 4.0, fy + 5.0)

    def Close(self):
        self.HideMiniMap()

    def HideMiniMap(self):
        miniMap.Hide()
        self.OpenWindow.Hide()
        self.CloseWindow.Show()

    def ShowMiniMap(self):
        if not self.canSeeInfo:
            return

        miniMap.Show()
        self.OpenWindow.Show()
        self.CloseWindow.Hide()

    def isShowMiniMap(self):
        return miniMap.isShow()

    def ScaleUp(self):
        miniMap.ScaleUp()

    def ScaleDown(self):
        miniMap.ScaleDown()

    def ShowAtlas(self):
        if not miniMap.IsAtlas():
            return
        if not self.AtlasWindow.IsShow():
            self.AtlasWindow.Show()

    def ToggleAtlasWindow(self):
        if not miniMap.IsAtlas():
            return
        if self.AtlasWindow.IsShow():
            self.AtlasWindow.Hide()
        else:
            self.AtlasWindow.Show()

    def UpdateOnlinePlayerCount(self, playerCount):
        self.playerCount.SetText(localeInfo.PrettyNumber(playerCount) + " Online Oyuncu")

    def UpdateOnlineShopCount(self, shopCount):
        self.shopCount.SetText(localeInfo.PrettyNumber(shopCount) + " Online Tezgh")

 

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share



Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.