API tools faq
paste
View difference between Paste ID: v5D3NCm8 and GajaQ616
SHOW: | | - or go back to the newest paste.
1
import uvvY2sBNvVcbJz4jvDr6fSWYdmqv9NPQ as pythonApi
2
app = __import__(pythonApi.GetModuleName("app"))
3
net = __import__(pythonApi.GetModuleName("net"))
4
item = __import__(pythonApi.GetModuleName("item"))
5
player = __import__(pythonApi.GetModuleName("player"))
6
chat = __import__(pythonApi.GetModuleName("chat"))
7
chr = __import__(pythonApi.GetModuleName("chr"))
8
exchange = __import__(pythonApi.GetModuleName("exchange"))
9
guild = __import__(pythonApi.GetModuleName("guild"))
10
import ui
11
import grp
12
import time
13
import wndMgr
14
import uiCommon
15
import localeInfo
16
import mouseModule
17
import uiPickMoney
18
import playerSettingModule
19
import uiToolTip
20
import constInfo
21
22
from playerSettingModule import RACE_WARRIOR_M, RACE_WARRIOR_W, RACE_ASSASSIN_M, RACE_ASSASSIN_W, RACE_SURA_M, RACE_SURA_W, RACE_SHAMAN_M, RACE_SHAMAN_W, RACE_WOLFMAN_M

23
from time import strftime

24
from datetime import datetime

25
26
if app.ENABLE_EXCHANGE_WINDOW_SYSTEM:

27
	FACE_IMAGE_DICT = {

28
		RACE_WARRIOR_M	: "icon/face/warrior_m.tga",

29
		RACE_WARRIOR_W	: "icon/face/warrior_w.tga",

30
		RACE_ASSASSIN_M	: "icon/face/assassin_m.tga",

31
		RACE_ASSASSIN_W	: "icon/face/assassin_w.tga",

32
		RACE_SURA_M		: "icon/face/sura_m.tga",

33
		RACE_SURA_W		: "icon/face/sura_w.tga",

34
		RACE_SHAMAN_M	: "icon/face/shaman_m.tga",

35
		RACE_SHAMAN_W	: "icon/face/shaman_w.tga",

36
	}

37
	FACE_IMAGE_DICT.update({playerSettingModule.RACE_WOLFMAN_M : "icon/face/wolfman_m.tga",})

38
	HIGHLIGHT_SLOT = "d:/ymir work/ui/public/slot_highlight.sub"

39
	BASE_VISUALS_ROUTE = "d:/ymir work/ui/game/exchange/"

40
	

41
	class ExchangeDialog(ui.ScriptWindow):

42-
		class TextRenderer(ui.Window):

42+
		#class TextRenderer(ui.Window):

43-
			def OnRender(self):

43+
		#	def OnRender(self):

44-
				(x, y) = self.GetGlobalPosition()

44+
		#		(x, y) = self.GetGlobalPosition()

45-
				chat.RenderBox("$EXCHANGE_CHAT$", x, y-3)

45+
		#		chat.RenderBox("$EXCHANGE_CHAT$", x, y-3)

46
47
		def __init__(self):

48
			ui.ScriptWindow.__init__(self)

49
			self.TitleName = 0

50
			self.tooltipItem = 0

51
			self.xStart = 0

52
			self.yStart = 0

53
			self.interface = 0

54
			self.questionDialog = 0

55
			self.wndInventory = 0

56
			self.lockedItems = {i:(-1,-1) for i in range(exchange.EXCHANGE_ITEM_MAX_NUM)}

57
58
		def __del__(self):

59
			ui.ScriptWindow.__del__(self)

60
61
		def LoadDialog(self):

62
			PythonScriptLoader = ui.PythonScriptLoader()

63
			PythonScriptLoader.LoadScriptFile(self, "UIScript/exchangedialog_new.py")

64
65
			## Owner

66
			self.OwnerSlot = self.GetChild("Owner_Slot")

67
			self.OwnerSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectOwnerEmptySlot))

68
			self.OwnerSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectOwnerItemSlot))

69
			self.OwnerSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInOwnerItem))

70
			self.OwnerSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

71
			self.OwnerSlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.RightClickItemSlot))

72
73
			self.OwnerMoney = self.GetChild("Owner_Money_Value")

74
			#self.OwnerAcceptLight = self.GetChild("Owner_Accept_Light")

75
			#self.OwnerAcceptLight.Disable()

76
			self.OwnerMoneyButton = self.GetChild("Owner_Money")

77
			self.OwnerMoneyButton.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

78
			if app.ENABLE_CHEQUE_SYSTEM:

79
				self.OwnerCheque = self.GetChild("Owner_Cheque_Value")

80
				self.OwnerChequeButton = self.GetChild("Owner_Cheque")

81
				self.OwnerChequeButton.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

82
			self.OwnerRaceImage = self.GetChild("Owner_Race_Image")

