Posté le 25 novembre 2017
Télécharger | Reposter | Largeur fixe

import ui
import snd
import shop
import mouseModule
import player
import chr
import net
import uiCommon
import locale
import chat
import item

g_isBuildingPrivateShop = FALSE

g_itemPriceDict={}

def Clear():
         global g_itemPriceDict
         global g_isBuildingPrivateShop
         g_itemPriceDict={}
         g_isBuildingPrivateShop = FALSE

def IsPrivateShopItemPriceList():
         global g_itemPriceDict
         if g_itemPriceDict:
                  return TRUE
         else:
                  return FALSE

def IsBuildingPrivateShop():
         global g_isBuildingPrivateShop
         if player.IsOpenPrivateShop() or g_isBuildingPrivateShop:
                  return TRUE
         else:
                  return FALSE

def SetPrivateShopItemPrice(itemVNum, itemPrice):
         global g_itemPriceDict
         g_itemPriceDict[int(itemVNum)]=itemPrice
         
def GetPrivateShopItemPrice(itemVNum):
         try:
                  global g_itemPriceDict
                  return g_itemPriceDict[itemVNum]
         except KeyError:
                  return 0
                  

class PrivateShopAdvertisementBoard(ui.ThinBoard):
         def __init__(self):
                  ui.ThinBoard.__init__(self, "UI_BOTTOM")
                  self.shopAdvertismentBoardSeen = []

                  self.vid = None

                  self.__MakeTextLine()

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

         def __MakeTextLine(self):
                  self.textLine = ui.TextLine()
                  self.textLine.SetParent(self)
                  self.textLine.SetWindowHorizontalAlignCenter()
                  self.textLine.SetWindowVerticalAlignCenter()
                  self.textLine.SetHorizontalAlignCenter()
                  self.textLine.SetVerticalAlignCenter()
                  self.textLine.Show()

         def Open(self, vid, text):

                  self.vid = vid
                  self.textLine.SetText(text)
                  if vid in self.shopAdvertismentBoardSeen:
                                    self.textLine.SetFontColor(1.0, 0.5, 0.1)
                  self.textLine.UpdateRect()
                  self.SetSize(len(text)*6 + 10*2, 20)
                  self.Show()
                  g_privateShopAdvertisementBoardDict[vid] = self
                  
         def OnMouseLeftButtonUp(self):

                  if not self.vid:
                           return

                  net.SendOnClickPacket(self.vid)
                  if self.vid != player.GetMainCharacterIndex():
                                    self.textLine.SetFontColor(1.0, 0.5, 0.1)
                                    self.shopAdvertismentBoardSeen.append(self.vid)

                  return TRUE

         def OnUpdate(self):
                  if not self.vid:
                           return

                  x, y = chr.GetProjectPosition(self.vid, 220)
                  self.SetPosition(x - self.GetWidth()/2, y - self.GetHeight()/2)


