Esempio n. 1
0
	def OnSetReelResult(self, slotPos):
		# Try to get network itemVnum.
		try:
			itemVnum = SLOT_MACHINE_REELS[self.reelResult[slotPos]]
		except IndexError:
			itemVnum = 63017

		# Select item information.
		item.SelectItem(itemVnum)
		itemIcon = item.GetIconImage()
		(width, height) = item.GetItemSize()

		# Set item icon on reel slot.
		self.reelIconSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
		self.reelIconSlot.SetSlotCount(slotPos, 0)
		self.reelIconSlot.ShowSlotBaseImage(slotPos)
		self.reelIconSlot.RefreshSlot()

		# Check if reel slot is unique.
		if self.reelResult[slotPos] <= SLOT_MACHINE_MAX_JACKPOTS:
			if ENABLE_SOUND:
				# Play jackpot reel icon sound.
				snd.PlaySound("sound/ui/quest_receive.wav")

			if ENABLE_EFFECT:
				# Show reel boom effect.
				if self.reelIconEffectList and not self.isInformationPage:
					self.reelIconEffectList[slotPos].ResetFrame()
					self.reelIconEffectList[slotPos].Show()
Esempio n. 2
0
    def CreateShop(self):
        if OpenLib.GetItemByID(SHOP_PACKET_ID) == -1:
            chat.AppendChat(3,
                            "[Shop-Creator] You need to buy a packet first.")
            return

        self.iniItems = []
        self.initItems = list(self.items_ui.keys())
        blocked_slots = set()  #Avoid selecting the same item twice

        for i in range(0, self.MAX_NUM_SLOT):
            idx = player.GetItemIndex(i)
            if idx == SHOP_PACKET_ID or idx == PREMIUM_SHOP_PACKET_ID or idx == 0:
                continue
            if i in blocked_slots:
                continue
            item.SelectItem(idx)
            size = item.GetItemSize()
            if size > 1:
                for ii in range(1, size):
                    blocked_slots.add(i + ii * 5)
            #if ItemValue == 50300:
            #	ItemValue = 100000 + player.GetItemMetinSocket(i, 0)
            #if ItemValue != 0:
            self.SetItemPrice(i)
        shop.BuildPrivateShop(self.ShopNameEditline.GetText())
Esempio n. 3
0
    def SetContent(self, id, vnum, price):
        self.id = id
        self.data = [vnum, price]
        item.SelectItem(vnum)

        self.itemName.SetText(item.GetItemName())
        self.itemIcon.LoadImage(item.GetIconImageFileName())
        self.itemIcon.SetPosition(35, (46, 32, 25)[item.GetItemSize()[1] - 1])
        self.itemIcon.SetScale(1, (1, 1, 0.8)[item.GetItemSize()[1] - 1])
        self.itemPrice.SetText('Precio: %d %s' % (price, "AP's"))
        self.itemAmount.KillFocus()

        if item.IsFlag(4) == 1:
            self.GetChild("ItemAmountSlot").Show()
        else:
            self.GetChild("ItemAmountSlot").Hide()

        self.toolTip.ClearToolTip()
        self.toolTip.AddItemData(vnum, [0, 0, 0])
        self.toolTip.HideToolTip()
Esempio n. 4
0
    def retrieveItems(self):
        OpenLog.DebugPrint("========= Retrieving item list ==========")

        for slot in range(SLOTS):
            item_id = player.GetItemIndex(slot)
            if item_id != 0:
                item.SelectItem(item_id)
                self.list.append(
                    Item(item_id, slot, int(item.GetItemSize()[1]),
                         item.GetItemName()))

        OpenLog.DebugPrint("========= Retrieving successful ==========")
Esempio n. 5
0
	def OnChangeReelResult(self, slotPos):
		# Get random itemVnum.
		itemVnum = SLOT_MACHINE_REELS[app.GetRandom(1, len(SLOT_MACHINE_REELS))]

		# Select item information.
		item.SelectItem(itemVnum)
		itemIcon = item.GetIconImage()
		(width, height) = item.GetItemSize()

		# Set item icon on reel slot.
		self.reelIconSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
		self.reelIconSlot.SetSlotCount(slotPos, 0)
		self.reelIconSlot.ShowSlotBaseImage(slotPos)
		self.reelIconSlot.RefreshSlot()