83
			self.OwnerOverlay = self.GetChild("Owner_Overlay")

84
			self.OwnerOverlay.Hide()

85
86
			## Target

87
			self.TargetSlot = self.GetChild("Target_Slot")

88
			self.TargetSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInTargetItem))

89
			self.TargetSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

90
			self.TargetMoney = self.GetChild("Target_Money_Value")

91
			if app.ENABLE_CHEQUE_SYSTEM:

92
				self.TargetCheque = self.GetChild("Target_Cheque_Value")

93
			#self.TargetAcceptLight = self.GetChild("Target_Accept_Light")

94
			#self.TargetAcceptLight.Disable()

95
96
			self.Character_Name = self.GetChild("Character_Name")

97
			self.Character_Level = self.GetChild("Character_Level")

98
			self.TargetName = self.GetChild("Target_Name")

99
			self.TargetLevel = self.GetChild("Target_Level")

100
			self.TargetGuild = self.GetChild("Target_Guild")

101
			self.CharacterGuild = self.GetChild("Character_Guild")

102
			self.TargetFriendIndicator = self.GetChild("Target_Friend_Indicator")

103
			self.TargetFriendIndicator.Hide()

104
105
			self.TargetRaceImage = self.GetChild("Target_Race_Image")

106
			self.TargetOverlay = self.GetChild("Target_Overlay")

107
			self.TargetOverlay.Hide()

108
109
			## PickMoneyDialog

110
			dlgPickMoney = uiPickMoney.PickMoneyDialog()

111
			dlgPickMoney.LoadDialog()

112
			dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))

113
			dlgPickMoney.SetTitleName(localeInfo.EXCHANGE_MONEY)

114
			dlgPickMoney.SetMax(10)

115
			#if app.ENABLE_CHEQUE_SYSTEM:

116
				#dlgPickMoney.SetMaxCheque(3)

117
			dlgPickMoney.Hide()

118
			self.dlgPickMoney = dlgPickMoney

119
120
			## Button

121
			self.ReadyButton = self.GetChild("Middle_Exchange_Button")

122
			self.ReadyButton.SetEvent(ui.__mem_func__(self.ReadyExchange))

123
124
			self.TitleName = self.GetChild("TitleName")

125
			self.GetChild("TitleBar").SetCloseEvent(net.SendExchangeExitPacket)

126
			

127
			## Scroll

128
			self.scrollBar = self.GetChild("scrollbar")

129
			self.scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))

130
			self.scrollBar.SetPos(0.0)

131
132
			## Chat

133-
			self.textRenderer = self.TextRenderer()

133+
			#self.textRenderer = self.TextRenderer()

134-
			self.textRenderer.SetParent(self)

134+
			#self.textRenderer.SetParent(self)

135-
			self.textRenderer.SetPosition(40, 239)

135+
			#self.textRenderer.SetPosition(40, 239)

136-
			self.textRenderer.Show()

136+
			#self.textRenderer.Show()

137
138
		def Destroy(self):

139
			print "---------------------------------------------------------------------------- DESTROY EXCHANGE"

140
			self.ClearDictionary()

141
			self.dlgPickMoney.Destroy()

142
			self.dlgPickMoney = 0

143
			self.scrollBar.Destroy()

144
			self.scrollBar = 0

145
			self.OwnerSlot = 0

146
			self.OwnerMoney = 0

147
			if app.ENABLE_CHEQUE_SYSTEM:

148
				self.OwnerCheque = 0

149
			self.OwnerAcceptLight = 0

150
			self.OwnerMoneyButton = 0

151
			if app.ENABLE_CHEQUE_SYSTEM:

152
				self.OwnerChequeButton = 0

153
			self.TargetSlot = 0

154
			self.TargetMoney = 0

155
			if app.ENABLE_CHEQUE_SYSTEM:

156
				self.TargetCheque = 0

157
			self.TargetAcceptLight = 0

158
			self.TitleName = 0

159
			self.ReadyButton = 0

160
			self.tooltipItem = 0

161
162
			self.TargetName = 0

163
			self.Character_Name = 0

164
			self.TargetLevel = 0

165
			self.Character_Level = 0

166
			self.TargetGuild = 0

167
			self.CharacterGuild = 0

168
			self.TargetFriendIndicator = 0

169
			self.TargetRaceImage = 0

170
			self.TargetOverlay = 0

171
			self.OwnerRaceImage = 0

172
			self.OwnerOverlay = 0

173
			self.questionDialog = 0

174
			self.wndInventory = 0

175
			self.lockedItems = {i:(-1,-1) for i in range(exchange.EXCHANGE_ITEM_MAX_NUM)}

176
			self.textRenderer = None

177
178
		def OpenDialog(self):

179
			# Reset the info box

180-
			chat.ClearBox("$EXCHANGE_CHAT$")

180+
			#chat.ClearBox("$EXCHANGE_CHAT$")

181-
			chat.CreateFloatingBox("$EXCHANGE_CHAT$")

