forked from metin-server/m2dev-client
234 lines
6.5 KiB
Python
234 lines
6.5 KiB
Python
import item
|
|
import net
|
|
import player
|
|
import ui
|
|
|
|
|
|
STATE_MAX = 3
|
|
STATE_ACTIVE = 0
|
|
STATE_CURRENT = 0
|
|
STATE_SUCCESS = 0
|
|
STATE_FAIL = 0
|
|
OPEN_WINDOWS = []
|
|
|
|
|
|
def SetStoneQueueState(maxCount, active, current, success, fail):
|
|
global STATE_MAX
|
|
global STATE_ACTIVE
|
|
global STATE_CURRENT
|
|
global STATE_SUCCESS
|
|
global STATE_FAIL
|
|
|
|
STATE_MAX = max(1, int(maxCount))
|
|
STATE_ACTIVE = 1 if int(active) else 0
|
|
STATE_CURRENT = max(0, int(current))
|
|
STATE_SUCCESS = max(0, int(success))
|
|
STATE_FAIL = max(0, int(fail))
|
|
|
|
for window in OPEN_WINDOWS:
|
|
try:
|
|
window.Refresh()
|
|
except:
|
|
pass
|
|
|
|
|
|
class StoneQueueWindow(ui.BoardWithTitleBar):
|
|
PAGE_SIZE = 20
|
|
|
|
def __init__(self):
|
|
ui.BoardWithTitleBar.__init__(self)
|
|
|
|
OPEN_WINDOWS.append(self)
|
|
|
|
self.scrollSlotPos = -1
|
|
self.selectedSlots = []
|
|
self.eligibleSlots = []
|
|
self.pageIndex = 0
|
|
self.candidateButtons = []
|
|
self.queueLines = []
|
|
|
|
self.AddFlag("float")
|
|
self.AddFlag("movable")
|
|
self.SetSize(340, 355)
|
|
self.SetTitleName("Stone Queue")
|
|
self.SetCloseEvent(self.Hide)
|
|
|
|
self.__CreateChildren()
|
|
self.Hide()
|
|
|
|
def __del__(self):
|
|
if self in OPEN_WINDOWS:
|
|
OPEN_WINDOWS.remove(self)
|
|
ui.BoardWithTitleBar.__del__(self)
|
|
|
|
def Destroy(self):
|
|
if self in OPEN_WINDOWS:
|
|
OPEN_WINDOWS.remove(self)
|
|
self.ClearDictionary()
|
|
self.selectedSlots = []
|
|
self.eligibleSlots = []
|
|
self.candidateButtons = []
|
|
self.queueLines = []
|
|
|
|
def __CreateChildren(self):
|
|
self.scrollLine = self.__CreateLine(15, 36)
|
|
self.statusLine = self.__CreateLine(15, 56)
|
|
self.progressLine = self.__CreateLine(15, 76)
|
|
self.resultLine = self.__CreateLine(15, 96)
|
|
|
|
self.prevButton = self.__CreateButton(15, 118, 45, "Prev")
|
|
self.prevButton.SetEvent(self.__ChangePage, -1)
|
|
self.pageLine = self.__CreateLine(127, 122)
|
|
self.nextButton = self.__CreateButton(280, 118, 45, "Next")
|
|
self.nextButton.SetEvent(self.__ChangePage, 1)
|
|
|
|
for row in range(5):
|
|
for column in range(4):
|
|
button = self.__CreateButton(15 + column * 78, 145 + row * 24, 72, "-")
|
|
self.candidateButtons.append(button)
|
|
|
|
for index in range(8):
|
|
line = self.__CreateLine(15, 272 + index * 10)
|
|
self.queueLines.append(line)
|
|
|
|
self.startButton = self.__CreateButton(185, 328, 65, "Start")
|
|
self.startButton.SetEvent(self.__StartQueue)
|
|
self.cancelButton = self.__CreateButton(260, 328, 65, "Cancel")
|
|
self.cancelButton.SetEvent(self.__CancelQueue)
|
|
|
|
def __CreateLine(self, x, y):
|
|
textLine = ui.TextLine()
|
|
textLine.SetParent(self)
|
|
textLine.SetPosition(x, y)
|
|
textLine.SetOutline()
|
|
textLine.Show()
|
|
return textLine
|
|
|
|
def __CreateButton(self, x, y, width, text):
|
|
button = ui.Button()
|
|
button.SetParent(self)
|
|
button.SetPosition(x, y)
|
|
button.SetUpVisual("d:/ymir work/ui/public/small_thin_button_01.sub")
|
|
button.SetOverVisual("d:/ymir work/ui/public/small_thin_button_02.sub")
|
|
button.SetDownVisual("d:/ymir work/ui/public/small_thin_button_03.sub")
|
|
button.SetDisableVisual("d:/ymir work/ui/public/small_thin_button_01.sub")
|
|
button.SetSize(width, 17)
|
|
button.SetText(text)
|
|
button.Show()
|
|
return button
|
|
|
|
def __BuildEligibleSlots(self):
|
|
self.eligibleSlots = []
|
|
if self.scrollSlotPos < 0:
|
|
return
|
|
|
|
scrollIndex = player.GetItemIndex(self.scrollSlotPos)
|
|
for slot in range(player.INVENTORY_PAGE_SIZE * player.INVENTORY_PAGE_COUNT):
|
|
if player.REFINE_OK != player.CanRefine(scrollIndex, slot):
|
|
continue
|
|
|
|
targetIndex = player.GetItemIndex(slot)
|
|
if targetIndex == 0:
|
|
continue
|
|
|
|
item.SelectItem(targetIndex)
|
|
if item.GetItemType() != item.ITEM_TYPE_METIN:
|
|
continue
|
|
|
|
self.eligibleSlots.append(slot)
|
|
|
|
def __GetSlotLabel(self, slot):
|
|
itemVnum = player.GetItemIndex(slot)
|
|
if itemVnum == 0:
|
|
return "Slot %d" % slot
|
|
|
|
item.SelectItem(itemVnum)
|
|
return "%d:+%d" % (slot, player.GetItemGrade(slot))
|
|
|
|
def __RefreshCandidates(self):
|
|
start = self.pageIndex * self.PAGE_SIZE
|
|
end = start + self.PAGE_SIZE
|
|
pageSlots = self.eligibleSlots[start:end]
|
|
|
|
totalPages = max(1, (len(self.eligibleSlots) + self.PAGE_SIZE - 1) // self.PAGE_SIZE)
|
|
self.pageLine.SetText("Page %d / %d" % (self.pageIndex + 1, totalPages))
|
|
|
|
for index, button in enumerate(self.candidateButtons):
|
|
if index < len(pageSlots):
|
|
slot = pageSlots[index]
|
|
prefix = "[x]" if slot in self.selectedSlots else "[ ]"
|
|
button.SetText("%s %s" % (prefix, self.__GetSlotLabel(slot)))
|
|
button.Enable()
|
|
button.SetEvent(self.__ToggleSlot, slot)
|
|
else:
|
|
button.SetText("-")
|
|
button.Disable()
|
|
|
|
self.prevButton.Enable() if self.pageIndex > 0 else self.prevButton.Disable()
|
|
self.nextButton.Enable() if end < len(self.eligibleSlots) else self.nextButton.Disable()
|
|
|
|
def __RefreshQueueLines(self):
|
|
for index, line in enumerate(self.queueLines):
|
|
if index < len(self.selectedSlots):
|
|
line.SetText("Queue %d: %s" % (index + 1, self.__GetSlotLabel(self.selectedSlots[index])))
|
|
else:
|
|
line.SetText("Queue %d: -" % (index + 1))
|
|
|
|
def __ToggleSlot(self, slot):
|
|
if STATE_ACTIVE:
|
|
return
|
|
|
|
if slot in self.selectedSlots:
|
|
self.selectedSlots.remove(slot)
|
|
elif len(self.selectedSlots) < STATE_MAX:
|
|
self.selectedSlots.append(slot)
|
|
|
|
self.Refresh()
|
|
|
|
def __ChangePage(self, delta):
|
|
totalPages = max(1, (len(self.eligibleSlots) + self.PAGE_SIZE - 1) // self.PAGE_SIZE)
|
|
self.pageIndex = max(0, min(totalPages - 1, self.pageIndex + delta))
|
|
self.__RefreshCandidates()
|
|
|
|
def __StartQueue(self):
|
|
if STATE_ACTIVE or self.scrollSlotPos < 0 or not self.selectedSlots:
|
|
return
|
|
|
|
command = "/stone_queue start %d %s" % (
|
|
self.scrollSlotPos,
|
|
" ".join([str(slot) for slot in self.selectedSlots[:STATE_MAX]]),
|
|
)
|
|
net.SendChatPacket(command, 0)
|
|
|
|
def __CancelQueue(self):
|
|
net.SendChatPacket("/stone_queue cancel", 0)
|
|
|
|
def Open(self, scrollSlotPos, targetSlotPos):
|
|
self.scrollSlotPos = scrollSlotPos
|
|
self.pageIndex = 0
|
|
self.selectedSlots = []
|
|
|
|
self.__BuildEligibleSlots()
|
|
if targetSlotPos in self.eligibleSlots:
|
|
self.selectedSlots.append(targetSlotPos)
|
|
|
|
net.SendChatPacket("/stone_queue sync", 0)
|
|
self.Refresh()
|
|
self.SetTop()
|
|
self.Show()
|
|
|
|
def Refresh(self):
|
|
self.scrollLine.SetText("Scroll slot: %d" % self.scrollSlotPos)
|
|
self.statusLine.SetText("Status: %s" % ("Running" if STATE_ACTIVE else "Ready"))
|
|
self.progressLine.SetText("Progress: %d / %d" % (STATE_CURRENT, len(self.selectedSlots)))
|
|
self.resultLine.SetText("Results: %d success / %d fail / max %d" % (STATE_SUCCESS, STATE_FAIL, STATE_MAX))
|
|
self.__RefreshCandidates()
|
|
self.__RefreshQueueLines()
|
|
|
|
if STATE_ACTIVE:
|
|
self.startButton.Disable()
|
|
self.cancelButton.Enable()
|
|
else:
|
|
self.startButton.Enable()
|
|
self.cancelButton.Disable()
|