Esempio n. 6
0
    def OpenRewardDialog(self, itemVnum, itemCount):
        item.SelectItem(itemVnum)
        itemName = item.GetItemName()

        get_text_pos = (item.GetItemSize()[1] * 20) + self.GET_TEXT_BASE_HEIGHT

        self.rewardDialogItemName.SetText(
            str(itemCount) + "x " + str(itemName))
        self.rewardDialogItemName.SetPosition(337, get_text_pos)
        self.rewardDialogInfo.SetPosition(337, get_text_pos + 20)
        self.rewardDialogCloseButton.SetPosition(679 / 2 - 48,
                                                 get_text_pos + 20 + 30)
        self.rewardDialogItemImage.LoadImage(item.GetIconImageFileName())
        self.rewardDialog.Show()
Esempio n. 7
0
        def RegisterShopSold(self, pos):
            if pos < 0 or not shop.GetItemID(pos):
                return
            item.SelectItem(int(shop.GetItemID(pos)))
            (itemWidth, itemHeight) = item.GetItemSize()

            targetSlot = self.itemSlotList["ItemSlot_%d" % self.GridSize]
            imageName = "d:/ymir work/slot_disabled_%d.tga" % itemHeight

            targetSlot.SetCoverButton(
                pos, imageName, imageName, imageName,
                "d:/ymir work/ui/game/belt_inventory/slot_disabled.tga", False,
                False)
            targetSlot.EnableSlot(pos)
            wndMgr.RefreshSlot(targetSlot.GetWindowHandle())