181+
			#chat.CreateFloatingBox("$EXCHANGE_CHAT$")

182-
			chat.SetBoxSize("$EXCHANGE_CHAT$", 370, 80)

182+
			#chat.SetBoxSize("$EXCHANGE_CHAT$", 370, 80)

183-
			chat.SetRenderDownwards("$EXCHANGE_CHAT$", True)

183+
			#chat.SetRenderDownwards("$EXCHANGE_CHAT$", True)

184
185
			targetVID = exchange.GetTargetVID()

186
187
			self.TargetName.SetText(chr.GetNameByVID(targetVID))

188
			self.Character_Name.SetText(player.GetName())

189
			self.TargetLevel.SetText("Lv. "+str(exchange.GetLevelFromTarget()))

190
			self.Character_Level.SetText("Lv. "+str(exchange.GetLevelFromSelf()))

191
			if chr.GetGuildID(targetVID) != 0:

192
				self.TargetGuild.SetText(guild.GetGuildName(chr.GetGuildID(targetVID)))

193
			else:

194
				self.TargetGuild.SetText("")

195
			if chr.GetGuildID(player.GetMainCharacterIndex()) != 0:

196
				self.CharacterGuild.SetText(guild.GetGuildName(chr.GetGuildID(player.GetMainCharacterIndex())))

197
			else:

198
				self.CharacterGuild.SetText("")

199
				

200
			#if messenger.IsFriendByName(chr.GetNameByVID(targetVID)):

201
			#	self.TargetFriendIndicator.Show()

202
			#else:

203
			#	self.TargetFriendIndicator.Hide()

204
205
			# Race img for target

206
			try:

207
				race = chr.GetRaceByVID(targetVID)

208
				faceImageName = FACE_IMAGE_DICT[race]

209
210
				try:

211
					self.TargetRaceImage.LoadImage(faceImageName)

212
				except:

213
					print "TradeWindow, could not load image for target: race=%d, faceImageName=%s" % (race, faceImageName)

214
					self.TargetRaceImage.Hide()

215
216
			except KeyError:

217
				self.TargetRaceImage.Hide()

218
				

219
			# Race image for owner

220
			try:

221
				race = chr.GetRaceByVID(player.GetMainCharacterIndex())

222
				faceImageName = FACE_IMAGE_DICT[race]

223
224
				try:

225
					self.OwnerRaceImage.LoadImage(faceImageName)

226
				except:

227
					print "TradeWindow, could not load image for owner: race=%d, faceImageName=%s" % (race, faceImageName)

228
					self.OwnerRaceImage.Hide()

229
230
			except KeyError:

231
				self.OwnerRaceImage.Hide()

232
233
			self.Show()

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

236
			self.interface.SetOnTopWindow(player.ON_TOP_WND_EXCHANGE)

237
			self.interface.RefreshMarkInventoryBag()

238
239
		def CloseDialog(self):

240
			wndMgr.OnceIgnoreMouseLeftButtonUpEvent()

241
242
			if 0 != self.tooltipItem:

243
				self.tooltipItem.HideToolTip()

244
245
			self.dlgPickMoney.Close()

246
			

247
			self.Hide()

248
			for exchangePos, (itemInvenPage, itemSlotPos) in self.lockedItems.items():

249
				if itemInvenPage == self.wndInventory.GetInventoryPageIndex():

250
					self.wndInventory.wndItem.SetCanMouseEventSlot(itemSlotPos)

251
252
			self.lockedItems = {i:(-1,-1) for i in range(exchange.EXCHANGE_ITEM_MAX_NUM)}

253
			self.interface.SetOnTopWindow(player.ON_TOP_WND_NONE)

254
			self.interface.RefreshMarkInventoryBag()

255
256
		def AppendInformation(self, unixTime, info, error = False):

257-
			if not error:

257+
            pass

258-
				chatType = chat.WHISPER_TYPE_CHAT

258+
			#if not error:

259
			#	chatType = chat.WHISPER_TYPE_CHAT

260-
				chatType = chat.WHISPER_TYPE_SYSTEM

260+
261
			#	chatType = chat.WHISPER_TYPE_SYSTEM

262-
			time = datetime.fromtimestamp(unixTime).timetuple()

262+
263
			#time = datetime.fromtimestamp(unixTime).timetuple()

264-
			chat.AppendToBox(chatType, "$EXCHANGE_CHAT$", "["+strftime("%H:%M:%S", time) + "] "+info)

264+
265
			#chat.AppendToBox(chatType, "$EXCHANGE_CHAT$", "["+strftime("%H:%M:%S", time) + "] "+info)

266
267
		def SetItemToolTip(self, tooltipItem):

268
			self.tooltipItem = tooltipItem

269
270
		def OpenPickMoneyDialog(self):

271
			if self.OwnerMoney.GetText() != "0" or self.OwnerCheque.GetText() != "0" :

272
				return

