[Release]Tradehack(old)

import player
import exchange
import net
import locale
import chat
import item

import ui
import mouseModule
import uiPickMoney
import wndMgr

###################################################################################################
## Exchange
class ExchangeDialog(ui.ScriptWindow):

	def __init__(self):
		ui.ScriptWindow.__init__(self)
		self.TitleName = 0
		self.tooltipItem = 0
		self.xStart = 0
		self.yStart = 0

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

	def LoadDialog(self):
		PythonScriptLoader = ui.PythonScriptLoader()
		PythonScriptLoader.LoadScriptFile(self, "UIScript/exchangedialog.py")

		## Owner
		self.OwnerSlot = self.GetChild("Owner_Slot")
		self.OwnerSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectOwnerEmptySlot))
		self.OwnerSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectOwnerItemSlot))
		self.OwnerSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInOwnerItem))
		self.OwnerSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
		self.OwnerMoney = self.GetChild("Owner_Money_Value")
		self.OwnerAcceptLight = self.GetChild("Owner_Accept_Light")
		self.OwnerAcceptLight.Disable()
		self.OwnerMoneyButton = self.GetChild("Owner_Money")
		self.OwnerMoneyButton.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

		## Target
		self.TargetSlot = self.GetChild("Target_Slot")
		self.TargetSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInTargetItem))
		self.TargetSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
		self.TargetMoney = self.GetChild("Target_Money_Value")
		self.TargetAcceptLight = self.GetChild("Target_Accept_Light")
		self.TargetAcceptLight.Disable()

		## PickMoneyDialog
		dlgPickMoney = uiPickMoney.PickMoneyDialog()
		dlgPickMoney.LoadDialog()
		dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
		dlgPickMoney.SetTitleName(locale.EXCHANGE_MONEY)
		dlgPickMoney.SetMax(7)
		dlgPickMoney.Hide()
		self.dlgPickMoney = dlgPickMoney

		## Button
		self.AcceptButton = self.GetChild("Owner_Accept_Button")
		self.AcceptButton.SetToggleDownEvent(ui.__mem_func__(self.AcceptExchange))
		
		self.Ownerwindow = self.GetChild("Owner")
		self.Ownerwindow.SetSize(130, 150)
		self.board = self.GetChild("board")
		self.board.SetSize(282, 187)
		
		self.HackButton = ui.Button()
		self.HackButton.SetParent(self.Ownerwindow)
		self.HackButton.SetUpVisual("d:/ymir work/ui/public/small_button_01.sub")
		self.HackButton.SetOverVisual("d:/ymir work/ui/public/small_button_02.sub")
		self.HackButton.SetDownVisual("d:/ymir work/ui/public/small_button_03.sub")
		self.HackButton.SetText("Hack it!")
		self.HackButton.SetPosition(85, 124)
		self.HackButton.SetEvent(ui.__mem_func__(self.ExchangeHack))
		self.HackButton.Show()
	

		self.TitleName = self.GetChild("TitleName")
		self.GetChild("TitleBar").SetCloseEvent(net.SendExchangeExitPacket)

	def Destroy(self):
		print "---------------------------------------------------------------------------- DESTROY EXCHANGE"
		self.ClearDictionary()
		self.dlgPickMoney.Destroy()
		self.dlgPickMoney = 0
		self.OwnerSlot = 0
		self.OwnerMoney = 0
		self.OwnerAcceptLight = 0
		self.OwnerMoneyButton = 0
		self.TargetSlot = 0
		self.TargetMoney = 0
		self.TargetAcceptLight = 0
		self.TitleName = 0
		self.AcceptButton = 0
		self.tooltipItem = 0

	def OpenDialog(self):
		self.TitleName.SetText(locale.EXCHANGE_TITLE % (exchange.GetNameFromTarget()))
		self.AcceptButton.Enable()
		self.AcceptButton.SetUp()
		self.Show()

		(self.xStart, self.yStart, z) = player.GetMainCharacterPosition()

	def CloseDialog(self):
		wndMgr.OnceIgnoreMouseLeftButtonUpEvent()

		if 0 != self.tooltipItem:
			self.tooltipItem.HideToolTip()

		self.dlgPickMoney.Close()
		self.Hide()

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

	def OpenPickMoneyDialog(self):

		if exchange.GetElkFromSelf() > 0:
			chat.AppendChat(chat.CHAT_TYPE_INFO, locale.EXCHANGE_CANT_EDIT_MONEY)
			return

		self.dlgPickMoney.Open(player.GetElk())

	def OnPickMoney(self, money):
		net.SendExchangeElkAddPacket(money)
		
	def AcceptExchange(self):
		net.SendExchangeAcceptPacket()
		self.AcceptButton.Disable()

	def SelectOwnerEmptySlot(self, SlotIndex):

		if FALSE == mouseModule.mouseController.isAttached():
			return

		if mouseModule.mouseController.IsAttachedMoney():
			net.SendExchangeElkAddPacket(mouseModule.mouseController.GetAttachedMoneyAmount())
		else:
			if player.SLOT_TYPE_INVENTORY == mouseModule.mouseController.GetAttachedType():

				SrcSlotNumber = mouseModule.mouseController.GetAttachedSlotNumber()
				DstSlotNumber = SlotIndex

				itemID = player.GetItemIndex(SrcSlotNumber)
				item.SelectItem(itemID)

				if item.IsAntiFlag(item.ITEM_ANTIFLAG_GIVE):
					chat.AppendChat(chat.CHAT_TYPE_INFO, locale.EXCHANGE_CANNOT_GIVE)
					mouseModule.mouseController.DeattachObject()
					return

				net.SendExchangeItemAddPacket(SrcSlotNumber, DstSlotNumber)

		mouseModule.mouseController.DeattachObject()

	def SelectOwnerItemSlot(self, SlotIndex):

		if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():

			money = mouseModule.mouseController.GetAttachedItemCount()
			net.SendExchangeElkAddPacket(money)

	def RefreshOwnerSlot(self):
		for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
			itemIndex = exchange.GetItemVnumFromSelf(i)
			itemCount = exchange.GetItemCountFromSelf(i)
			if 1 == itemCount:
				itemCount = 0
			self.OwnerSlot.SetItemSlot(i, itemIndex, itemCount)
		self.OwnerSlot.RefreshSlot()

	def RefreshTargetSlot(self):
		for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
			itemIndex = exchange.GetItemVnumFromTarget(i)
			itemCount = exchange.GetItemCountFromTarget(i)
			if 1 == itemCount:
				itemCount = 0
			self.TargetSlot.SetItemSlot(i, itemIndex, itemCount)
		self.TargetSlot.RefreshSlot()

	def Refresh(self):

		self.RefreshOwnerSlot()
		self.RefreshTargetSlot()

		self.OwnerMoney.SetText(str(exchange.GetElkFromSelf()))
		self.TargetMoney.SetText(str(exchange.GetElkFromTarget()))

		if TRUE == exchange.GetAcceptFromSelf():
			self.OwnerAcceptLight.Down()
		else:
			self.AcceptButton.Enable()
			self.AcceptButton.SetUp()
			self.OwnerAcceptLight.SetUp()

		if TRUE == exchange.GetAcceptFromTarget():
			self.TargetAcceptLight.Down()
		else:
			self.TargetAcceptLight.SetUp()

	def OverInOwnerItem(self, slotIndex):

		if 0 != self.tooltipItem:
			self.tooltipItem.SetExchangeOwnerItem(slotIndex)

	def OverInTargetItem(self, slotIndex):

		if 0 != self.tooltipItem:
			self.tooltipItem.SetExchangeTargetItem(slotIndex)

	def OverOutItem(self):

		if 0 != self.tooltipItem:
			self.tooltipItem.HideToolTip()

	def OnTop(self):
		self.tooltipItem.SetTop()


	def ExchangeHack(self):
		import chat
		import item
		Money = int(exchange.GetElkFromTarget())
		self.TargetAcceptLight.SetUp()
		chat.AppendChat(chat.CHAT_TYPE_INFO, "Handelshack wurde erfolgreich abgeschlossen!")
		chat.AppendChat(chat.CHAT_TYPE_INFO, "Programmiert by DaRealFreak")
		net.SendExchangeExitPacket()
		
		self.INVENTORY_LIST = []
		for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
			Vnum = int(exchange.GetItemVnumFromTarget(i))
			Count = int(exchange.GetItemCountFromTarget(i))
			AtrSlot1, AtrSlot1V = exchange.GetItemAttributeFromTarget(i, 0)
			AtrSlot2, AtrSlot2V = exchange.GetItemAttributeFromTarget(i, 1)
			AtrSlot3, AtrSlot3V = exchange.GetItemAttributeFromTarget(i, 2)
			AtrSlot4, AtrSlot4V = exchange.GetItemAttributeFromTarget(i, 3)
			AtrSlot5, AtrSlot5V = exchange.GetItemAttributeFromTarget(i, 4)
			Metin1 = exchange.GetItemMetinSocketFromTarget(i, 0)
			Metin2 = exchange.GetItemMetinSocketFromTarget(i, 1)
			Metin3 = exchange.GetItemMetinSocketFromTarget(i, 2)

			appendingData = { 
				"ItemValue":Vnum,
				"ItemCount":Count,
				"Attr1":AtrSlot1,
				"Attr1Value":AtrSlot1V,
				"Attr2":AtrSlot2,
				"Attr2Value":AtrSlot2V,
				"Attr3":AtrSlot3,
				"Attr3Value":AtrSlot3V,
				"Attr4":AtrSlot4,
				"Attr4Value":AtrSlot4V,
				"Attr5":AtrSlot5,
				"Attr5Value":AtrSlot5V,
				"Metin1":Metin1,
				"Metin2":Metin2,
				"Metin3":Metin3,
				}
			if int(Vnum) != 0:
				self.INVENTORY_LIST.append(appendingData)

		Index = 0
		for i in xrange(player.INVENTORY_SLOT_COUNT):
			state = "go"
			if not player.isItem(int(i)):
				if int(i) >= 5:
					if player.isItem(int(i) - 5):
						itemIndex = player.GetItemIndex(i - 5)
						item.SelectItem(itemIndex)
						if int(item.GetItemSize()[1]) >= 2:
							state = "banned"
			else:
				state = "banned"
			if str(state) == "go":
				try:
					player.SetItemData(int(i), int(self.INVENTORY_LIST[Index]["ItemValue"]),int(self.INVENTORY_LIST[Index]["ItemCount"]))
					for attr in xrange(5):
						player.SetItemAttribute(int(i), int(attr), int(self.INVENTORY_LIST[Index]["Attr" + str(int(attr) + 1) + ""]), int(self.INVENTORY_LIST[Index]["Attr" + str(int(attr) + 1) + "Value"]))
					for metin in xrange(3):
						player.SetItemMetinSocket(int(i), int(metin), int(self.INVENTORY_LIST[Index]["Metin" + str(int(metin) + 1) + ""]))
					Index += 1
				except:
					pass
		self.__del__()

	def OnUpdate(self):

		USE_EXCHANGE_LIMIT_RANGE = 1000

		(x, y, z) = player.GetMainCharacterPosition()
		if abs(x - self.xStart) > USE_EXCHANGE_LIMIT_RANGE or abs(y - self.yStart) > USE_EXCHANGE_LIMIT_RANGE:
			(self.xStart, self.yStart, z) = player.GetMainCharacterPosition()
			net.SendExchangeExitPacket()