Esempio n. 8
0
	def SetBaseLayout(self):
		self.itemCount = 0
		for i in xrange(self.slotCount):
			if i < self.biologistLevel:
				self.itemSlot.EnableCoverButton(i)
				
				item.SelectItem(self.biologistItemVnum)
				itemIcon = item.GetIconImage()
				(width, height) = item.GetItemSize()
				self.itemSlot.SetSlot(i, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
				self.itemSlot.SetSlotCount(i, 0)				

			else:
				self.itemSlot.DisableCoverButton(i)

		self.itemSlot.RefreshSlot()
Esempio n. 9
0
    def Open(self, targetItemPos, nextGradeItemVnum, cost, prob, type):

        if FALSE == self.isLoaded:
            self.__LoadScript()

        self.__Initialize()

        self.targetItemPos = targetItemPos
        self.vnum = nextGradeItemVnum
        self.cost = cost
        self.percentage = prob
        self.type = type

        self.probText.SetText(locale.REFINE_SUCCESS_PROBALITY %
                              (self.percentage))
        self.costText.SetText(locale.REFINE_COST % (self.cost))

        if app.WJ_ENABLE_TRADABLE_ICON:
            self.SetCantMouseEventSlot(targetItemPos)

        self.toolTip.ClearToolTip()
        metinSlot = []
        for i in xrange(player.METIN_SOCKET_MAX_NUM):
            metinSlot.append(player.GetItemMetinSocket(targetItemPos, i))

        attrSlot = []
        for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
            attrSlot.append(player.GetItemAttribute(targetItemPos, i))
        self.toolTip.AddRefineItemData(nextGradeItemVnum, metinSlot, attrSlot)

        item.SelectItem(nextGradeItemVnum)
        self.itemImage.LoadImage(item.GetIconImageFileName())
        xSlotCount, ySlotCount = item.GetItemSize()
        for slot in self.slotList:
            slot.Hide()
        for i in xrange(min(3, ySlotCount)):
            self.slotList[i].SetPosition(-35, i * 32 - (ySlotCount - 1) * 16)
            self.slotList[i].Show()

        self.dialogHeight = self.toolTip.GetHeight() + 46
        self.UpdateDialog()

        self.SetTop()
        self.Show()
Esempio n. 10
0
	def Open(self, targetItemPos, nextGradeItemVnum, cost, prob, type):

		if False == self.isLoaded:
			self.__LoadScript()

		if app.ENABLE_REFINE_RENEWAL:
			self.__InitializeOpen()
		else:
			self.__Initialize()

		self.targetItemPos = targetItemPos
		self.vnum = nextGradeItemVnum
		self.cost = cost
		self.percentage = prob
		self.type = type

		self.probText.SetText(localeInfo.REFINE_SUCCESS_PROBALITY % (self.percentage))
		self.probText.SetFontColor(0.9607, 0.2392, 0.0)
		self.costText.SetText("Verbesserungskosten: " + constInfo.NumberToPointString(int(self.cost)) + " Yang")

		self.toolTip.ClearToolTip()
		metinSlot = []
		for i in xrange(fgGHGjjFHJghjfFG1545gGG.METIN_SOCKET_MAX_NUM):
			metinSlot.append(fgGHGjjFHJghjfFG1545gGG.GetItemMetinSocket(targetItemPos, i))

		attrSlot = []
		for i in xrange(fgGHGjjFHJghjfFG1545gGG.ATTRIBUTE_SLOT_MAX_NUM):
			attrSlot.append(fgGHGjjFHJghjfFG1545gGG.GetItemAttribute(targetItemPos, i))
		self.toolTip.AddRefineItemData(nextGradeItemVnum, metinSlot, attrSlot)

		item.SelectItem(nextGradeItemVnum)
		self.itemImage.LoadImage(item.GetIconImageFileName())
		xSlotCount, ySlotCount = item.GetItemSize()
		for slot in self.slotList:
			slot.Hide()
		for i in xrange(min(3, ySlotCount)):
			self.slotList[i].SetPosition(-38, i*32 - (ySlotCount-1)*16)
			self.slotList[i].Show()

		self.dialogHeight = self.toolTip.GetHeight() + 46
		self.UpdateDialog()

		self.SetTop()
		self.Show()
Esempio n. 11
0
	def SelectEmptySlot(self, itemSlotIndex):
		slot = self.GetSlot(itemSlotIndex)
		isAttached = mouseModule.mouseController.isAttached()
		if isAttached:
			attachedSlotType = mouseModule.mouseController.GetAttachedType()
			if fgGHGjjFHJghjfFG1545gGG.SLOT_TYPE_INVENTORY == attachedSlotType:
				attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
				itemIndex = fgGHGjjFHJghjfFG1545gGG.GetItemIndex(attachedSlotPos)
				itemCount = fgGHGjjFHJghjfFG1545gGG.GetItemCount(attachedSlotPos)
				item.SelectItem(itemIndex)
				x,y = item.GetItemSize()
				mouseModule.mouseController.DeattachObject()
				if int(x)==1 and int(y)!=1:
					return
				for i in xrange(len(self.ItemSlot)):
					if self.ItemSlot[i][0]==attachedSlotPos:
						s = self.GetSlot(i)
						self.ItemSlot[i] = [-1,-1,-1,0]
						s.ClearSlot(i)
						s.DeactivateSlot(i)
				self.ItemSlot[itemSlotIndex] = [int(attachedSlotPos), itemIndex, itemCount, 0]
				slot.SetItemSlot(itemSlotIndex, itemIndex, itemCount)
				slot.RefreshSlot()
Esempio n. 12
0
    def __OnSelectMaterialSlot(self, trash, resultIndex, materialIndex):
        resultIndex = resultIndex + self.firstSlotIndex
        if resultIndex not in self.cubeMaterialInfos:
            return

        materialInfo = self.cubeMaterialInfos[resultIndex]
        materialCount = len(materialInfo[materialIndex])

        if 0 == materialCount:
            return

        for itemVnum, itemCount in materialInfo[materialIndex]:
            bAddedNow = False
            item.SelectItem(itemVnum)
            itemSizeX, itemSizeY = item.GetItemSize()

            if player.GetItemCountByVnum(itemVnum) >= itemCount:
                for i in xrange(player.INVENTORY_SLOT_COUNT):
                    vnum = player.GetItemIndex(i)
                    count = player.GetItemCount(i)

                    if vnum == itemVnum and count >= itemCount:
                        bAlreadyExists = False
                        for slotPos, invenPos in self.cubeItemInfo.items():
                            if invenPos == i:
                                bAlreadyExists = True

                        if True == bAlreadyExists:
                            continue  #continue inventory iterating

                        #print "Cube Status : ", self.cubeItemInfo

                        bCanAddSlot = False
                        for slotPos in xrange(self.cubeSlot.GetSlotCount()):
                            if not slotPos in self.cubeItemInfo:
                                upperColumnItemSizeY = -1
                                currentSlotLine = int(slotPos /
                                                      self.CUBE_SLOT_COUNTX)
                                cubeColumn = int(slotPos %
                                                 self.CUBE_SLOT_COUNTX)

                                if cubeColumn in self.cubeItemInfo:
                                    columnVNUM = player.GetItemIndex(
                                        self.cubeItemInfo[cubeColumn])
                                    item.SelectItem(columnVNUM)
                                    columnItemSizeX, columnItemSizeY = item.GetItemSize(
                                    )

                                    if 3 == columnItemSizeY:
                                        continue  #continue cube slot iterating

                                if 0 < currentSlotLine and slotPos - self.CUBE_SLOT_COUNTX in self.cubeItemInfo:
                                    upperColumnVNUM = player.GetItemIndex(
                                        self.cubeItemInfo[
                                            slotPos - self.CUBE_SLOT_COUNTX])
                                    item.SelectItem(upperColumnVNUM)
                                    columnItemSizeX, upperColumnItemSizeY = item.GetItemSize(
                                    )

                                if 1 == itemSizeY:
                                    if 0 == currentSlotLine:
                                        bCanAddSlot = True
                                    elif 1 == currentSlotLine and 1 == upperColumnItemSizeY:
                                        bCanAddSlot = True
                                    elif 2 == currentSlotLine:
                                        bCanAddSlot = True
                                elif 2 == itemSizeY:
                                    if 0 == currentSlotLine and not cubeColumn + self.CUBE_SLOT_COUNTX in self.cubeItemInfo:
                                        bCanAddSlot = True
                                    elif 1 == currentSlotLine and 1 == upperColumnItemSizeY and not cubeColumn + (
                                            self.CUBE_SLOT_COUNTX *
                                            2) in self.cubeItemInfo:
                                        bCanAddSlot = True
                                else:
                                    if not cubeColumn in self.cubeItemInfo and not cubeColumn + self.CUBE_SLOT_COUNTX in self.cubeItemInfo and not cubeColumn + (
                                            self.CUBE_SLOT_COUNTX *
                                            2) in self.cubeItemInfo:
                                        bCanAddSlot = True

                                if True == bCanAddSlot:
                                    self.cubeItemInfo[slotPos] = i
                                    self.cubeSlot.SetItemSlot(
                                        slotPos, vnum, count)
                                    net.SendChatPacket("/cube add %d %d" %
                                                       (slotPos, i))

                                    bAddedNow = True

                            if True == bAddedNow:
                                break  #break cube slot iterating

                        if True == bAddedNow:
                            break  #break inventory iterating

                if True == bAddedNow:
                    break  #break material iterating
Esempio n. 13
0
    def Refresh(self):
        for slotPos in xrange(self.cubeSlot.GetSlotCount()):

            if not slotPos in self.cubeItemInfo:
                self.cubeSlot.ClearSlot(slotPos)
                continue

            invenPos = self.cubeItemInfo[slotPos]
            itemCount = player.GetItemCount(invenPos)
            if itemCount > 0:
                self.cubeSlot.SetItemSlot(slotPos,
                                          player.GetItemIndex(invenPos),
                                          itemCount)
            else:
                del self.cubeItemInfo[slotPos]
                self.cubeSlot.ClearSlot(slotPos)

        i = 0
        for itemVnum, count in self.cubeResultInfos[self.firstSlotIndex:]:
            currentSlot = self.resultSlots[i]

            item.SelectItem(itemVnum)

            currentSlot.SetItemSlot(0, itemVnum, count)
            currentSlot.Show()

            # Center Align
            item.SelectItem(itemVnum)
            sizeX, sizeY = item.GetItemSize()
            localX, localY = currentSlot.GetLocalPosition()

            currentSlot.SetSize(self.SLOT_SIZEX, self.SLOT_SIZEY * sizeY)

            adjustLocalY = 0
            if sizeY < 3:
                adjustLocalY = int(32 / sizeY)

            currentSlot.SetPosition(localX, 0 + adjustLocalY)

            i = i + 1
            if 3 <= i:
                break

        #print "self.cubeMaterialInfos : ", self.cubeMaterialInfos
        if self.firstSlotIndex in self.cubeMaterialInfos:
            for i in xrange(self.RESULT_SLOT_COUNT):
                materialList = self.cubeMaterialInfos[self.firstSlotIndex + i]
                #print "Refresh ::: ", materialList
                j = 0
                for materialInfo in materialList:
                    if 0 < len(materialInfo):
                        currentSlot = self.materialSlots[i][j]
                        itemVnum, itemCount = materialInfo[0]
                        currentSlot.SetItemSlot(0, itemVnum, itemCount)
                        j = j + 1

                        # Center Align
                        item.SelectItem(itemVnum)
                        sizeX, sizeY = item.GetItemSize()
                        localX, localY = currentSlot.GetLocalPosition()

                        currentSlot.SetSize(self.SLOT_SIZEX,
                                            self.SLOT_SIZEY * sizeY)

                        adjustLocalY = 0
                        if sizeY < 3:
                            adjustLocalY = int(32 / sizeY)

                        currentSlot.SetPosition(localX, 0 + adjustLocalY)

                for k in xrange(5):
                    if k >= j:
                        self.materialSlots[i][k].ClearSlot(0)

                if self.RESULT_SLOT_COUNT <= i:
                    break

        self.cubeSlot.RefreshSlot()
Esempio n. 14
0
    def __OnSelectMaterialSlot(self, trash, resultIndex, materialIndex):
        resultIndex = resultIndex + self.firstSlotIndex
        if resultIndex not in self.cubeMaterialInfos:
            return

        materialInfo = self.cubeMaterialInfos[resultIndex]
        materialCount = len(materialInfo[materialIndex])

        if 0 == materialCount:
            return

        for itemVnum, itemCount in materialInfo[materialIndex]:
            bAddedNow = FALSE  # 이번에 클릭함으로써 아이템이 추가되었나?
            item.SelectItem(itemVnum)
            itemSizeX, itemSizeY = item.GetItemSize()

            # 제조에 필요한 만큼의 재료를 가지고 있는가?
            if player.GetItemCountByVnum(itemVnum) >= itemCount:
                for i in xrange(player.INVENTORY_SLOT_COUNT):
                    vnum = player.GetItemIndex(i)
                    count = player.GetItemCount(i)

                    if vnum == itemVnum and count >= itemCount:
                        # 이미 같은 아이템이 등록되어 있는지 검사하고, 없다면 추가함
                        bAlreadyExists = FALSE
                        for slotPos, invenPos in self.cubeItemInfo.items():
                            if invenPos == i:
                                bAlreadyExists = TRUE

                        if TRUE == bAlreadyExists:
                            continue  #continue inventory iterating

                        #print "Cube Status : ", self.cubeItemInfo

                        # 여기 진입하면 큐브에 등록되지 않은 아이템이므로, 빈 큐브 슬롯에 해당 아이템 추가
                        bCanAddSlot = FALSE
                        for slotPos in xrange(self.cubeSlot.GetSlotCount()):
                            # 이 큐브 슬롯이 비어있는가?
                            if not slotPos in self.cubeItemInfo:
                                upperColumnItemSizeY = -1
                                currentSlotLine = int(slotPos /
                                                      self.CUBE_SLOT_COUNTX)
                                cubeColumn = int(slotPos %
                                                 self.CUBE_SLOT_COUNTX)

                                # 만약 큐브에 3칸짜리 아이템이 등록되어 있다면, 이 열(column)은 더 이상 볼 것도 없이 넘어간다
                                if cubeColumn in self.cubeItemInfo:
                                    columnVNUM = player.GetItemIndex(
                                        self.cubeItemInfo[cubeColumn])
                                    item.SelectItem(columnVNUM)
                                    columnItemSizeX, columnItemSizeY = item.GetItemSize(
                                    )

                                    if 3 == columnItemSizeY:
                                        continue  #continue cube slot iterating

                                if 0 < currentSlotLine and slotPos - self.CUBE_SLOT_COUNTX in self.cubeItemInfo:
                                    upperColumnVNUM = player.GetItemIndex(
                                        self.cubeItemInfo[
                                            slotPos - self.CUBE_SLOT_COUNTX])
                                    item.SelectItem(upperColumnVNUM)
                                    columnItemSizeX, upperColumnItemSizeY = item.GetItemSize(
                                    )

                                # 1칸짜리 아이템은 바로 윗줄에 한칸짜리 아이템이 있어야 함
                                if 1 == itemSizeY:
                                    if 0 == currentSlotLine:
                                        bCanAddSlot = TRUE
                                    elif 1 == currentSlotLine and 1 == upperColumnItemSizeY:
                                        bCanAddSlot = TRUE
                                    elif 2 == currentSlotLine:
                                        bCanAddSlot = TRUE
                                # 2칸짜리 아이템은 위아래가 비어있어야 함
                                elif 2 == itemSizeY:
                                    if 0 == currentSlotLine and not cubeColumn + self.CUBE_SLOT_COUNTX in self.cubeItemInfo:
                                        bCanAddSlot = TRUE
                                    elif 1 == currentSlotLine and 1 == upperColumnItemSizeY and not cubeColumn + (
                                            self.CUBE_SLOT_COUNTX *
                                            2) in self.cubeItemInfo:
                                        bCanAddSlot = TRUE
                                # 3칸짜리 아이템은 해당 Column 자체가 모두 비어있어야 함
                                else:
                                    if not cubeColumn in self.cubeItemInfo and not cubeColumn + self.CUBE_SLOT_COUNTX in self.cubeItemInfo and not cubeColumn + (
                                            self.CUBE_SLOT_COUNTX *
                                            2) in self.cubeItemInfo:
                                        bCanAddSlot = TRUE

                                if TRUE == bCanAddSlot:
                                    self.cubeItemInfo[slotPos] = i
                                    self.cubeSlot.SetItemSlot(
                                        slotPos, vnum, count)
                                    net.SendChatPacket("/cube add %d %d" %
                                                       (slotPos, i))

                                    bAddedNow = TRUE

                            if TRUE == bAddedNow:
                                break  #break cube slot iterating

                        if TRUE == bAddedNow:
                            break  #break inventory iterating

                if TRUE == bAddedNow:
                    break  #break material iterating
	def __RefreshRefineItemSlot(self):
		try:
			for slotPos in xrange(self.wndRefineSlot.GetSlotCount()):
				self.wndRefineSlot.ClearSlot(slotPos)
				if slotPos < self.refineSlotLockStartIndex:
					# self.refineItemInfo[slotPos]의 정보확인
					# (실제로 아이템이 존재하는지 확인)
					# 존재 -> 아이템 아이콘을 슬롯에 셋팅.
					# 비존재 -> 아이템이 없으므로 강화창에서 삭제.
					if slotPos in self.refineItemInfo:
						invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
						itemVnum = player.GetItemIndex(invenType, invenPos)

						# if itemVnum:
						if itemVnum:
							self.wndRefineSlot.SetItemSlot(slotPos, player.GetItemIndex(invenType, invenPos), itemCount)
						else:
							del self.refineItemInfo[slotPos]

					# 빈 슬롯에 reference 아이콘을 alpha 0.5로 셋팅.
					if not slotPos in self.refineItemInfo:
						try:
							reference_vnum = 0
							# strength 강화일 때는,
							# 0번 슬롯에 강화석을, 1번 슬롯에 용혼석을 놓는다.
							if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
								if DragonSoulRefineWindow.REFINE_STONE_SLOT == slotPos:
									reference_vnum = 100300
							else:
								reference_vnum = self.__MakeDragonSoulVnum(*self.currentRecipe["ds_info"])
							if 0 != reference_vnum:
								item.SelectItem(reference_vnum)
								itemIcon = item.GetIconImage()
								(width, height) = item.GetItemSize()
								self.wndRefineSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
								# slot 우측 하단에 숫자 뜨면 안 예쁨...
								self.wndRefineSlot.SetSlotCount(slotPos, 0)
						except:
							pass
					# refineSlotLockStartIndex 보다 작은 슬롯은 닫힌 이미지를 보여주면 안됨.
					self.wndRefineSlot.HideSlotBaseImage(slotPos)
				# slotPos >= self.refineSlotLockStartIndex:
				else:
					# 정상적인 경우라면 이 if문에 들어갈 일은 없겠지만,
					# (애초에 인덱스가 refineSlotLockStartIndex 이상인 슬롯에는 아이템을 넣지 못하게 했기 때문)
					# 혹시 모를 에러에 대비함.
					if slotPos in self.refineItemInfo:
						invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
						remainCount = player.GetItemCount(invenType, invenPos)
						player.SetItemCount(invenType, invenPos, remainCount + itemCount)
						del self.refineItemInfo[selectedSlotPos]
					# refineSlotLockStartIndex 이상인 슬롯은 닫힌 이미지를 보여줘야함.
					self.wndRefineSlot.ShowSlotBaseImage(slotPos)
			
			# 강화창에 아무런 아이템이 없다면, 초기화해줌.
			# 위에서 중간 중간에 "del self.refineItemInfo[slotPos]"를 했기 때문에,
			# 여기서 한번 체크해줘야함.
			if not self.refineItemInfo:
				self.__Initialize()
 
			self.wndRefineSlot.RefreshSlot()
		except Exception, e:
			import dbg
			dbg.TraceError("Exception : __RefreshRefineItemSlot, %s" % e)
Esempio n. 16
0
    def AttachObject(self, Owner, Type, SlotNumber, ItemIndex, count=0):

        self.LastAttachedSlotNumber = self.AttachedSlotNumber

        self.AttachedFlag = True
        self.AttachedOwner = Owner
        self.AttachedType = Type
        self.AttachedSlotNumber = SlotNumber
        self.AttachedItemIndex = ItemIndex
        self.AttachedCount = count
        self.countNumberLine.SetNumber("")
        self.countNumberLine.Hide()

        if count > 1:
            self.countNumberLine.SetNumber(str(count))
            self.countNumberLine.Show()

        try:

            width = 1
            height = 1

            if Type == player.SLOT_TYPE_INVENTORY or\
             Type == player.SLOT_TYPE_PRIVATE_SHOP or\
             Type == player.SLOT_TYPE_SHOP or\
             Type == player.SLOT_TYPE_SAFEBOX or\
             Type == player.SLOT_TYPE_MALL or\
             Type == player.SLOT_TYPE_DRAGON_SOUL_INVENTORY:

                item.SelectItem(self.AttachedItemIndex)
                self.AttachedIconHandle = item.GetIconInstance()

                if not self.AttachedIconHandle:
                    self.AttachedIconHandle = 0
                    self.DeattachObject()
                    return

                (width, height) = item.GetItemSize()

            elif Type == player.SLOT_TYPE_SKILL:
                skillGrade = player.GetSkillGrade(SlotNumber)
                self.AttachedIconHandle = skill.GetIconInstanceNew(
                    self.AttachedItemIndex, skillGrade)

            elif Type == player.SLOT_TYPE_EMOTION:
                image = player.GetEmotionIconImage(ItemIndex)
                self.AttachedIconHandle = grpImage.GenerateFromHandle(image)

            elif Type == player.SLOT_TYPE_QUICK_SLOT:
                (quickSlotType,
                 position) = player.GetGlobalQuickSlot(SlotNumber)

                if quickSlotType == player.SLOT_TYPE_INVENTORY:

                    itemIndex = player.GetItemIndex(position)
                    item.SelectItem(itemIndex)
                    self.AttachedIconHandle = item.GetIconInstance()
                    (width, height) = item.GetItemSize()

                elif quickSlotType == player.SLOT_TYPE_SKILL:
                    skillIndex = player.GetSkillIndex(position)
                    skillGrade = player.GetSkillGrade(position)
                    self.AttachedIconHandle = skill.GetIconInstanceNew(
                        skillIndex, skillGrade)

                elif quickSlotType == player.SLOT_TYPE_EMOTION:
                    image = player.GetEmotionIconImage(position)
                    self.AttachedIconHandle = grpImage.GenerateFromHandle(
                        image)

            if not self.AttachedIconHandle:
                self.DeattachObject()
                return

            self.AttachedIconHalfWidth = grpImage.GetWidth(
                self.AttachedIconHandle) / 2
            self.AttachedIconHalfHeight = grpImage.GetHeight(
                self.AttachedIconHandle) / 2
            self.AttachedIconHalfWidth = grpImage.GetWidth(
                self.AttachedIconHandle) / 2
            self.AttachedIconHalfHeight = grpImage.GetHeight(
                self.AttachedIconHandle) / 2
            wndMgr.AttachIcon(self.AttachedType, self.AttachedItemIndex,
                              self.AttachedSlotNumber, width, height)

        except Exception, e:
            dbg.TraceError("mouseModule.py: AttachObject : " + str(e))
            self.AttachedIconHandle = 0
Esempio n. 17
0
	def __BindEvent(self):
		# Title Bar
		if self.titleBar:
			self.titleBar.SetCloseEvent(ui.__mem_func__(self.__OnClickCloseTitleBar))

		# Bet Button
		if self.betButton:
			self.betButton.SetEvent(ui.__mem_func__(self.__OnClickBetButton))

		# Down Bet Button
		if self.downBetButton:
			self.downBetButton.SetEvent(ui.__mem_func__(self.__OnClickDownBetButton))

		# Up Bet Button
		if self.upBetButton:
			self.upBetButton.SetEvent(ui.__mem_func__(self.__OnClickUpBetButton))

		# Information (Jackpot) Button
		if self.informationButton:
			self.informationButton.SetToggleUpEvent(ui.__mem_func__(self.__OnClickInformationButton))
			self.informationButton.SetToggleDownEvent(ui.__mem_func__(self.__OnClickInformationButton))

		# Help ToolTip Button
		if self.helpToolTipButton:
			self.toolTipHelp = self.__CreateGameTypeToolTip(localeInfo.SLOT_MACHINE_INFO_TOOLTIP, SLOT_MACHINE_TOOLTIP_DICT)
			self.toolTipHelp.SetTop()
			self.helpToolTipButton.SetToolTipWindow(self.toolTipHelp)

		# Jackpot Effect
		if self.jackpotEffect:
			self.jackpotEffect.SetEndFrameEvent(ui.__mem_func__(self.__OnHideEffects))

		# Success Effect
		if self.successEffect:
			self.successEffect.SetEndFrameEvent(ui.__mem_func__(self.__OnHideEffects))

		# Slot Reel Effect
		if self.reelIconEffectList:
			for reelIconEffect in self.reelIconEffectList:
				reelIconEffect.SetEndFrameEvent(ui.__mem_func__(self.__OnHideEffects))

		for slotPos in xrange(self.reelIconSlot.GetSlotCount()):
			# Get random itemVnum.
			itemVnum = SLOT_MACHINE_REELS[app.GetRandom(1, len(SLOT_MACHINE_REELS))]

			# Select item information.
			item.SelectItem(itemVnum)
			itemIcon = item.GetIconImage()
			(width, height) = item.GetItemSize()

			# Set item icon on reel slot.
			self.reelIconSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
			self.reelIconSlot.SetSlotCount(slotPos, 0)
			self.reelIconSlot.ShowSlotBaseImage(slotPos)

		self.reelIconSlot.RefreshSlot()

		for slotPos in xrange(self.jackpotReelIconSlot.GetSlotCount()):
			uniqueSlot = 1

			if slotPos >= 3 and slotPos <= 5:
				uniqueSlot = 2
			elif slotPos >= 6 and slotPos <= 8:
				uniqueSlot = 3
			else:
				uniqueSlot = 1

			# Get jackpot itemVnum.
			itemVnum = SLOT_MACHINE_REELS[uniqueSlot]

			# Select item information.
			item.SelectItem(itemVnum)
			itemIcon = item.GetIconImage()
			(width, height) = item.GetItemSize()

			# Set item icon on jackpot reel slot.
			self.jackpotReelIconSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
			self.jackpotReelIconSlot.SetSlotCount(slotPos, 0)
			self.jackpotReelIconSlot.ShowSlotBaseImage(slotPos)

		self.jackpotReelIconSlot.RefreshSlot()

		# Click up bet button.
		self.__OnClickUpBetButton()