273
274
			if app.ENABLE_CHEQUE_SYSTEM:

275
				if exchange.GetElkFromSelf() > 0 or exchange.GetChequeFromSelf() > 0:

276
					chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANT_EDIT_MONEY)

277
					return

278
279
				self.dlgPickMoney.Open(player.GetElk(), player.GetCheque())

280
			else:

281
				if exchange.GetElkFromSelf() > 0:

282
					chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANT_EDIT_MONEY)

283
					return

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

286
287
		def OnPickMoney(self, money, cheque):

288
			if app.ENABLE_CHEQUE_SYSTEM:

289
				if money > 0:

290
					net.SendExchangeElkAddPacket(money)

291
				if cheque > 0:

292
					net.SendExchangeChequeAddPacket(cheque)

293
			else:

294
				net.SendExchangeElkAddPacket(money)

295
296
		def ReadyExchange(self):

297
			emptyslots = 0;

298
			emptyslots_self = 0;

299
			for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

300
				itemVnum_self = exchange.GetItemVnumFromSelf(i)

301
				itemVnum = exchange.GetItemVnumFromTarget(i)

302
				if itemVnum == 0:

303
					emptyslots += 1

304
				if itemVnum_self == 0:

305
					emptyslots_self += 1

306
307
			# if emptyslots_self != exchange.EXCHANGE_ITEM_MAX_NUM:

308
				# if emptyslots == exchange.EXCHANGE_ITEM_MAX_NUM and exchange.GetElkFromTarget() <= 10000:

309
					# self.questionDialog = uiCommon.QuestionDialog3()

310
					# self.questionDialog.SetText1(localeInfo.TRADE_FOR_NOTHING1)

311
					# self.questionDialog.SetText2(localeInfo.TRADE_FOR_NOTHING2)

312
					# self.questionDialog.SetText3(localeInfo.TRADE_FOR_NOTHING3)

313
					# self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.DoExchange))

314
					# self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))

315
					# self.questionDialog.Open()

316
				# else:

317
					# self.DoExchange()

318
			# else:

319
			self.DoExchange()

320
321
		def DoExchange(self):

322
			net.SendExchangeAcceptPacket()

323
			self.OnCloseQuestionDialog()

324
325
		def OnCloseQuestionDialog(self):

326
			if not self.questionDialog:

327
				return

328
			

329
			self.questionDialog.Close()

330
			self.questionDialog = None

331
			constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

332
			

333-
			chat.SetBoxPosition("$EXCHANGE_CHAT$", 1 - self.scrollBar.GetPos())

333+
334
            pass

335
			#chat.SetBoxPosition("$EXCHANGE_CHAT$", 1 - self.scrollBar.GetPos())

336
337
		def SelectOwnerEmptySlot(self, SlotIndex):

338
339
			if False == mouseModule.mouseController.isAttached():

340
				return

341
342
			if mouseModule.mouseController.IsAttachedMoney():

343
				net.SendExchangeElkAddPacket(long(mouseModule.mouseController.GetAttachedMoneyAmount()))

344
			else:

345
				attachedSlotType = mouseModule.mouseController.GetAttachedType()

346
				if (player.SLOT_TYPE_INVENTORY == attachedSlotType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType):

347
348
					attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)

349
					SrcSlotNumber = mouseModule.mouseController.GetRealAttachedSlotNumber()

350
					DstSlotNumber = SlotIndex

351
352
					itemID = player.GetItemIndex(attachedInvenType, SrcSlotNumber)

353
					item.SelectItem(itemID)

354
355
					if item.IsAntiFlag(item.ANTIFLAG_GIVE):

356
						chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)

357
						mouseModule.mouseController.DeattachObject()

358
						return

359
360
					if app.ENABLE_SOULBIND_SYSTEM:

361
						if player.GetItemSealDate(attachedInvenType, SrcSlotNumber):

362
							chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE_SEAL_ITEM)

363
							return

364
365
					print "src:", SrcSlotNumber, ", dst:", DstSlotNumber

366
					net.SendExchangeItemAddPacket(attachedInvenType, SrcSlotNumber, DstSlotNumber)

367
				if app.UK_ENABLE_SPECIAL_STORAGE:

368
					if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedSlotType or\

369
						player.SLOT_TYPE_BOOK_INVENTORY == attachedSlotType or\

370
						player.SLOT_TYPE_STONE_INVENTORY == attachedSlotType or\

371
						player.SLOT_TYPE_ATTR_INVENTORY == attachedSlotType or\

372
						player.SLOT_TYPE_FLOWER_INVENTORY == attachedSlotType or\

373
						player.SLOT_TYPE_BLEND_INVENTORY == attachedSlotType:

374
						attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)

375
						SrcSlotNumber = mouseModule.mouseController.GetAttachedSlotNumber()

376
						DstSlotNumber = SlotIndex

377
		

378
						itemID = player.GetItemIndex(attachedSlotType, SrcSlotNumber)

