API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 26th, 2020
364
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 63.34 KB | None | 0 0
raw download clone embed print report
  1. import uvvY2sBNvVcbJz4jvDr6fSWYdmqv9NPQ as pythonApi
  2. net = __import__(pythonApi.GetModuleName("net"))
  3. app = __import__(pythonApi.GetModuleName("app"))
  4. item = __import__(pythonApi.GetModuleName("item"))
  5. player = __import__(pythonApi.GetModuleName("player"))
  6. chat = __import__(pythonApi.GetModuleName("chat"))
  7. ime = __import__(pythonApi.GetModuleName("ime"))
  8. import ui
  9. import mouseModule
  10. import snd
  11. import grp
  12. import uiScriptLocale
  13. import uiRefine
  14. import uiAttachMetin
  15. import uiPickMoney
  16. import uiCommon
  17. import uiPrivateShopBuilder
  18. import localeInfo
  19. import constInfo
  20. import uiInventory
  21. import sys
  22.  
  23. ITEM_FLAG_APPLICABLE = 1 << 14
  24. GET_PAGE_INDEX = 0
  25. GET_DK_INDEX = 0
  26.  
  27. class DragonSoulWindow(ui.ScriptWindow):
  28. KIND_TAP_TITLES = [uiScriptLocale.DRAGONSOUL_TAP_TITLE_1, uiScriptLocale.DRAGONSOUL_TAP_TITLE_2,
  29. uiScriptLocale.DRAGONSOUL_TAP_TITLE_3, uiScriptLocale.DRAGONSOUL_TAP_TITLE_4, uiScriptLocale.DRAGONSOUL_TAP_TITLE_5, uiScriptLocale.DRAGONSOUL_TAP_TITLE_6]
  30.  
  31. def __init__(self):
  32. ui.ScriptWindow.__init__(self)
  33. self.questionDialog = None
  34. self.tooltipItem = None
  35. self.sellingSlotNumber = -1
  36. self.isLoaded = 0
  37. self.isActivated = False
  38. self.DSKindIndex = 0
  39. self.tabDict = None
  40. self.tabButtonDict = None
  41. self.deckPageIndex = 0
  42. self.inventoryPageIndex = 0
  43. self.SetWindowName("DragonSoulWindow")
  44. self.__LoadWindow()
  45.  
  46. def __del__(self):
  47. ui.ScriptWindow.__del__(self)
  48.  
  49. def Show(self):
  50. self.__LoadWindow()
  51. ui.ScriptWindow.Show(self)
  52.  
  53. def __LoadWindow(self):
  54. if self.isLoaded == 1:
  55. return
  56.  
  57. self.isLoaded = 1
  58. try:
  59. pyScrLoader = ui.PythonScriptLoader()
  60. pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "dragonsoulwindow.py")
  61.  
  62. except:
  63. import exception
  64. exception.Abort("dragonsoulwindow.LoadWindow.LoadObject")
  65. try:
  66. if localeInfo.IsARABIC():
  67. self.board = self.GetChild("Equipment_Base")
  68. self.board.SetScale(-1.0, 1.0)
  69. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  70. self.board = self.GetChild("Tab_01")
  71. self.board.SetScale(-1.0, 1.0)
  72. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  73. self.board = self.GetChild("Tab_02")
  74. self.board.SetScale(-1.0, 1.0)
  75. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  76. self.board = self.GetChild("Tab_03")
  77. self.board.SetScale(-1.0, 1.0)
  78. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  79. self.board = self.GetChild("Tab_04")
  80. self.board.SetScale(-1.0, 1.0)
  81. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  82. self.board = self.GetChild("Tab_05")
  83. self.board.SetScale(-1.0, 1.0)
  84. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  85. self.board = self.GetChild("Tab_06")
  86. self.board.SetScale(-1.0, 1.0)
  87. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  88.  
  89. wndItem = self.GetChild("ItemSlot")
  90. wndEquip = self.GetChild("EquipmentSlot")
  91.  
  92. self.activateButton = self.GetChild("activate")
  93. self.marketbutton = self.GetChild("market")
  94.  
  95. self.deckTab = []
  96. self.deckTab.append(self.GetChild("deck1"))
  97. self.deckTab.append(self.GetChild("deck2"))
  98. self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
  99.  
  100. self.inventoryTab = []
  101. self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
  102. self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
  103. self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))
  104. self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))
  105. self.inventoryTab.append(self.GetChild("Inventory_Tab_05"))
  106. self.inventoryTab.append(self.GetChild("Inventory_Tab_06"))
  107.  
  108. self.tabDict = {
  109. 0 : self.GetChild("Tab_01"),
  110. 1 : self.GetChild("Tab_02"),
  111. 2 : self.GetChild("Tab_03"),
  112. 3 : self.GetChild("Tab_04"),
  113. 4 : self.GetChild("Tab_05"),
  114. 5 : self.GetChild("Tab_06"),
  115. }
  116.  
  117. self.tabButtonDict = {
  118. 0 : self.GetChild("Tab_Button_01"),
  119. 1 : self.GetChild("Tab_Button_02"),
  120. 2 : self.GetChild("Tab_Button_03"),
  121. 3 : self.GetChild("Tab_Button_04"),
  122. 4 : self.GetChild("Tab_Button_05"),
  123. 5 : self.GetChild("Tab_Button_06"),
  124. }
  125.  
  126. self.tabText = self.GetChild("tab_text_area")
  127. self.hizliarindir = self.GetChild("hizliarindirac")
  128. self.btnChangeAttr = self.GetChild("btnChangeAttr")
  129. except:
  130. import exception
  131. exception.Abort("InventoryWindow.LoadWindow.BindObject")
  132.  
  133. ## DragonSoul Kind Tap
  134. for (tabKey, tabButton) in self.tabButtonDict.items():
  135. tabButton.SetEvent(ui.__mem_func__(self.SetDSKindIndex), tabKey)
  136.  
  137. ## Item
  138. wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
  139. wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
  140. wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
  141. wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
  142. wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
  143. wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
  144.  
  145. ## Equipment
  146. wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptyEquipSlot))
  147. wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectEquipItemSlot))
  148. wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseEquipItemSlot))
  149. wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseEquipItemSlot))
  150. wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInEquipItem))
  151. wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutEquipItem))
  152.  
  153. ## Deck
  154. self.deckTab[0].SetToggleDownEvent(lambda arg=0: self.SetDeckPage(arg))
  155. self.deckTab[1].SetToggleDownEvent(lambda arg=1: self.SetDeckPage(arg))
  156. self.deckTab[0].SetToggleUpEvent(lambda arg=0: self.__DeckButtonDown(arg))
  157. self.deckTab[1].SetToggleUpEvent(lambda arg=1: self.__DeckButtonDown(arg))
  158. self.deckTab[0].Down()
  159.  
  160. ## Grade button
  161. self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
  162. self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
  163. self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))
  164. self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))
  165. self.inventoryTab[4].SetEvent(lambda arg=4: self.SetInventoryPage(arg))
  166. self.inventoryTab[5].SetEvent(lambda arg=5: self.SetInventoryPage(arg))
  167. self.inventoryTab[0].Down()
  168.  
  169. ## Etc
  170. self.wndItem = wndItem
  171. self.wndEquip = wndEquip
  172.  
  173. self.dlgQuestion = uiCommon.QuestionDialog2()
  174. self.dlgQuestion.Close()
  175.  
  176. self.activateButton.SetToggleDownEvent(ui.__mem_func__(self.ActivateButtonClick))
  177. self.activateButton.SetToggleUpEvent(ui.__mem_func__(self.ActivateButtonClick))
  178.  
  179. self.marketbutton.SetEvent(self.MarketButtonClick)
  180.  
  181. self.wndPopupDialog = uiCommon.PopupDialog()
  182.  
  183. self.hizliarindir.SetEvent(ui.__mem_func__(self.hizliarindir2))
  184. self.btnChangeAttr.SetEvent(self.OnChangeAttr)
  185.  
  186. ##
  187. self.listHighlightedSlot = []
  188.  
  189. ## Refresh
  190. self.SetInventoryPage(0)
  191. self.RefreshItemSlot()
  192. self.RefreshEquipSlotWindow()
  193. self.RefreshBagSlotWindow()
  194. self.SetDSKindIndex(0)
  195. self.activateButton.Enable()
  196. self.deckTab[self.deckPageIndex].Down()
  197. self.activateButton.SetUp()
  198. def hizliarindir2(self):
  199. net.SendChatPacket("/arindirmaac")
  200.  
  201. def Destroy(self):
  202. self.ClearDictionary()
  203. self.tooltipItem = None
  204. self.wndItem = 0
  205. self.wndEquip = 0
  206. self.activateButton = 0
  207. self.questionDialog = None
  208. self.mallButton = None
  209. self.inventoryTab = []
  210. self.deckTab = []
  211. self.equipmentTab = []
  212. self.tabDict = None
  213. self.tabButtonDict = None
  214.  
  215. def Close(self):
  216. if None != self.tooltipItem:
  217. self.tooltipItem.HideToolTip()
  218.  
  219. self.Hide()
  220.  
  221. def __DeckButtonDown(self, deck):
  222. self.deckTab[deck].Down()
  223.  
  224. def SetInventoryPage(self, page):
  225. if self.inventoryPageIndex != page:
  226. self.__HighlightSlot_ClearCurrentPage()
  227.  
  228. self.inventoryPageIndex = page
  229. self.inventoryTab[(page+1)%6].SetUp()
  230. self.inventoryTab[(page+2)%6].SetUp()
  231. self.inventoryTab[(page+3)%6].SetUp()
  232. self.inventoryTab[(page+4)%6].SetUp()
  233. self.inventoryTab[(page+5)%6].SetUp()
  234. global GET_PAGE_INDEX
  235. GET_PAGE_INDEX = page
  236. self.RefreshBagSlotWindow()
  237.  
  238. def SetItemToolTip(self, tooltipItem):
  239. self.tooltipItem = tooltipItem
  240.  
  241. def RefreshItemSlot(self):
  242. self.RefreshBagSlotWindow()
  243. self.RefreshEquipSlotWindow()
  244.  
  245. def RefreshEquipSlotWindow(self):
  246. for i in xrange(6):
  247. slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
  248. itemVnum = player.GetItemIndex(slotNumber)
  249.  
  250. self.wndEquip.SetItemSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i, itemVnum, 0)
  251. self.wndEquip.EnableSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
  252.  
  253. if itemVnum != 0:
  254. item.SelectItem(itemVnum)
  255. for j in xrange(item.LIMIT_MAX_NUM):
  256. (limitType, limitValue) = item.GetLimit(j)
  257.  
  258. remain_time = 999
  259.  
  260. if item.LIMIT_REAL_TIME == limitType:
  261. remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) - app.GetGlobalTimeStamp()
  262. elif item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
  263. remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) - app.GetGlobalTimeStamp()
  264. elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
  265. remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0)
  266.  
  267. if remain_time <= 0:
  268. self.wndEquip.DisableSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
  269. break
  270.  
  271. self.wndEquip.RefreshSlot()
  272.  
  273. def OnChangeAttr(self):
  274. self.wndDragonSoulChangeAttr.Show()
  275.  
  276. def ActivateEquipSlotWindow(self, deck):
  277. for i in xrange(6):
  278. if deck == 2:
  279. plusCount = 6
  280. else:
  281. plusCount = 0
  282.  
  283. self.wndEquip.ActivateSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i + plusCount)
  284.  
  285. def DeactivateEquipSlotWindow(self):
  286. for i in xrange(12):
  287. self.wndEquip.DeactivateSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
  288.  
  289. def RefreshStatus(self):
  290. self.RefreshItemSlot()
  291.  
  292. def __InventoryLocalSlotPosToGlobalSlotPos(self, window_type, local_slot_pos):
  293. if player.INVENTORY == window_type:
  294. return self.deckPageIndex * player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE + local_slot_pos
  295.  
  296. return (self.DSKindIndex * 6 * player.DRAGON_SOUL_PAGE_SIZE) + self.inventoryPageIndex * player.DRAGON_SOUL_PAGE_SIZE + local_slot_pos
  297.  
  298. def __DragonSoulInventorySlotPos(self, local_slot_pos):
  299. return self.inventoryPageIndex * player.DRAGON_SOUL_PAGE_SIZE + local_slot_pos
  300.  
  301. def RefreshBagSlotWindow(self):
  302. getItemVNum=player.GetItemIndex
  303. getItemCount=player.GetItemCount
  304. setItemVnum=self.wndItem.SetItemSlot
  305. for i in xrange(player.DRAGON_SOUL_PAGE_SIZE):
  306. self.wndItem.EnableSlot(i)
  307. #<- dragon soul kind
  308. slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i)
  309.  
  310. itemCount = getItemCount(player.DRAGON_SOUL_INVENTORY, slotNumber)
  311. if 0 == itemCount:
  312. self.wndItem.ClearSlot(i)
  313. continue
  314. elif 1 == itemCount:
  315. itemCount = 0
  316.  
  317. itemVnum = getItemVNum(player.DRAGON_SOUL_INVENTORY, slotNumber)
  318.  
  319. setItemVnum(i, itemVnum, itemCount)
  320.  
  321. if itemVnum != 0:
  322. item.SelectItem(itemVnum)
  323. for j in xrange(item.LIMIT_MAX_NUM):
  324. (limitType, limitValue) = item.GetLimit(j)
  325.  
  326. remain_time = 999
  327. if item.LIMIT_REAL_TIME == limitType:
  328. remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0)
  329. elif item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
  330. remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0)
  331. elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
  332. remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0)
  333.  
  334. if remain_time <= 0:
  335. self.wndItem.DisableSlot(i)
  336. break
  337.  
  338. self.__HighlightSlot_RefreshCurrentPage()
  339. self.wndItem.RefreshSlot()
  340.  
  341. def ShowToolTip(self, window_type, slotIndex):
  342. if None != self.tooltipItem:
  343. if player.INVENTORY == window_type:
  344. self.tooltipItem.SetInventoryItem(slotIndex)
  345. else:
  346. self.tooltipItem.SetInventoryItem(slotIndex, player.DRAGON_SOUL_INVENTORY)
  347.  
  348. def OnPressEscapeKey(self):
  349. self.Close()
  350. return True
  351.  
  352. def OnTop(self):
  353. if None != self.tooltipItem:
  354. self.tooltipItem.SetTop()
  355.  
  356. def OverOutItem(self):
  357. self.wndItem.SetUsableItem(False)
  358. if None != self.tooltipItem:
  359. self.tooltipItem.HideToolTip()
  360.  
  361. def OverInItem(self, overSlotPos):
  362. self.wndItem.DeactivateSlot(overSlotPos)
  363. overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, overSlotPos)
  364.  
  365. try:
  366. self.listHighlightedSlot.remove(overSlotPos)
  367. except:
  368. pass
  369.  
  370. self.wndItem.SetUsableItem(False)
  371. self.ShowToolTip(player.DRAGON_SOUL_INVENTORY, overSlotPos)
  372.  
  373. def __UseItem(self, slotIndex):
  374. ItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotIndex)
  375. if 0 == player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotIndex, 0):
  376. self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_EXPIRED)
  377. self.wndPopupDialog.Open()
  378. return
  379.  
  380. self.__EquipItem(slotIndex)
  381.  
  382. def __EquipItem(self, slotIndex):
  383. ItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotIndex)
  384. item.SelectItem(ItemVNum)
  385. subType = item.GetItemSubType()
  386. equipSlotPos = player.DRAGON_SOUL_EQUIPMENT_SLOT_START + self.deckPageIndex * player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE + subType
  387. srcItemPos = (player.DRAGON_SOUL_INVENTORY, slotIndex)
  388. dstItemPos = (player.INVENTORY, equipSlotPos)
  389. self.__OpenQuestionDialog(True, srcItemPos, dstItemPos)
  390.  
  391. def SelectItemSlot(self, itemSlotIndex):
  392. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  393. return
  394.  
  395. itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
  396.  
  397. if mouseModule.mouseController.isAttached():
  398. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  399. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  400. attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()
  401.  
  402. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  403. if player.RESERVED_WINDOW != attachedInvenType:
  404. net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
  405.  
  406. mouseModule.mouseController.DeattachObject()
  407.  
  408. else:
  409. curCursorNum = app.GetCursor()
  410.  
  411. if app.SELL == curCursorNum:
  412. self.__SellItem(itemSlotIndex)
  413. elif app.BUY == curCursorNum:
  414. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
  415. elif app.IsPressed(app.DIK_LALT):
  416. link = player.GetItemLink(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
  417. ime.PasteString(link)
  418. else:
  419. selectedItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
  420. itemCount = player.GetItemCount(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
  421. mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_DRAGON_SOUL_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
  422. self.wndItem.SetUseMode(False)
  423. snd.PlaySound("sound/ui/pick.wav")
  424.  
  425. def __SellItem(self, itemSlotPos):
  426. if not player.IsDSEquipmentSlot(player.DRAGON_SOUL_INVENTORY, itemSlotPos):
  427. self.sellingSlotNumber = itemSlotPos
  428. itemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, itemSlotPos)
  429. itemCount = player.GetItemCount(player.DRAGON_SOUL_INVENTORY, itemSlotPos)
  430.  
  431. item.SelectItem(itemIndex)
  432.  
  433. if item.IsAntiFlag(item.ANTIFLAG_SELL):
  434. popup = uiCommon.PopupDialog()
  435. popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)
  436. popup.SetAcceptEvent(self.__OnClosePopupDialog)
  437. popup.Open()
  438. self.popup = popup
  439. return
  440.  
  441. itemPrice = item.GetISellItemPrice()
  442.  
  443. if item.Is1GoldItem():
  444. itemPrice = itemCount / itemPrice / 5
  445. else:
  446. itemPrice = itemPrice * itemCount / 5
  447.  
  448. item.GetItemName(itemIndex)
  449. itemName = item.GetItemName()
  450.  
  451. self.questionDialog = uiCommon.QuestionDialog()
  452. self.questionDialog.SetText(localeInfo.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
  453. self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
  454. self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
  455. self.questionDialog.Open()
  456. self.questionDialog.count = itemCount
  457.  
  458. def SellItem(self):
  459. #if app.ENABLE_SPECIAL_INVENTORY_SYSTEM:
  460. #net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count, player.DRAGON_SOUL_INVENTORY)
  461. #else:
  462. net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count)
  463.  
  464. snd.PlaySound("sound/ui/money.wav")
  465. self.OnCloseQuestionDialog()
  466.  
  467. def OnCloseQuestionDialog(self):
  468. if self.questionDialog:
  469. self.questionDialog.Close()
  470.  
  471. self.questionDialog = None
  472.  
  473. def __OnClosePopupDialog(self):
  474. self.pop = None
  475.  
  476. def SelectEmptySlot(self, selectedSlotPos):
  477. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  478. return
  479.  
  480. selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, selectedSlotPos)
  481. if mouseModule.mouseController.isAttached():
  482. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  483. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  484. attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
  485. attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
  486.  
  487. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  488. if player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:
  489. mouseModule.mouseController.RunCallBack("INVENTORY")
  490.  
  491. elif player.SLOT_TYPE_SHOP == attachedSlotType:
  492. net.SendShopBuyPacket(attachedSlotPos)
  493.  
  494. elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:
  495. if player.ITEM_MONEY == attachedItemIndex:
  496. net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
  497. snd.PlaySound("sound/ui/money.wav")
  498.  
  499. else:
  500. net.SendSafeboxCheckoutPacket(attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos)
  501.  
  502. elif player.SLOT_TYPE_MALL == attachedSlotType:
  503. net.SendMallCheckoutPacket(attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos)
  504.  
  505. elif player.RESERVED_WINDOW != attachedInvenType:
  506. if player.IsDSEquipmentSlot(attachedInvenType, attachedSlotPos):
  507. srcItemPos = (attachedInvenType, attachedSlotPos)
  508. dstItemPos = (player.DRAGON_SOUL_INVENTORY, selectedSlotPos)
  509. self.__OpenQuestionDialog(False, srcItemPos, dstItemPos)
  510. else:
  511. itemCount = player.GetItemCount(attachedInvenType, attachedSlotPos)
  512. attachedCount = mouseModule.mouseController.GetAttachedItemCount()
  513.  
  514. self.__SendMoveItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos, attachedCount)
  515.  
  516. mouseModule.mouseController.DeattachObject()
  517.  
  518. def UseItemSlot(self, slotIndex):
  519. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
  520. return
  521.  
  522. slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, slotIndex)
  523.  
  524. try:
  525. if self.wndDragonSoulRefine.IsShow():
  526. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  527. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  528. return
  529.  
  530. self.wndDragonSoulRefine.AutoSetItem((player.DRAGON_SOUL_INVENTORY, slotIndex), 1)
  531. return
  532. if self.wndDragonSoulChangeAttr.IsShow():
  533. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  534. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  535. return
  536. self.wndDragonSoulChangeAttr.AutoSetItem((player.DRAGON_SOUL_INVENTORY, slotIndex), 1)
  537. return
  538. except:
  539. pass
  540.  
  541. self.__UseItem(slotIndex)
  542.  
  543. mouseModule.mouseController.DeattachObject()
  544. self.OverOutItem()
  545.  
  546. ############################################################################################3
  547.  
  548. ############################################################################################
  549.  
  550. def __SendMoveItemPacket(self, srcSlotWindow, srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount):
  551. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  552. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  553. return
  554.  
  555. net.SendItemMovePacket(srcSlotWindow , srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount)
  556.  
  557. def OverOutEquipItem(self):
  558. self.OverOutItem()
  559.  
  560. def OverInEquipItem(self, overSlotPos):
  561. overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, overSlotPos)
  562. self.wndItem.SetUsableItem(False)
  563. self.ShowToolTip(player.INVENTORY, overSlotPos)
  564.  
  565. def UseEquipItemSlot(self, slotIndex):
  566. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
  567. return
  568.  
  569. slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, slotIndex)
  570.  
  571. self.__UseEquipItem(slotIndex)
  572. mouseModule.mouseController.DeattachObject()
  573. self.OverOutEquipItem()
  574.  
  575. def __UseEquipItem(self, slotIndex):
  576. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  577. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)
  578. return
  579.  
  580. self.__OpenQuestionDialog(False, (player.INVENTORY, slotIndex), (1, 1))
  581.  
  582. def SelectEquipItemSlot(self, itemSlotIndex):
  583. curCursorNum = app.GetCursor()
  584. if app.SELL == curCursorNum:
  585. return
  586. elif app.BUY == curCursorNum:
  587. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
  588. return
  589.  
  590. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  591. return
  592.  
  593. itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, itemSlotIndex)
  594.  
  595. if mouseModule.mouseController.isAttached():
  596. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  597. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  598.  
  599. if player.SLOT_TYPE_INVENTORY == attachedSlotType and itemSlotIndex == attachedSlotPos:
  600. return
  601.  
  602. attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()
  603.  
  604. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  605. if player.RESERVED_WINDOW != attachedInvenType:
  606. net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.INVENTORY, itemSlotIndex)
  607.  
  608. mouseModule.mouseController.DeattachObject()
  609. else:
  610. selectedItemVNum = player.GetItemIndex(player.INVENTORY, itemSlotIndex)
  611. itemCount = player.GetItemCount(player.INVENTORY, itemSlotIndex)
  612. mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
  613. self.wndItem.SetUseMode(False)
  614. snd.PlaySound("sound/ui/pick.wav")
  615.  
  616. def SelectEmptyEquipSlot(self, selectedSlot):
  617. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  618. return
  619.  
  620. selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, selectedSlot)
  621.  
  622. if mouseModule.mouseController.isAttached():
  623. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  624. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  625. attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
  626. attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
  627.  
  628. if player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType:
  629. if 0 == player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, attachedSlotPos, 0):
  630. self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_EXPIRED)
  631. self.wndPopupDialog.Open()
  632. return
  633.  
  634. item.SelectItem(attachedItemIndex)
  635. subType = item.GetItemSubType()
  636. if subType != (selectedSlot - player.DRAGON_SOUL_EQUIPMENT_SLOT_START):
  637. self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_UNMATCHED_SLOT)
  638. self.wndPopupDialog.Open()
  639. else:
  640. srcItemPos = (player.DRAGON_SOUL_INVENTORY, attachedSlotPos)
  641. dstItemPos = (player.INVENTORY, selectedSlotPos)
  642. self.__OpenQuestionDialog(True, srcItemPos, dstItemPos)
  643.  
  644. mouseModule.mouseController.DeattachObject()
  645.  
  646. def __OpenQuestionDialog(self, Equip, srcItemPos, dstItemPos):
  647. self.srcItemPos = srcItemPos
  648. self.dstItemPos = dstItemPos
  649.  
  650. self.dlgQuestion.SetAcceptEvent(ui.__mem_func__(self.__Accept))
  651. self.dlgQuestion.SetCancelEvent(ui.__mem_func__(self.__Cancel))
  652.  
  653. if Equip:
  654. self.dlgQuestion.SetText1(localeInfo.DRAGON_SOUL_EQUIP_WARNING1)
  655. self.dlgQuestion.SetText2(localeInfo.DRAGON_SOUL_EQUIP_WARNING2)
  656. else:
  657. self.dlgQuestion.SetText1(localeInfo.DRAGON_SOUL_UNEQUIP_WARNING1)
  658. self.dlgQuestion.SetText2(localeInfo.DRAGON_SOUL_UNEQUIP_WARNING2)
  659.  
  660. self.dlgQuestion.Open()
  661.  
  662. def __Accept(self):
  663. if (-1, -1) == self.dstItemPos:
  664. net.SendItemUsePacket(*self.srcItemPos)
  665. else:
  666. self.__SendMoveItemPacket(*(self.srcItemPos + self.dstItemPos + (0,)))
  667.  
  668. self.dlgQuestion.Close()
  669.  
  670. def __Cancel(self):
  671. self.srcItemPos = (0, 0)
  672. self.dstItemPos = (0, 0)
  673. self.dlgQuestion.Close()
  674.  
  675. def SetDSKindIndex(self, kindIndex):
  676. if self.DSKindIndex != kindIndex:
  677. self.__HighlightSlot_ClearCurrentPage()
  678.  
  679. self.DSKindIndex = kindIndex
  680.  
  681. for (tabKey, tabButton) in self.tabButtonDict.items():
  682. if kindIndex!=tabKey:
  683. tabButton.SetUp()
  684.  
  685. for tabValue in self.tabDict.itervalues():
  686. tabValue.Hide()
  687.  
  688. self.tabDict[kindIndex].Show()
  689. self.tabText.SetText(DragonSoulWindow.KIND_TAP_TITLES[kindIndex])
  690.  
  691. global GET_DK_INDEX
  692. GET_DK_INDEX = kindIndex
  693. self.RefreshBagSlotWindow()
  694.  
  695. def SetDeckPage(self, page):
  696. if page == self.deckPageIndex:
  697. return
  698.  
  699. if self.isActivated:
  700. self.DeactivateDragonSoul()
  701. net.SendChatPacket("/dragon_soul deactivate")
  702. self.deckPageIndex = page
  703. self.deckTab[page].Down()
  704. self.deckTab[(page+1)%2].SetUp()
  705.  
  706. self.RefreshEquipSlotWindow()
  707.  
  708. def ActivateDragonSoulByExtern(self, deck):
  709. self.ActivateEquipSlotWindow(deck)
  710. self.isActivated = True
  711. self.activateButton.Down()
  712. self.deckPageIndex = deck
  713. self.deckTab[deck].Down()
  714. self.deckTab[(deck+1)%2].SetUp()
  715. self.RefreshEquipSlotWindow()
  716.  
  717. def DeactivateDragonSoul(self):
  718. self.DeactivateEquipSlotWindow()
  719. self.isActivated = False
  720. self.activateButton.SetUp()
  721.  
  722. def ActivateButtonClick(self):
  723. self.isActivated = self.isActivated ^ True
  724. if self.isActivated:
  725. if self.__CanActivateDeck():
  726. net.SendChatPacket("/dragon_soul activate " + str(self.deckPageIndex))
  727. else:
  728. self.isActivated = False
  729. self.activateButton.SetUp()
  730. else:
  731. net.SendChatPacket("/dragon_soul deactivate")
  732.  
  733. def MarketButtonClick(self):
  734. net.SendChatPacket("/open_range_npc 14")
  735.  
  736. def __CanActivateDeck(self):
  737. canActiveNum = 0
  738. for i in xrange(6):
  739. slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
  740. itemVnum = player.GetItemIndex(slotNumber)
  741.  
  742. if itemVnum != 0:
  743. item.SelectItem(itemVnum)
  744. isNoLimit = True
  745. for i in xrange(item.LIMIT_MAX_NUM):
  746. (limitType, limitValue) = item.GetLimit(i)
  747.  
  748. if item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
  749. isNoLimit = False
  750. remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0)
  751. if 0 != remain_time:
  752. canActiveNum += 1
  753. break
  754.  
  755. if isNoLimit:
  756. canActiveNum += 1
  757.  
  758. return canActiveNum > 0
  759.  
  760. def __HighlightSlot_ClearCurrentPage(self):
  761. for i in xrange(self.wndItem.GetSlotCount()):
  762. slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i)
  763. if slotNumber in self.listHighlightedSlot:
  764. self.wndItem.DeactivateSlot(i)
  765. self.listHighlightedSlot.remove(slotNumber)
  766.  
  767. def __HighlightSlot_RefreshCurrentPage(self):
  768. for i in xrange(self.wndItem.GetSlotCount()):
  769. slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i)
  770. if slotNumber in self.listHighlightedSlot:
  771. self.wndItem.ActivateSlot(i)
  772.  
  773. def HighlightSlot(self, slot):
  774. if not slot in self.listHighlightedSlot:
  775. self.listHighlightedSlot.append (slot)
  776.  
  777. def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):
  778. if app.ENABLE_DRAGON_SOUL_SYSTEM:
  779. from _weakref import proxy
  780. self.wndDragonSoulRefine = proxy(wndDragonSoulRefine)
  781.  
  782. def SetDragonSoulChangeAttrWindow(self, wndDragonSoulChangeAttr):
  783. from _weakref import proxy
  784. self.wndDragonSoulChangeAttr = proxy(wndDragonSoulChangeAttr)
  785.  
  786. class DragonSoulRefineWindow(ui.ScriptWindow):
  787. REFINE_TYPE_GRADE, REFINE_TYPE_STEP, REFINE_TYPE_STRENGTH = xrange(3)
  788.  
  789. DS_SUB_HEADER_DIC = {
  790. REFINE_TYPE_GRADE : player.DS_SUB_HEADER_DO_UPGRADE,
  791. REFINE_TYPE_STEP : player.DS_SUB_HEADER_DO_IMPROVEMENT,
  792. REFINE_TYPE_STRENGTH : player.DS_SUB_HEADER_DO_REFINE
  793. }
  794.  
  795. REFINE_STONE_SLOT, DRAGON_SOUL_SLOT = xrange(2)
  796.  
  797. INVALID_DRAGON_SOUL_INFO = -1
  798.  
  799. def __init__(self):
  800. ui.ScriptWindow.__init__(self)
  801. self.tooltipItem = None
  802. self.sellingSlotNumber = -1
  803. self.isLoaded = 0
  804. self.refineChoiceButtonDict = None
  805. self.doRefineButton = None
  806. self.BeansInvenType = 0
  807. self.BeansInvenPos = 0
  808. self.doAllRefineButton = None
  809. self.wndMoney = None
  810.  
  811. self.bAutoRefine = False
  812. self.autoRefineCount = 0
  813. self.autoRefineTime = 0.0
  814. self.SetWindowName("DragonSoulRefineWindow")
  815. self.__LoadWindow()
  816.  
  817. def __del__(self):
  818. ui.ScriptWindow.__del__(self)
  819.  
  820. def Show(self):
  821. self.__LoadWindow()
  822. ui.ScriptWindow.Show(self)
  823.  
  824. def __LoadWindow(self):
  825. if self.isLoaded == 1:
  826. return
  827.  
  828. self.isLoaded = 1
  829.  
  830. try:
  831. pyScrLoader = ui.PythonScriptLoader()
  832. pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "dragonsoulrefinewindow.py")
  833.  
  834. except:
  835. import exception
  836. exception.Abort("dragonsoulrefinewindow.LoadWindow.LoadObject")
  837. try:
  838. if localeInfo.IsARABIC():
  839. self.board = self.GetChild("DragonSoulRefineWindowBaseImage")
  840. self.board.SetScale(-1.0, 1.0)
  841. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  842.  
  843. wndRefineSlot = self.GetChild("RefineSlot")
  844. wndResultSlot = self.GetChild("ResultSlot")
  845. self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
  846.  
  847. self.refineChoiceButtonDict = {
  848. self.REFINE_TYPE_GRADE : self.GetChild("GradeButton"),
  849. self.REFINE_TYPE_STEP: self.GetChild("StepButton"),
  850. self.REFINE_TYPE_STRENGTH : self.GetChild("StrengthButton"),
  851. }
  852.  
  853. self.doRefineButton = self.GetChild("DoRefineButton")
  854. self.doAllRefineButton = self.GetChild("DoAllRefineButton")
  855. self.wndMoney = self.GetChild("Money_Slot")
  856.  
  857. except:
  858. import exception
  859. exception.Abort("DragonSoulRefineWindow.LoadWindow.BindObject")
  860.  
  861. ## Item Slots
  862. wndRefineSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInRefineItem))
  863. wndRefineSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem))
  864. wndRefineSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.__SelectRefineEmptySlot))
  865. wndRefineSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
  866. wndRefineSlot.SetUseSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
  867. wndRefineSlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
  868.  
  869. wndResultSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInResultItem))
  870. wndResultSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem))
  871. self.wndRefineSlot = wndRefineSlot
  872. self.wndResultSlot = wndResultSlot
  873.  
  874. ## Button
  875. self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].SetToggleDownEvent(self.__ToggleDownGradeButton)
  876. self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetToggleDownEvent(self.__ToggleDownStepButton)
  877. self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetToggleDownEvent(self.__ToggleDownStrengthButton)
  878. self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_GRADE))
  879. self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_STEP))
  880. self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_STRENGTH))
  881.  
  882. self.doRefineButton.SetEvent(self.__PressDoRefineButton)
  883. self.doAllRefineButton.SetEvent(self.__PressDoAllRefineButton)
  884.  
  885. ## Dialog
  886. self.wndPopupDialog = uiCommon.PopupDialog()
  887.  
  888. self.currentRefineType = self.REFINE_TYPE_GRADE
  889. self.refineItemInfo = {}
  890. self.resultItemInfo = {}
  891. self.currentRecipe = {}
  892.  
  893. self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
  894. self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].Down()
  895.  
  896. self.__Initialize()
  897.  
  898. def Destroy(self):
  899. self.ClearDictionary()
  900. self.tooltipItem = None
  901. self.wndItem = 0
  902. self.wndEquip = 0
  903. self.activateButton = 0
  904. self.questionDialog = None
  905. self.mallButton = None
  906. self.inventoryTab = []
  907. self.deckTab = []
  908. self.equipmentTab = []
  909. self.tabDict = None
  910. self.tabButtonDict = None
  911.  
  912. def Close(self):
  913. if None != self.tooltipItem:
  914. self.tooltipItem.HideToolTip()
  915.  
  916. self.__FlushRefineItemSlot()
  917. player.SendDragonSoulRefine(player.DRAGON_SOUL_REFINE_CLOSE)
  918. self.Hide()
  919.  
  920. def Show(self):
  921. self.currentRefineType = self.REFINE_TYPE_GRADE
  922. self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
  923. self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].Down()
  924. self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetUp()
  925. self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetUp()
  926.  
  927. self.Refresh()
  928.  
  929. ui.ScriptWindow.Show(self)
  930.  
  931. def SetItemToolTip(self, tooltipItem):
  932. self.tooltipItem = tooltipItem
  933.  
  934. def __Initialize(self):
  935. self.currentRecipe = {}
  936. self.refineItemInfo = {}
  937. self.resultItemInfo = {}
  938.  
  939. if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  940. self.refineSlotLockStartIndex = 2
  941. else:
  942. self.refineSlotLockStartIndex = 1
  943.  
  944. for i in xrange(self.refineSlotLockStartIndex):
  945. self.wndRefineSlot.HideSlotBaseImage(i)
  946.  
  947. self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
  948.  
  949. def __FlushRefineItemSlot(self):
  950. for invenType, invenPos, itemCount in self.refineItemInfo.values():
  951. remainCount = player.GetItemCount(invenType, invenPos)
  952. player.SetItemCount(invenType, invenPos, remainCount + itemCount)
  953.  
  954. self.__Initialize()
  955.  
  956. def __ToggleUpButton(self, idx):
  957. self.refineChoiceButtonDict[idx].Down()
  958.  
  959. def __ToggleDownGradeButton(self):
  960. if self.REFINE_TYPE_GRADE == self.currentRefineType:
  961. return
  962.  
  963. self.refineChoiceButtonDict[self.currentRefineType].SetUp()
  964. self.currentRefineType = self.REFINE_TYPE_GRADE
  965. self.__FlushRefineItemSlot()
  966. self.Refresh()
  967.  
  968. def __ToggleDownStepButton(self):
  969. if self.REFINE_TYPE_STEP == self.currentRefineType:
  970. return
  971.  
  972. self.refineChoiceButtonDict[self.currentRefineType].SetUp()
  973. self.currentRefineType = self.REFINE_TYPE_STEP
  974. self.__FlushRefineItemSlot()
  975. self.Refresh()
  976.  
  977. def __ToggleDownStrengthButton(self):
  978. if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  979. return
  980.  
  981. self.refineChoiceButtonDict[self.currentRefineType].SetUp()
  982. self.currentRefineType = self.REFINE_TYPE_STRENGTH
  983. self.__FlushRefineItemSlot()
  984. self.Refresh()
  985.  
  986. def __PopUp(self, message):
  987. self.wndPopupDialog.SetText(message)
  988. self.wndPopupDialog.Open()
  989.  
  990. def __SetItem(self, inven, dstSlotIndex, itemCount):
  991. invenType, invenPos = inven
  992.  
  993. if dstSlotIndex >= self.refineSlotLockStartIndex:
  994. return False
  995.  
  996. itemVnum = player.GetItemIndex(invenType, invenPos)
  997. maxCount = player.GetItemCount(invenType, invenPos)
  998.  
  999. if itemCount > maxCount:
  1000. # return False
  1001. raise Exception, ("Invalid attachedItemCount(%d). (base pos (%d, %d), base itemCount(%d))" % (itemCount, invenType, invenPos, maxCount))
  1002.  
  1003. if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1004. if self.__IsDragonSoul(itemVnum):
  1005. dstSlotIndex = 1
  1006. else:
  1007. dstSlotIndex = 0
  1008.  
  1009. if dstSlotIndex in self.refineItemInfo:
  1010. return False
  1011.  
  1012. if False == self.__CheckCanRefine(itemVnum):
  1013. return False
  1014.  
  1015. player.SetItemCount(invenType, invenPos, maxCount - itemCount)
  1016. self.refineItemInfo[dstSlotIndex] = (invenType, invenPos, itemCount)
  1017. self.Refresh()
  1018.  
  1019. return True
  1020.  
  1021. def __CheckCanRefine(self, vnum):
  1022. if self.REFINE_TYPE_GRADE == self.currentRefineType:
  1023. return self.__CanRefineGrade(vnum)
  1024.  
  1025. elif self.REFINE_TYPE_STEP == self.currentRefineType:
  1026. return self.__CanRefineStep(vnum)
  1027.  
  1028. elif self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1029. return self.__CanRefineStrength(vnum)
  1030.  
  1031. else:
  1032. return False
  1033.  
  1034. def __CanRefineGrade (self, vnum):
  1035. ds_info = self.__GetDragonSoulTypeInfo(vnum)
  1036.  
  1037. if DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO == ds_info:
  1038. self.__PopUp(localeInfo.DRAGON_SOUL_IS_NOT_DRAGON_SOUL)
  1039. return False
  1040.  
  1041. if self.currentRecipe:
  1042. ds_type, grade, step, strength = ds_info
  1043. cur_refine_ds_type, cur_refine_grade, cur_refine_step, cur_refine_strength = self.currentRecipe["ds_info"]
  1044.  
  1045. if not (cur_refine_ds_type == ds_type and cur_refine_grade == grade):
  1046. self.__PopUp(localeInfo.DRAGON_SOUL_INVALID_DRAGON_SOUL)
  1047. return False
  1048.  
  1049. else:
  1050. self.currentRecipe = self.__GetRefineGradeRecipe(vnum)
  1051.  
  1052. if self.currentRecipe:
  1053. self.refineSlotLockStartIndex = self.currentRecipe["need_count"]
  1054. self.wndMoney.SetText(localeInfo.NumberToMoneyString(self.currentRecipe["fee"]))
  1055. return True
  1056. else:
  1057. self.__PopUp(localeInfo.DRAGON_SOUL_CANNOT_REFINE)
  1058. return False
  1059.  
  1060. def __CanRefineStep (self, vnum):
  1061. ds_info = self.__GetDragonSoulTypeInfo(vnum)
  1062.  
  1063. if DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO == ds_info:
  1064. self.__PopUp(localeInfo.DRAGON_SOUL_IS_NOT_DRAGON_SOUL)
  1065. return False
  1066.  
  1067. if self.currentRecipe:
  1068. ds_type, grade, step, strength = ds_info
  1069. cur_refine_ds_type, cur_refine_grade, cur_refine_step, cur_refine_strength = self.currentRecipe["ds_info"]
  1070. if not (cur_refine_ds_type == ds_type and cur_refine_grade == grade and cur_refine_step == step):
  1071. self.__PopUp(localeInfo.DRAGON_SOUL_INVALID_DRAGON_SOUL)
  1072. return False
  1073. else:
  1074. self.currentRecipe = self.__GetRefineStepRecipe(vnum)
  1075.  
  1076. if self.currentRecipe:
  1077. self.refineSlotLockStartIndex = self.currentRecipe["need_count"]
  1078. self.wndMoney.SetText(localeInfo.NumberToMoneyString(self.currentRecipe["fee"]))
  1079. return True
  1080. else:
  1081. self.__PopUp(localeInfo.DRAGON_SOUL_CANNOT_REFINE)
  1082. return False
  1083.  
  1084. def __CanRefineStrength (self, vnum):
  1085. if self.__IsDragonSoul(vnum):
  1086. ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)
  1087.  
  1088. import dragon_soul_refine_settings
  1089. if strength >= dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["strength_max_table"][grade][step]:
  1090. self.__PopUp(localeInfo.DRAGON_SOUL_CANNOT_REFINE_MORE)
  1091. return False
  1092.  
  1093. else:
  1094. return True
  1095.  
  1096. else:
  1097. if self.currentRecipe:
  1098. self.__PopUp(localeInfo.DRAGON_SOUL_IS_NOT_DRAGON_SOUL)
  1099. return False
  1100. else:
  1101. refineRecipe = self.__GetRefineStrengthInfo(vnum)
  1102. if refineRecipe:
  1103. self.currentRecipe = refineRecipe
  1104. self.wndMoney.SetText(localeInfo.NumberToMoneyString(self.currentRecipe["fee"]))
  1105. return True
  1106. else:
  1107. self.__PopUp(localeInfo.DRAGON_SOUL_NOT_DRAGON_SOUL_REFINE_STONE)
  1108. return False
  1109.  
  1110. def __GetRefineGradeRecipe (self, vnum):
  1111. ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)
  1112. try:
  1113. import dragon_soul_refine_settings
  1114.  
  1115. return {
  1116. "ds_info" : (ds_type, grade, step, strength),
  1117. "need_count" : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["grade_need_count"][grade],
  1118. "fee" : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["grade_fee"][grade]
  1119. }
  1120. except:
  1121. return None
  1122.  
  1123. def __GetRefineStepRecipe (self, vnum):
  1124. ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)
  1125. try:
  1126. import dragon_soul_refine_settings
  1127.  
  1128. return {
  1129. "ds_info" : (ds_type, grade, step, strength),
  1130. "need_count" : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["step_need_count"][step],
  1131. "fee" : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["step_fee"][step]
  1132. }
  1133. except:
  1134. return None
  1135.  
  1136. def __GetRefineStrengthInfo (self, itemVnum):
  1137. try:
  1138. item.SelectItem(itemVnum)
  1139. if not (item.ITEM_TYPE_MATERIAL == item.GetItemType() \
  1140. and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)):
  1141. return None
  1142.  
  1143. import dragon_soul_refine_settings
  1144. return { "fee" : dragon_soul_refine_settings.strength_fee[item.GetItemSubType()] }
  1145. except:
  1146. return None
  1147.  
  1148. def __IsDragonSoul(self, vnum):
  1149. item.SelectItem(vnum)
  1150. return item.GetItemType() == item.ITEM_TYPE_DS
  1151.  
  1152. def __GetDragonSoulTypeInfo(self, vnum):
  1153. if not self.__IsDragonSoul(vnum):
  1154. return DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO
  1155.  
  1156. ds_type = vnum / 10000
  1157. grade = vnum % 10000 /1000
  1158. step = vnum % 1000 / 100
  1159. strength = vnum % 100 / 10
  1160.  
  1161. return (ds_type, grade, step, strength)
  1162.  
  1163. def __MakeDragonSoulVnum(self, ds_type, grade, step, strength):
  1164. return ds_type * 10000 + grade * 1000 + step * 100 + strength * 10
  1165.  
  1166. def __SelectRefineEmptySlot(self, selectedSlotPos):
  1167. try:
  1168. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  1169. return
  1170.  
  1171. if selectedSlotPos >= self.refineSlotLockStartIndex:
  1172. return
  1173.  
  1174. if mouseModule.mouseController.isAttached():
  1175. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  1176. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  1177. attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
  1178. attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
  1179. mouseModule.mouseController.DeattachObject()
  1180.  
  1181. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  1182. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  1183. return
  1184.  
  1185. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  1186.  
  1187. if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos):
  1188. return
  1189.  
  1190. if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType:
  1191. return
  1192.  
  1193. if True == self.__SetItem((attachedInvenType, attachedSlotPos), selectedSlotPos, attachedItemCount):
  1194. self.Refresh()
  1195.  
  1196. except Exception, e:
  1197. import dbg
  1198. dbg.TraceError("Exception : __SelectRefineEmptySlot, %s" % e)
  1199.  
  1200. def __SelectRefineItemSlot(self, selectedSlotPos):
  1201. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  1202. return
  1203.  
  1204. try:
  1205. if not selectedSlotPos in self.refineItemInfo:
  1206. if mouseModule.mouseController.isAttached():
  1207. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  1208. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  1209. attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
  1210. attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
  1211. mouseModule.mouseController.DeattachObject()
  1212.  
  1213. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  1214. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  1215. return
  1216.  
  1217. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  1218.  
  1219. if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos):
  1220. return
  1221.  
  1222. if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType:
  1223. return
  1224.  
  1225. self.AutoSetItem((attachedInvenType, attachedSlotPos), 1)
  1226. return
  1227. elif mouseModule.mouseController.isAttached():
  1228. return
  1229.  
  1230. attachedInvenType, attachedSlotPos, attachedItemCount = self.refineItemInfo[selectedSlotPos]
  1231. selectedItemVnum = player.GetItemIndex(attachedInvenType, attachedSlotPos)
  1232.  
  1233. invenType, invenPos, itemCount = self.refineItemInfo[selectedSlotPos]
  1234. remainCount = player.GetItemCount(invenType, invenPos)
  1235. player.SetItemCount(invenType, invenPos, remainCount + itemCount)
  1236. del self.refineItemInfo[selectedSlotPos]
  1237.  
  1238. if not self.refineItemInfo:
  1239. self.__Initialize()
  1240. else:
  1241. item.SelectItem(selectedItemVnum)
  1242.  
  1243. if (item.ITEM_TYPE_MATERIAL == item.GetItemType() \
  1244. and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)):
  1245. self.currentRecipe = {}
  1246. self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
  1247. else:
  1248. pass
  1249.  
  1250. except Exception, e:
  1251. import dbg
  1252. dbg.TraceError("Exception : __SelectRefineItemSlot, %s" % e)
  1253.  
  1254. self.Refresh()
  1255.  
  1256. def __OverInRefineItem(self, slotIndex):
  1257. if self.refineItemInfo.has_key(slotIndex):
  1258. inven_type, inven_pos, item_count = self.refineItemInfo[slotIndex]
  1259. self.tooltipItem.SetInventoryItem(inven_pos, inven_type)
  1260.  
  1261. def __OverInResultItem(self, slotIndex):
  1262. if self.resultItemInfo.has_key(slotIndex):
  1263. inven_type, inven_pos, item_count = self.resultItemInfo[slotIndex]
  1264. self.tooltipItem.SetInventoryItem(inven_pos, inven_type)
  1265.  
  1266. def __OverOutItem(self):
  1267. if self.tooltipItem:
  1268. self.tooltipItem.HideToolTip()
  1269.  
  1270. def __PressDoRefineButton(self):
  1271. for i in xrange(self.refineSlotLockStartIndex):
  1272. if not i in self.refineItemInfo:
  1273. self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_NOT_ENOUGH_MATERIAL)
  1274. self.wndPopupDialog.Open()
  1275.  
  1276. return
  1277.  
  1278. player.SendDragonSoulRefine(DragonSoulRefineWindow.DS_SUB_HEADER_DIC[self.currentRefineType], self.refineItemInfo)
  1279.  
  1280. def __GetItemPos(self, local_slot_pos):
  1281. global GET_DK_INDEX
  1282. global GET_PAGE_INDEX
  1283. return (GET_DK_INDEX * 6 * player.DRAGON_SOUL_PAGE_SIZE) + GET_PAGE_INDEX * player.DRAGON_SOUL_PAGE_SIZE + local_slot_pos
  1284.  
  1285. def __PressDoAllRefineButton(self):
  1286. self.bAutoRefine = True
  1287. self.autoRefineTime = float(app.GetTime())
  1288. self.autoRefineCount = 0
  1289.  
  1290. def OnUpdate(self):
  1291. if self.bAutoRefine is False:
  1292. return
  1293.  
  1294. if self.autoRefineTime + 0.2 > float(app.GetTime()):
  1295. return
  1296.  
  1297. if self.autoRefineCount > 16:
  1298. return
  1299.  
  1300. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  1301. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  1302. self.bAutoRefine = False
  1303. return
  1304.  
  1305. add_item = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0}
  1306. #add_item = {0:0, 1:0}
  1307. num = 0
  1308.  
  1309. for i in xrange(33):
  1310. if i == 32:
  1311. self.bAutoRefine = False
  1312. break
  1313.  
  1314. slotNumber = self.__GetItemPos(i)
  1315. itemVnum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotNumber)
  1316.  
  1317. if ((add_item[0] == 1) and (add_item[1] == 1)):
  1318. break
  1319.  
  1320. if not itemVnum:
  1321. continue
  1322.  
  1323. add_item[num] = 1
  1324. num += 1
  1325. self.AutoSetItem((player.DRAGON_SOUL_INVENTORY, slotNumber), 1)
  1326.  
  1327. player.SendDragonSoulRefine(DragonSoulRefineWindow.DS_SUB_HEADER_DIC[self.currentRefineType], self.refineItemInfo)
  1328. add_item = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0}
  1329. #add_item = {0:0, 1:0}
  1330. num = 0
  1331. self.autoRefineCount += 1
  1332. self.autoRefineTime = float(app.GetTime())
  1333.  
  1334. def OnPressEscapeKey(self):
  1335. self.Close()
  1336. return True
  1337.  
  1338. def Refresh(self):
  1339. self.__RefreshRefineItemSlot()
  1340. self.__ClearResultItemSlot()
  1341.  
  1342. def __RefreshRefineItemSlot(self):
  1343. try:
  1344. for slotPos in xrange(self.wndRefineSlot.GetSlotCount()):
  1345. self.wndRefineSlot.ClearSlot(slotPos)
  1346. if slotPos < self.refineSlotLockStartIndex:
  1347. if slotPos in self.refineItemInfo:
  1348. invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
  1349. itemVnum = player.GetItemIndex(invenType, invenPos)
  1350.  
  1351. if itemVnum:
  1352. self.wndRefineSlot.SetItemSlot(slotPos, player.GetItemIndex(invenType, invenPos), itemCount)
  1353. else:
  1354. del self.refineItemInfo[slotPos]
  1355.  
  1356. if not slotPos in self.refineItemInfo:
  1357. try:
  1358. reference_vnum = 0
  1359.  
  1360. if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1361. if DragonSoulRefineWindow.REFINE_STONE_SLOT == slotPos:
  1362. reference_vnum = 100300
  1363. else:
  1364. reference_vnum = self.__MakeDragonSoulVnum(*self.currentRecipe["ds_info"])
  1365.  
  1366. if 0 != reference_vnum:
  1367. item.SelectItem(reference_vnum)
  1368. itemIcon = item.GetIconImage()
  1369. (width, height) = item.GetItemSize()
  1370. self.wndRefineSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
  1371. self.wndRefineSlot.SetSlotCount(slotPos, 0)
  1372. except:
  1373. pass
  1374.  
  1375. self.wndRefineSlot.HideSlotBaseImage(slotPos)
  1376. else:
  1377. if slotPos in self.refineItemInfo:
  1378. invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
  1379. remainCount = player.GetItemCount(invenType, invenPos)
  1380. player.SetItemCount(invenType, invenPos, remainCount + itemCount)
  1381. del self.refineItemInfo[slotPos]
  1382.  
  1383. self.wndRefineSlot.ShowSlotBaseImage(slotPos)
  1384.  
  1385. if not self.refineItemInfo:
  1386. self.__Initialize()
  1387.  
  1388. self.wndRefineSlot.RefreshSlot()
  1389.  
  1390. except Exception, e:
  1391. import dbg
  1392. dbg.TraceError("Exception : __RefreshRefineItemSlot, %s" % e)
  1393.  
  1394. def __GetEmptySlot(self, itemVnum = 0):
  1395. if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1396. if 0 == itemVnum:
  1397. return -1
  1398.  
  1399. if self.__IsDragonSoul(itemVnum):
  1400. if not DragonSoulRefineWindow.DRAGON_SOUL_SLOT in self.refineItemInfo:
  1401. return DragonSoulRefineWindow.DRAGON_SOUL_SLOT
  1402. else:
  1403. if not DragonSoulRefineWindow.REFINE_STONE_SLOT in self.refineItemInfo:
  1404. return DragonSoulRefineWindow.REFINE_STONE_SLOT
  1405. else:
  1406. for slotPos in xrange(self.wndRefineSlot.GetSlotCount()):
  1407. if not slotPos in self.refineItemInfo:
  1408. return slotPos
  1409.  
  1410. return -1
  1411.  
  1412. def AutoSetItem(self, inven, itemCount):
  1413. invenType, invenPos = inven
  1414. itemVnum = player.GetItemIndex(invenType, invenPos)
  1415. emptySlot = self.__GetEmptySlot(itemVnum)
  1416.  
  1417. if -1 == emptySlot:
  1418. return
  1419.  
  1420. if invenType == player.INVENTORY:
  1421. self.BeansInvenType = invenType
  1422. self.BeansInvenPos = invenPos
  1423.  
  1424. self.__SetItem((invenType, invenPos), emptySlot, itemCount)
  1425.  
  1426. def __ClearResultItemSlot(self):
  1427. self.wndResultSlot.ClearSlot(0)
  1428. self.resultItemInfo = {}
  1429.  
  1430. def RefreshBeans(self):
  1431. if self.BeansInvenType == player.INVENTORY:
  1432. itemCount = player.GetItemCount(player.INVENTORY, self.BeansInvenPos)
  1433. if itemCount > 0:
  1434. self.AutoSetItem((self.BeansInvenType, self.BeansInvenPos), itemCount)
  1435.  
  1436. def RefineSucceed(self, inven_type, inven_pos):
  1437. self.__Initialize()
  1438. self.Refresh()
  1439.  
  1440. if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1441. self.RefreshBeans()
  1442.  
  1443. itemCount = player.GetItemCount(inven_type, inven_pos)
  1444. if itemCount > 0:
  1445. self.resultItemInfo[0] = (inven_type, inven_pos, itemCount)
  1446. self.wndResultSlot.SetItemSlot(0, player.GetItemIndex(inven_type, inven_pos), itemCount)
  1447.  
  1448. if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1449. self.AutoSetItem((inven_type, inven_pos), itemCount)
  1450.  
  1451. def RefineFail(self, reason, inven_type, inven_pos):
  1452. if net.DS_SUB_HEADER_REFINE_FAIL == reason:
  1453. self.__Initialize()
  1454. self.Refresh()
  1455.  
  1456. if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1457. self.RefreshBeans()
  1458.  
  1459. itemCount = player.GetItemCount(inven_type, inven_pos)
  1460. if itemCount > 0:
  1461. self.resultItemInfo[0] = (inven_type, inven_pos, itemCount)
  1462. self.wndResultSlot.SetItemSlot(0, player.GetItemIndex(inven_type, inven_pos), itemCount)
  1463.  
  1464. if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
  1465. self.AutoSetItem((inven_type, inven_pos), itemCount)
  1466. else:
  1467. self.Refresh()
  1468.  
  1469. def SetInventoryWindows(self, wndInventory, wndDragonSoul):
  1470. self.wndInventory = wndInventory
  1471. self.wndDragonSoul = wndDragonSoul
  1472.  
  1473. class DragonSoulChangeAttrWindow(ui.ScriptWindow):
  1474. def __init__(self):
  1475. ui.ScriptWindow.__init__(self)
  1476. self.tooltipItem = None
  1477. self.sellingSlotNumber = -1
  1478. self.isLoaded = 0
  1479. self.refineChoiceButtonDict = None
  1480. self.doApplyButton = None
  1481. self.wndMoney = None
  1482. self.SetWindowName("DragonSoulChangeAttrWindow")
  1483. self.__LoadWindow()
  1484.  
  1485. def __del__(self):
  1486. ui.ScriptWindow.__del__(self)
  1487.  
  1488. def Show(self):
  1489. self.__LoadWindow()
  1490. ui.ScriptWindow.Show(self)
  1491.  
  1492. def __LoadWindow(self):
  1493. if self.isLoaded == 1:
  1494. return
  1495. self.isLoaded = 1
  1496. try:
  1497. pyScrLoader = ui.PythonScriptLoader()
  1498. pyScrLoader.LoadScriptFile(self, "uiscript/dragonsoulattr.py")
  1499.  
  1500. except:
  1501. import exception
  1502. exception.Abort("dragonsoulrefinewindow.LoadWindow.LoadObject")
  1503. try:
  1504. if localeInfo.IsARABIC():
  1505. self.board = self.GetChild("DragonSoulRefineWindowBaseImage")
  1506. self.board.SetScale(-1.0, 1.0)
  1507. self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
  1508.  
  1509. wndRefineSlot = self.GetChild("RefineSlot")
  1510. wndResultSlot = self.GetChild("ResultSlot")
  1511. self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
  1512. self.changeAttrButton = self.GetChild("ChangeAttrButton")
  1513. self.doApplyButton = self.GetChild("DoApplyButton")
  1514. self.wndMoney = self.GetChild("Money_Slot")
  1515. except:
  1516. import exception
  1517. exception.Abort("DragonSoulRefineWindow.LoadWindow.BindObject")
  1518.  
  1519.  
  1520. ## Item Slots
  1521. wndRefineSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInRefineItem))
  1522. wndRefineSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem))
  1523. wndRefineSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.__SelectRefineEmptySlot))
  1524. wndRefineSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
  1525. wndRefineSlot.SetUseSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
  1526. wndRefineSlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
  1527.  
  1528. wndResultSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInResultItem))
  1529. wndResultSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem))
  1530. self.wndRefineSlot = wndRefineSlot
  1531. self.wndResultSlot = wndResultSlot
  1532.  
  1533. ## Button
  1534. self.changeAttrButton.Down()
  1535. self.doApplyButton.SetEvent(self.__PressDoApplyButton)
  1536.  
  1537. ## Dialog
  1538. self.wndPopupDialog = uiCommon.PopupDialog()
  1539.  
  1540. self.refineItemInfo = {}
  1541. self.resultItemInfo = {}
  1542. self.needFireCount = 0
  1543. self.needfee = 0
  1544. self.wndMoney.SetText("Gerekli Ejderha alevi sayýsý: %s" % self.needFireCount)
  1545.  
  1546. self.__Initialize()
  1547.  
  1548. def Destroy(self):
  1549. self.ClearDictionary()
  1550. self.tooltipItem = None
  1551. self.wndItem = 0
  1552. self.wndEquip = 0
  1553. self.activateButton = 0
  1554. self.questionDialog = None
  1555. self.mallButton = None
  1556. self.inventoryTab = []
  1557. self.deckTab = []
  1558. self.equipmentTab = []
  1559. self.tabDict = None
  1560. self.tabButtonDict = None
  1561.  
  1562. def Close(self):
  1563. if None != self.tooltipItem:
  1564. self.tooltipItem.HideToolTip()
  1565.  
  1566. self.__FlushRefineItemSlot()
  1567. player.SendDragonSoulRefine(player.DRAGON_SOUL_REFINE_CLOSE)
  1568. self.Hide()
  1569.  
  1570. def Show(self):
  1571. self.wndMoney.SetText("Gerekli Ejderha alevi sayýsý: %s" % self.needFireCount)
  1572. self.doApplyButton.Down() and self.doApplyButton.Disable()
  1573.  
  1574. self.Refresh()
  1575.  
  1576. ui.ScriptWindow.Show(self)
  1577.  
  1578. def SetItemToolTip(self, tooltipItem):
  1579. self.tooltipItem = tooltipItem
  1580.  
  1581. def __Initialize(self):
  1582. self.needFireCount = 0
  1583. self.needfee = 0
  1584. self.refineItemInfo = {}
  1585. self.resultItemInfo = {}
  1586.  
  1587. self.refineSlotLockStartIndex = 2
  1588.  
  1589. for i in xrange(self.refineSlotLockStartIndex):
  1590. self.wndRefineSlot.HideSlotBaseImage(i)
  1591.  
  1592. self.wndMoney.SetText("Gerekli Ejderha alevi sayýsý: %s" % self.needFireCount)
  1593.  
  1594. def __FlushRefineItemSlot(self):
  1595. for invenType, invenPos, itemCount in self.refineItemInfo.values():
  1596. remainCount = player.GetItemCount(invenType, invenPos)
  1597. player.SetItemCount(invenType, invenPos, remainCount + itemCount)
  1598. self.__Initialize()
  1599.  
  1600. def __PopUp(self, message):
  1601. self.wndPopupDialog.SetText(message)
  1602. self.wndPopupDialog.Open()
  1603.  
  1604. def __SetItem(self, inven, dstSlotIndex, itemCount):
  1605. invenType, invenPos = inven
  1606.  
  1607. if dstSlotIndex >= self.refineSlotLockStartIndex:
  1608. return False
  1609.  
  1610. itemVnum = player.GetItemIndex(invenType, invenPos)
  1611. maxCount = player.GetItemCount(invenType, invenPos)
  1612.  
  1613. if itemCount > maxCount:
  1614. raise Exception, ("Invalid attachedItemCount(%d). (base pos (%d, %d), base itemCount(%d))" % (itemCount, invenType, invenPos, maxCount))
  1615. #return False
  1616.  
  1617. if self.__IsDragonSoul(itemVnum):
  1618. dstSlotIndex = 0
  1619. self.__SetAttrCountInfo(itemVnum)
  1620. else:
  1621. dstSlotIndex = 1
  1622.  
  1623. if dstSlotIndex in self.refineItemInfo:
  1624. return False
  1625.  
  1626. player.SetItemCount(invenType, invenPos, maxCount - itemCount)
  1627. self.refineItemInfo[dstSlotIndex] = (invenType, invenPos, itemCount)
  1628. self.Refresh()
  1629.  
  1630. return True
  1631.  
  1632. def __SetAttrCountInfo(self, vnum):
  1633. ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)
  1634. try:
  1635. import dragon_soul_refine_settings
  1636.  
  1637. self.needFireCount = dragon_soul_refine_settings.default_flame_need_count[step]
  1638. self.wndMoney.SetText("Gerekli Ejderha alevi sayýsý: %s" % self.needFireCount)
  1639. except:
  1640. return None
  1641.  
  1642. def __IsDragonSoul(self, vnum):
  1643. item.SelectItem(vnum)
  1644. return item.GetItemType() == item.ITEM_TYPE_DS
  1645.  
  1646. def __GetDragonSoulTypeInfo(self, vnum):
  1647. if not self.__IsDragonSoul(vnum):
  1648. return DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO
  1649. ds_type = vnum / 10000
  1650. grade = vnum % 10000 /1000
  1651. step = vnum % 1000 / 100
  1652. strength = vnum % 100 / 10
  1653.  
  1654. return (ds_type, grade, step, strength)
  1655.  
  1656. def __MakeDragonSoulVnum(self, ds_type, grade, step, strength):
  1657. return ds_type * 10000 + grade * 1000 + step * 100 + strength * 10
  1658.  
  1659. def __SelectRefineEmptySlot(self, selectedSlotPos):
  1660. try:
  1661. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  1662. return
  1663.  
  1664. if selectedSlotPos >= self.refineSlotLockStartIndex:
  1665. return
  1666.  
  1667. if mouseModule.mouseController.isAttached():
  1668. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  1669. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  1670. attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
  1671. attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
  1672. mouseModule.mouseController.DeattachObject()
  1673.  
  1674. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  1675. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  1676. return
  1677.  
  1678. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  1679.  
  1680. if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos):
  1681. return
  1682.  
  1683. if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType:
  1684. return
  1685.  
  1686. if True == self.__SetItem((attachedInvenType, attachedSlotPos), selectedSlotPos, attachedItemCount):
  1687. self.Refresh()
  1688.  
  1689. except Exception, e:
  1690. import dbg
  1691. dbg.TraceError("Exception : __SelectRefineEmptySlot, %s" % e)
  1692.  
  1693. def __SelectRefineItemSlot(self, selectedSlotPos):
  1694. if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
  1695. return
  1696.  
  1697. try:
  1698. if not selectedSlotPos in self.refineItemInfo:
  1699. if mouseModule.mouseController.isAttached():
  1700. attachedSlotType = mouseModule.mouseController.GetAttachedType()
  1701. attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
  1702. attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
  1703. attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
  1704. mouseModule.mouseController.DeattachObject()
  1705.  
  1706. if uiPrivateShopBuilder.IsBuildingPrivateShop():
  1707. chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
  1708. return
  1709.  
  1710. attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
  1711.  
  1712. if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos):
  1713. return
  1714.  
  1715. if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType:
  1716. return
  1717.  
  1718. self.AutoSetItem((attachedInvenType, attachedSlotPos), 1)
  1719. return
  1720. elif mouseModule.mouseController.isAttached():
  1721. return
  1722.  
  1723. attachedInvenType, attachedSlotPos, attachedItemCount = self.refineItemInfo[selectedSlotPos]
  1724. selectedItemVnum = player.GetItemIndex(attachedInvenType, attachedSlotPos)
  1725.  
  1726. invenType, invenPos, itemCount = self.refineItemInfo[selectedSlotPos]
  1727. remainCount = player.GetItemCount(invenType, invenPos)
  1728. player.SetItemCount(invenType, invenPos, remainCount + itemCount)
  1729. del self.refineItemInfo[selectedSlotPos]
  1730.  
  1731. if not self.refineItemInfo:
  1732. self.__Initialize()
  1733. else:
  1734. item.SelectItem(selectedItemVnum)
  1735. if (item.ITEM_TYPE_MATERIAL == item.GetItemType() \
  1736. and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)):
  1737. self.currentRecipe = {}
  1738. self.wndMoney.SetText("Gerekli Ejderha alevi sayýsý: %s" % self.needFireCount)
  1739. else:
  1740. pass
  1741.  
  1742. except Exception, e:
  1743. import dbg
  1744. dbg.TraceError("Exception : __SelectRefineItemSlot, %s" % e)
  1745.  
  1746. self.Refresh()
  1747.  
  1748. def __OverInRefineItem(self, slotIndex):
  1749. if self.refineItemInfo.has_key(slotIndex):
  1750. inven_type, inven_pos, item_count = self.refineItemInfo[slotIndex]
  1751. self.tooltipItem.SetInventoryItem(inven_pos, inven_type)
  1752.  
  1753. def __OverInResultItem(self, slotIndex):
  1754. if self.resultItemInfo.has_key(slotIndex):
  1755. inven_type, inven_pos, item_count = self.resultItemInfo[slotIndex]
  1756. self.tooltipItem.SetInventoryItem(inven_pos, inven_type)
  1757.  
  1758. def __OverOutItem(self):
  1759. if self.tooltipItem:
  1760. self.tooltipItem.HideToolTip()
  1761.  
  1762. def __PressDoApplyButton(self):
  1763. for i in xrange(self.refineSlotLockStartIndex):
  1764. if not i in self.refineItemInfo:
  1765. self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_NOT_ENOUGH_MATERIAL)
  1766. self.wndPopupDialog.Open()
  1767.  
  1768. return
  1769. inven_type, inven_pos, item_count = self.refineItemInfo[0]
  1770. net.SendChatPacket("/ds_change_attr %s" % (inven_pos))
  1771.  
  1772. def OnPressEscapeKey(self):
  1773. self.Close()
  1774. return True
  1775.  
  1776. def Refresh(self):
  1777. self.__RefreshRefineItemSlot()
  1778. self.__ClearResultItemSlot()
  1779.  
  1780. def __RefreshRefineItemSlot(self):
  1781. try:
  1782. for slotPos in xrange(self.wndRefineSlot.GetSlotCount()):
  1783. self.wndRefineSlot.ClearSlot(slotPos)
  1784. if slotPos < self.refineSlotLockStartIndex:
  1785. if slotPos in self.refineItemInfo:
  1786. invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
  1787. itemVnum = player.GetItemIndex(invenType, invenPos)
  1788.  
  1789. if itemVnum:
  1790. self.wndRefineSlot.SetItemSlot(slotPos, player.GetItemIndex(invenType, invenPos), itemCount)
  1791. else:
  1792. del self.refineItemInfo[slotPos]
  1793.  
  1794. if not slotPos in self.refineItemInfo:
  1795. try:
  1796. reference_vnum = 0
  1797. if 1 == slotPos:
  1798. reference_vnum = 100700
  1799. if 0 != reference_vnum:
  1800. item.SelectItem(reference_vnum)
  1801. itemIcon = item.GetIconImage()
  1802. (width, height) = item.GetItemSize()
  1803. self.wndRefineSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
  1804. self.wndRefineSlot.SetSlotCount(slotPos, 0)
  1805. except:
  1806. pass
  1807. self.wndRefineSlot.HideSlotBaseImage(slotPos)
  1808. else:
  1809. if slotPos in self.refineItemInfo:
  1810. invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
  1811. remainCount = player.GetItemCount(invenType, invenPos)
  1812. player.SetItemCount(invenType, invenPos, remainCount + itemCount)
  1813. del self.refineItemInfo[slotPos]
  1814. self.wndRefineSlot.ShowSlotBaseImage(slotPos)
  1815. if not self.refineItemInfo:
  1816. self.__Initialize()
  1817.  
  1818. self.wndRefineSlot.RefreshSlot()
  1819. except Exception, e:
  1820. import dbg
  1821. dbg.TraceError("Exception : __RefreshRefineItemSlot, %s" % e)
  1822.  
  1823. def __GetEmptySlot(self, itemVnum = 0):
  1824. if 0 == itemVnum:
  1825. return -1
  1826.  
  1827. if self.__IsDragonSoul(itemVnum):
  1828. if not 0 in self.refineItemInfo:
  1829. return 0
  1830. elif 100700 == itemVnum:
  1831. if not 1 in self.refineItemInfo:
  1832. return 1
  1833.  
  1834. return -1
  1835.  
  1836. def AutoSetItem(self, inven, itemCount):
  1837. invenType, invenPos = inven
  1838. itemVnum = player.GetItemIndex(invenType, invenPos)
  1839. emptySlot = self.__GetEmptySlot(itemVnum)
  1840. if -1 == emptySlot:
  1841. return
  1842.  
  1843. self.__SetItem((invenType, invenPos), emptySlot, itemCount)
  1844.  
  1845. def __ClearResultItemSlot(self):
  1846. self.wndResultSlot.ClearSlot(0)
  1847. self.resultItemInfo = {}
  1848.  
  1849. def ChangeAttr_Success(self):
  1850. inven_type, inven_pos, item_count = self.refineItemInfo[0]
  1851. itemCount = player.GetItemCount(inven_type, inven_pos)
  1852. self.__Initialize()
  1853. self.Refresh()
  1854. if itemCount > 0:
  1855. self.resultItemInfo[0] = (inven_type, inven_pos, itemCount)
  1856. self.wndResultSlot.SetItemSlot(0, player.GetItemIndex(inven_type, inven_pos), itemCount)
  1857.  
  1858. def ChangeAttr_Failed(self):
  1859. self.Refresh()
  1860.  
  1861. def SetInventoryWindows(self, wndInventory, wndDragonSoul):
  1862. self.wndInventory = wndInventory
  1863. self.wndDragonSoul = wndDragonSoul
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!