class PrivateShopBuilder(ui.ScriptWindow):

         def __init__(self):
                  #print "NEW MAKE_PRIVATE_SHOP_WINDOW ----------------------------------------------------------------"
                  ui.ScriptWindow.__init__(self)

                  self.__LoadWindow()
                  self.itemStock = {}
                  self.tooltipItem = None
                  self.priceInputBoard = None
                  self.title = ""

         def __del__(self):
                  #print "------------------------------------------------------------- DELETE MAKE_PRIVATE_SHOP_WINDOW"
                  ui.ScriptWindow.__del__(self)

         def __LoadWindow(self):
                  try:
                           pyScrLoader = ui.PythonScriptLoader()
                           pyScrLoader.LoadScriptFile(self, "UIScript/PrivateShopBuilder.py")
                  except:
                           import exception
                           exception.Abort("PrivateShopBuilderWindow.LoadWindow.LoadObject")

                  try:
                           GetObject = self.GetChild
                           self.nameLine = GetObject("NameLine")
                           self.itemSlot = GetObject("ItemSlot")
                           self.btnOk = GetObject("OkButton")
                           self.btnClose = GetObject("CloseButton")
                           self.titleBar = GetObject("TitleBar")
                  except:
                           import exception
                           exception.Abort("PrivateShopBuilderWindow.LoadWindow.BindObject")

                  self.btnOk.SetEvent(ui.__mem_func__(self.OnOk))
                  self.btnClose.SetEvent(ui.__mem_func__(self.OnClose))
                  self.titleBar.SetCloseEvent(ui.__mem_func__(self.OnClose))

                  self.itemSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.OnSelectEmptySlot))
                  self.itemSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.OnSelectItemSlot))
                  self.itemSlot.SetOverInItemEvent(ui.__mem_func__(self.OnOverInItem))
                  self.itemSlot.SetOverOutItemEvent(ui.__mem_func__(self.OnOverOutItem))

         def Destroy(self):
                  self.ClearDictionary()

                  self.nameLine = None
                  self.itemSlot = None
                  self.btnOk = None
                  self.btnClose = None
                  self.titleBar = None
                  self.priceInputBoard = None

         def Open(self, title):

                  self.title = title

                  if len(title) > 25:
                           title = title[:22] + "..."

                  self.itemStock = {}
                  shop.ClearPrivateShopStock()
                  self.nameLine.SetText(title)
                  self.SetCenterPosition()
                  self.Refresh()
                  self.Show()

                  global g_isBuildingPrivateShop
                  g_isBuildingPrivateShop = TRUE

         def Close(self):
                  global g_isBuildingPrivateShop
                  g_isBuildingPrivateShop = FALSE

                  self.title = ""
                  self.itemStock = {}
                  shop.ClearPrivateShopStock()
                  self.Hide()

         def SetItemToolTip(self, tooltipItem):
                  self.tooltipItem = tooltipItem

         def Refresh(self):
                  getitemVNum=player.GetItemIndex
                  getItemCount=player.GetItemCount
                  setitemVNum=self.itemSlot.SetItemSlot
                  delItem=self.itemSlot.ClearSlot

                  for i in xrange(shop.SHOP_SLOT_COUNT):

                           if not self.itemStock.has_key(i):
                                    delItem(i)
                                    continue

                           pos = self.itemStock[i]

                           itemCount = getItemCount(pos)
                           if itemCount <= 1:
                                    itemCount = 0
                           setitemVNum(i, getitemVNum(pos), itemCount)

                  self.itemSlot.RefreshSlot()

         def OnSelectEmptySlot(self, selectedSlotPos):

                  isAttached = mouseModule.mouseController.isAttached()
                  if isAttached:
                           attachedSlotType = mouseModule.mouseController.GetAttachedType()
                           attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
                           mouseModule.mouseController.DeattachObject()

                           if player.SLOT_TYPE_INVENTORY != attachedSlotType:
                                    return

                           itemVNum = player.GetItemIndex(attachedSlotPos)
                           item.SelectItem(itemVNum)

                           if item.IsAntiFlag(item.ITEM_ANTIFLAG_GIVE) or item.IsAntiFlag(item.ITEM_ANTIFLAG_MYSHOP):
                                    chat.AppendChat(chat.CHAT_TYPE_INFO, locale.PRIVATE_SHOP_CANNOT_SELL_ITEM)
                                    return

                           priceInputBoard = uiCommon.MoneyInputDialog()
                           priceInputBoard.SetTitle(locale.PRIVATE_SHOP_INPUT_PRICE_DIALOG_TITLE)
                           priceInputBoard.SetAcceptEvent(ui.__mem_func__(self.AcceptInputPrice))
                           priceInputBoard.SetCancelEvent(ui.__mem_func__(self.CancelInputPrice))
                           priceInputBoard.Open()

                           itemPrice=GetPrivateShopItemPrice(itemVNum)

                           if itemPrice>0:
                                    priceInputBoard.SetValue(itemPrice)
                           
                           self.priceInputBoard = priceInputBoard
                           self.priceInputBoard.itemVNum = itemVNum
                           self.priceInputBoard.sourceSlotPos = attachedSlotPos
                           self.priceInputBoard.targetSlotPos = selectedSlotPos

         def OnSelectItemSlot(self, selectedSlotPos):

                  isAttached = mouseModule.mouseController.isAttached()
                  if isAttached:
                           snd.PlaySound("sound/ui/loginfail.wav")
                           mouseModule.mouseController.DeattachObject()

                  else:
                           if not selectedSlotPos in self.itemStock:
                                    return

                           inventoryPos = self.itemStock[selectedSlotPos]
                           shop.DelPrivateShopItemStock(inventoryPos)
                           snd.PlaySound("sound/ui/drop.wav")

                           del self.itemStock[selectedSlotPos]

                           self.Refresh()

         def AcceptInputPrice(self):

                  if not self.priceInputBoard:
                           return TRUE

                  text = self.priceInputBoard.GetText()

                  if not text:
                           return TRUE

                  if not text.isdigit():
                           return TRUE

                  if int(text) <= 0:
                           return TRUE

                  sourceSlotPos = self.priceInputBoard.sourceSlotPos
                  targetSlotPos = self.priceInputBoard.targetSlotPos

                  for privatePos, inventorySlotPos in self.itemStock.items():
                           if inventorySlotPos == sourceSlotPos:
                                    shop.DelPrivateShopItemStock(targetSlotPos)
                                    del self.itemStock[privatePos]

                  price = int(self.priceInputBoard.GetText())

                  if IsPrivateShopItemPriceList():
                           SetPrivateShopItemPrice(self.priceInputBoard.itemVNum, price)

                  shop.AddPrivateShopItemStock(sourceSlotPos, targetSlotPos, price)
                  self.itemStock[targetSlotPos] = sourceSlotPos
                  snd.PlaySound("sound/ui/drop.wav")

                  self.Refresh()                  

                  #####

                  self.priceInputBoard = None
                  return TRUE

         def CancelInputPrice(self):
                  self.priceInputBoard = None
                  return TRUE

         def OnOk(self):

                  if not self.title:
                           return

                  if 0 == len(self.itemStock):
                           return

                  shop.BuildPrivateShop(self.title)
                  self.Close()

         def OnClose(self):
                  self.Close()

         def OnPressEscapeKey(self):
                  self.Close()
                  return TRUE

         def OnOverInItem(self, slotIndex):

                  if self.tooltipItem:
                           if self.itemStock.has_key(slotIndex):
                                    self.tooltipItem.SetPrivateShopBuilderItem(self.itemStock[slotIndex], slotIndex)

         def OnOverOutItem(self):

                  if self.tooltipItem:
                           self.tooltipItem.HideToolTip()

x
Éditer le texte

Merci d'entrer le mot de passe que vous avez indiqué à la création du texte.

x
Télécharger le texte

Merci de choisir le format du fichier à télécharger.