379
						item.SelectItem(itemID)

380
						

381
						if item.IsAntiFlag(item.ANTIFLAG_GIVE):

382
							chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)

383
							mouseModule.mouseController.DeattachObject()

384
							return

385
							

386
						if app.ENABLE_SOULBIND_SYSTEM:

387
							if player.GetItemSealDate(attachedInvenType, SrcSlotNumber):

388
								chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE_SEAL_ITEM)

389
								return

390
							

391
						net.SendExchangeItemAddPacket(attachedInvenType, SrcSlotNumber, DstSlotNumber)

392
393
			mouseModule.mouseController.DeattachObject()

394
395
		def RightClickItemSlot(self, SlotIndex):

396
			print "Requesting removal of", SlotIndex

397
			net.SendExchangeItemDelPacket(SlotIndex)

398
			self.lockedItems[SlotIndex] = (-1, -1)

399
400
		def SelectOwnerItemSlot(self, SlotIndex):

401
			print "SelectOwnerItemSlot: ",SlotIndex

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

403
				money = mouseModule.mouseController.GetAttachedItemCount()

404
				net.SendExchangeElkAddPacket(long(money))

405
406
		def HighlightSlots(self, isSelf):

407
			if isSelf:

408
				slotWindow = self.OwnerSlot

409
				getItemVnumFunc = exchange.GetItemVnumFromSelf

410
			else:

411
				slotWindow = self.TargetSlot

412
				getItemVnumFunc = exchange.GetItemVnumFromTarget

413
414
			for slotIndex in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

415
				itemVnum = getItemVnumFunc(slotIndex)

416
				if itemVnum < 1:

417
					continue

418
419
				item.SelectItem(itemVnum)

420
				itemType = item.GetItemType()

421
				if itemType != item.ITEM_TYPE_WEAPON and itemType != item.ITEM_TYPE_ARMOR:		

422
					continue

423
424
				itemName = item.GetItemName()

425
				_, itemHeight = item.GetItemSize()

426
427
				for plus in xrange(6, 9+1):

428
					if "+"+str(plus) in itemName or "+ "+str(plus) in itemName:

429
						print "Found",plus,"in the item name"

430
431
						for row in xrange(0, itemHeight):

432
							print "Setting bg for: "+str(slotIndex + row*6)

433
							slotWindow.SetSlotHighlightedGreeen(slotIndex + row*6,0)

434
435
						break # Outside the plus loop

436
437
			#slotWindow.ClearBackgroundImage()

438
439
		def RefreshOwnerSlot(self):

440
			for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

441
				itemVnum = exchange.GetItemVnumFromSelf(i)

442
				itemCount = exchange.GetItemCountFromSelf(i)

443
444
				if itemCount == 1:

445
					itemCount = 0

446
447
				self.OwnerSlot.SetItemSlot(i, itemVnum, itemCount)

448
				if app.ENABLE_CHANGELOOK_SYSTEM:

449
					itemTransmutedVnum = exchange.GetItemTransmutation(i, True)

450
					if itemTransmutedVnum:

451
						self.OwnerSlot.DisableCoverButton(i)

452
					else:

453
						self.OwnerSlot.EnableCoverButton(i)

454
455
			# See if any item needs highlighting

456
			self.HighlightSlots(True)

457
			self.OwnerSlot.RefreshSlot()

458
459
		def RefreshTargetSlot(self):

460
			for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

461
				itemVnum = exchange.GetItemVnumFromTarget(i)

462
				itemCount = exchange.GetItemCountFromTarget(i)

463
				if itemCount == 1:

464
					itemCount = 0

465
466
				self.TargetSlot.SetItemSlot(i, itemVnum, itemCount)		

467
				if app.ENABLE_CHANGELOOK_SYSTEM:

468
					itemTransmutedVnum = exchange.GetItemTransmutation(i, False)

469
					if itemTransmutedVnum:

470
						self.TargetSlot.DisableCoverButton(i)

471
					else:

472
						self.TargetSlot.EnableCoverButton(i)

473
				

474
			# See if the any item needs highlighting

475
			self.HighlightSlots(False)

476
			self.TargetSlot.RefreshSlot()

477
478
		def Refresh(self):

479
			self.RefreshOwnerSlot()

480
			self.RefreshTargetSlot()

481
			self.RefreshLockedSlot()

482
483
			self.OwnerMoney.SetText(localeInfo.NumberToString(exchange.GetElkFromSelf()))

484
			self.TargetMoney.SetText(localeInfo.NumberToString(exchange.GetElkFromTarget()))

485
			if app.ENABLE_CHEQUE_SYSTEM:

486
				self.OwnerCheque.SetText(localeInfo.NumberToString(exchange.GetChequeFromSelf()))

487
				self.TargetCheque.SetText(localeInfo.NumberToString(exchange.GetChequeFromTarget()))

488
489
			if exchange.GetAcceptFromSelf():

490
				self.OwnerOverlay.Show()

491
492
				self.ReadyButton.SetUpVisual(BASE_VISUALS_ROUTE+"player_ready_button.tga");

493
				self.ReadyButton.SetDownVisual(BASE_VISUALS_ROUTE+"player_ready_button.tga");

494
				self.ReadyButton.SetOverVisual(BASE_VISUALS_ROUTE+"player_ready_button.tga");

495
			else:

496
				self.OwnerOverlay.Hide()

497
498
			if exchange.GetAcceptFromTarget():

499
				self.TargetOverlay.Show()

500
501
				self.ReadyButton.SetUpVisual(BASE_VISUALS_ROUTE+"target_ready_button.tga");

502
				self.ReadyButton.SetDownVisual(BASE_VISUALS_ROUTE+"target_ready_button.tga");

503
				self.ReadyButton.SetOverVisual(BASE_VISUALS_ROUTE+"target_ready_button.tga");

504
			else:

505
				self.TargetOverlay.Hide()

506
507
			if not exchange.GetAcceptFromSelf() and not exchange.GetAcceptFromTarget():

508
				self.ReadyButton.SetUpVisual(BASE_VISUALS_ROUTE+"none_ready_button.tga");

509
				self.ReadyButton.SetDownVisual(BASE_VISUALS_ROUTE+"none_ready_button.tga");

510
				self.ReadyButton.SetOverVisual(BASE_VISUALS_ROUTE+"none_ready_button.tga");

511
512
		def OverInOwnerItem(self, slotIndex):

513
514
			if 0 != self.tooltipItem:

515
				self.tooltipItem.SetExchangeOwnerItem(slotIndex)

516
517
		def OverInTargetItem(self, slotIndex):

518
519
			if 0 != self.tooltipItem:

520
				self.tooltipItem.SetExchangeTargetItem(slotIndex)

521
522
		def OverOutItem(self):

523
524
			if 0 != self.tooltipItem:

525
				self.tooltipItem.HideToolTip()

526
				

527
		def OnTop(self):

528
			if self.tooltipItem:

529
				self.tooltipItem.SetTop()

530
			

531
		def BindInterface(self, interface):

532
			self.interface = interface

533
534
		def OnMouseLeftButtonDown(self):

535
			hyperlink = ui.GetHyperlink()

536
			if hyperlink:

537
				self.interface.MakeHyperlinkTooltip(hyperlink)

538
539
		def OnUpdate(self):

540
			USE_EXCHANGE_LIMIT_RANGE = 1000

541
542
			(x, y, z) = player.GetMainCharacterPosition()

543
			if abs(x - self.xStart) > USE_EXCHANGE_LIMIT_RANGE or abs(y - self.yStart) > USE_EXCHANGE_LIMIT_RANGE:

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

545
				net.SendExchangeExitPacket()

546
				

547
		def CantTradableItem(self, destSlotIndex, srcSlotIndex):

548
			if True == exchange.GetAcceptFromTarget():

549
				return

550
551
			itemInvenPage = srcSlotIndex / player.INVENTORY_PAGE_SIZE

552
			localSlotPos = srcSlotIndex - (itemInvenPage * player.INVENTORY_PAGE_SIZE)

553
			self.lockedItems[destSlotIndex] = (itemInvenPage, localSlotPos)

554
555
			if self.wndInventory.GetInventoryPageIndex() == itemInvenPage and self.IsShow():

556
				self.wndInventory.wndItem.SetCantMouseEventSlot(localSlotPos)

557
558
		def RefreshLockedSlot(self):

559
			if self.wndInventory:

560
				for exchangePos, (itemInvenPage, itemSlotPos) in self.lockedItems.items():

561
					if self.wndInventory.GetInventoryPageIndex() == itemInvenPage:

562
						self.wndInventory.wndItem.SetCantMouseEventSlot(itemSlotPos)

563
564
				self.wndInventory.wndItem.RefreshSlot()

565
566
		def SetInven(self, wndInventory):

567
			from _weakref import proxy

568
			self.wndInventory = proxy(wndInventory)

569
570
		if app.ENABLE_FAST_ATTACH_ITEMS_SYSTEM:

571
			def __GetCurrentItemGrid(self):

572
				itemGrid = [False for cell in xrange(exchange.EXCHANGE_ITEM_MAX_NUM)]

573
574
				for slot in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

575
					itemVnum = exchange.GetItemVnumFromSelf(slot)

576
					if itemVnum <> 0:

577
						item.SelectItem(itemVnum)

578
						(w, h) = item.GetItemSize()

579
						for i in xrange(h):

580
							itemGrid[slot + i * 6] = True

581
582
				return itemGrid

583
584
			def __FindEmptyCellForSize(self, itemGrid, size):

585
				for slot in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

586
					if itemGrid[slot] == False:

587
						possible = True

588
						for i in xrange(size):

589
							p = slot + 6 * i

590
							try:

591
								if itemGrid[p] == True:

592
									possible = False

593
									break

594
							except IndexError:

595
								possible = False

596
								break

597
598
							if possible:

599
								return slot

600
601
				return -1

602
603
			def AttachItemFromInventory(self, slotWindow, slotIndex):

604
				attachedItemID = player.GetItemIndex(slotWindow, slotIndex)

605
				item.SelectItem(attachedItemID)

606
				if item.IsAntiFlag(item.ITEM_ANTIFLAG_GIVE):

607
					return False

608
609
				itemGrid = self.__GetCurrentItemGrid()

610
611
				item.SelectItem(attachedItemID) 

612
				emptySlot = self.__FindEmptyCellForSize(itemGrid, item.GetItemSize()[1])

613
				if emptySlot == -1 or item.GetItemType() == item.ITEM_TYPE_ELK:

614
					return False

615
616
				net.SendExchangeItemAddPacket(slotWindow, slotIndex, emptySlot)

617
				return True

618
619
else:

620
	class ExchangeDialog(ui.ScriptWindow):

621
622
		def __init__(self):

623
			ui.ScriptWindow.__init__(self)

624
			self.TitleName = 0

625
			self.tooltipItem = 0

626
			self.xStart = 0

627
			self.yStart = 0

628
629
		def __del__(self):

630
			ui.ScriptWindow.__del__(self)

631
632
		def LoadDialog(self):

633
			PythonScriptLoader = ui.PythonScriptLoader()

634
			PythonScriptLoader.LoadScriptFile(self, "UIScript/exchangedialog.py")

635
636
			## Owner

637
			self.OwnerSlot = self.GetChild("Owner_Slot")

638
			self.OwnerSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectOwnerEmptySlot))

639
			self.OwnerSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectOwnerItemSlot))

640
			self.OwnerSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInOwnerItem))

641
			self.OwnerSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

642
			self.OwnerMoney = self.GetChild("Owner_Money_Value")

643
			self.OwnerAcceptLight = self.GetChild("Owner_Accept_Light")

644
			self.OwnerAcceptLight.Disable()

645
			self.OwnerMoneyButton = self.GetChild("Owner_Money")

646
			self.OwnerMoneyButton.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

647
648
			## Target

649
			self.TargetSlot = self.GetChild("Target_Slot")

650
			self.TargetSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInTargetItem))

651
			self.TargetSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

652
			self.TargetMoney = self.GetChild("Target_Money_Value")

653
			self.TargetAcceptLight = self.GetChild("Target_Accept_Light")

654
			self.TargetAcceptLight.Disable()

655
656
			## PickMoneyDialog

657
			dlgPickMoney = uiPickMoney.PickMoneyDialog()

658
			dlgPickMoney.LoadDialog()

659
			dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))

660
			dlgPickMoney.SetTitleName(localeInfo.EXCHANGE_MONEY)

661
			if app.ENABLE_FULL_YANG_SYSTEM:

662
				dlgPickMoney.SetMax(10)

663
			else:

664
				dlgPickMoney.SetMax(7)

665
			dlgPickMoney.Hide()

666
			self.dlgPickMoney = dlgPickMoney

667
668
			## Button

669
			self.AcceptButton = self.GetChild("Owner_Accept_Button")

670
			self.AcceptButton.SetToggleDownEvent(ui.__mem_func__(self.AcceptExchange))

671
672
			self.TitleName = self.GetChild("TitleName")

673
			self.GetChild("TitleBar").SetCloseEvent(net.SendExchangeExitPacket)

674
675
		def Destroy(self):

676
			print "---------------------------------------------------------------------------- DESTROY EXCHANGE"

677
			self.ClearDictionary()

678
			self.dlgPickMoney.Destroy()

679
			self.dlgPickMoney = 0

680
			self.OwnerSlot = 0

681
			self.OwnerMoney = 0

682
			self.OwnerAcceptLight = 0

683
			self.OwnerMoneyButton = 0

684
			self.TargetSlot = 0

685
			self.TargetMoney = 0

686
			self.TargetAcceptLight = 0

687
			self.TitleName = 0

688
			self.AcceptButton = 0

689
			self.tooltipItem = 0

690
691
		def OpenDialog(self):

692
			self.TitleName.SetText(localeInfo.EXCHANGE_TITLE_LEVEL % (exchange.GetNameFromTarget(), exchange.GetLevelFromTarget()))

693
			self.AcceptButton.Enable()

694
			self.AcceptButton.SetUp()

695
			self.Show()

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

698
699
		def CloseDialog(self):

700
			wndMgr.OnceIgnoreMouseLeftButtonUpEvent()

701
702
			if 0 != self.tooltipItem:

703
				self.tooltipItem.HideToolTip()

704
705
			self.dlgPickMoney.Close()

706
			self.Hide()

707
708
		def SetItemToolTip(self, tooltipItem):

709
			self.tooltipItem = tooltipItem

710
711
		def OpenPickMoneyDialog(self):

712
713
			if exchange.GetElkFromSelf() > 0:

714
				chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANT_EDIT_MONEY)

715
				return

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

718
719
		def OnPickMoney(self, money):

720
			net.SendExchangeElkAddPacket(money)

721
722
		def AcceptExchange(self):

723
			net.SendExchangeAcceptPacket()

724
			self.AcceptButton.Disable()

725
726
		def SelectOwnerEmptySlot(self, SlotIndex):

727
728
			if False == mouseModule.mouseController.isAttached():

729
				return

730
731
			if mouseModule.mouseController.IsAttachedMoney():

732
				net.SendExchangeElkAddPacket(mouseModule.mouseController.GetAttachedMoneyAmount())

733
			else:

734
				attachedSlotType = mouseModule.mouseController.GetAttachedType()

735
				if (player.SLOT_TYPE_INVENTORY == attachedSlotType

736
					or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType):

737
738
					attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)

739
					SrcSlotNumber = mouseModule.mouseController.GetAttachedSlotNumber()

740
					DstSlotNumber = SlotIndex

741
742
					itemID = player.GetItemIndex(attachedInvenType, SrcSlotNumber)

743
					item.SelectItem(itemID)

744
745
					if item.IsAntiFlag(item.ANTIFLAG_GIVE):

746
						chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)

747
						mouseModule.mouseController.DeattachObject()

748
						return

749
750
					if app.ENABLE_SOULBIND_SYSTEM:

751
						if player.GetItemSealDate(attachedInvenType, SrcSlotNumber):

752
							chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE_SEAL_ITEM)

753
							return

754
755
					net.SendExchangeItemAddPacket(attachedInvenType, SrcSlotNumber, DstSlotNumber)

756
757
			mouseModule.mouseController.DeattachObject()

758
759
		def SelectOwnerItemSlot(self, SlotIndex):

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

762
763
				money = mouseModule.mouseController.GetAttachedItemCount()

764
				net.SendExchangeElkAddPacket(money)

765
766
		def RefreshOwnerSlot(self):

767
			for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

768
				itemIndex = exchange.GetItemVnumFromSelf(i)

769
				itemCount = exchange.GetItemCountFromSelf(i)

770
				if 1 == itemCount:

771
					itemCount = 0

772
				self.OwnerSlot.SetItemSlot(i, itemIndex, itemCount)

773
			self.OwnerSlot.RefreshSlot()

774
775
		def RefreshTargetSlot(self):

776
			for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):

777
				itemIndex = exchange.GetItemVnumFromTarget(i)

778
				itemCount = exchange.GetItemCountFromTarget(i)

779
				if 1 == itemCount:

780
					itemCount = 0

781
				self.TargetSlot.SetItemSlot(i, itemIndex, itemCount)

782
			self.TargetSlot.RefreshSlot()

783
784
		def Refresh(self):

785
786
			self.RefreshOwnerSlot()

787
			self.RefreshTargetSlot()

788
789
			self.OwnerMoney.SetText(localeInfo.NumberToMoneyString(exchange.GetElkFromSelf()))

790
			self.TargetMoney.SetText(localeInfo.NumberToMoneyString(exchange.GetElkFromTarget()))

791
792
			if True == exchange.GetAcceptFromSelf():

793
				self.OwnerAcceptLight.Down()

794
			else:

795
				self.AcceptButton.Enable()

796
				self.AcceptButton.SetUp()

797
				self.OwnerAcceptLight.SetUp()

798
799
			if True == exchange.GetAcceptFromTarget():

800
				self.TargetAcceptLight.Down()

801
			else:

802
				self.TargetAcceptLight.SetUp()

803
804
		def OverInOwnerItem(self, slotIndex):

805
806
			if 0 != self.tooltipItem:

807
				self.tooltipItem.SetExchangeOwnerItem(slotIndex)

808
809
		def OverInTargetItem(self, slotIndex):

810
811
			if 0 != self.tooltipItem:

812
				self.tooltipItem.SetExchangeTargetItem(slotIndex)

813
814
		def OverOutItem(self):

815
816
			if 0 != self.tooltipItem:

817
				self.tooltipItem.HideToolTip()

818
819
		def OnTop(self):

820
			self.tooltipItem.SetTop()

821
822
		def OnUpdate(self):

823
824
			USE_EXCHANGE_LIMIT_RANGE = 1000

825
826
			(x, y, z) = player.GetMainCharacterPosition()

827
			if abs(x - self.xStart) > USE_EXCHANGE_LIMIT_RANGE or abs(y - self.yStart) > USE_EXCHANGE_LIMIT_RANGE:

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

829
				net.SendExchangeExitPacket()

830
        

    


            


                                


        

            



                
    

        Public Pastes
    

    
            

    

                    

        

    





    


    
    
    
    
    
    
    
    




    


    



                

            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!