Problem z Clientem

Mr-OMGWTF · 27 Lutego 2014

Pobrałem pliki Terenzo + Clienta serwer działa a gdy loguje się do gry pisze zostałeś połączony i client się wyłącza tutai syserr

0227 22:02:10281 :: 
networkModule.py(line:200) SetSelectCharacterPhase
system.py(line:130) __pack_import
system.py(line:110) _process_result
introSelect.py(line:23) ?
system.py(line:130) __pack_import
system.py(line:110) _process_result
uiAffectShower.py(line:8) ?
system.py(line:130) __pack_import

networkModule.SetSelectCharacterPhase - exceptions.IndentationError:expected an indented block (line 97)

0227 22:02:10282 :: ============================================================================================================
0227 22:02:10282 :: Abort!!!!

Czegewara. · 27 Lutego 2014

gdzieś masz spacje w tabach albo nie masz tabów edytowałeś cos w root ?

Mr-OMGWTF · 27 Lutego 2014

tak plik uitooltip

dodałem to poniżej bo client po wybraniu postaci był czarny .

2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
import dbg
import player
import item
import grp
import wndMgr
import skill
import shop
import exchange
import grpText
import safebox
import locale
import app
import background
import nonplayer
import chr
 
import ui
import mouseModule
import constInfo
 
WARP_SCROLLS = [22011, 22000, 22010]
 
DESC_DEFAULT_MAX_COLS = 26 
DESC_WESTERN_MAX_COLS = 35
DESC_WESTERN_MAX_WIDTH = 220
 
def chop(n):
return round(n - 0.5, 1)
 
def SplitDescription(desc, limit):
total_tokens = desc.split()
line_tokens = []
line_len = 0
lines = []
for token in total_tokens:
if "|" in token:
sep_pos = token.find("|")
line_tokens.append(token[:sep_pos])
 
lines.append(" ".join(line_tokens))
line_len = len(token) - (sep_pos + 1)
line_tokens = [token[sep_pos+1:]]
else:
line_len += len(token)
if len(line_tokens) + line_len > limit:
lines.append(" ".join(line_tokens))
line_len = len(token)
line_tokens = [token]
else:
line_tokens.append(token)
 
if line_tokens:
lines.append(" ".join(line_tokens))
 
return lines
 
###################################################################################################
## ToolTip
##
##   NOTE : Ă‡Ă¶Ĺ”Ă§Â´Ă‚ ItemÂ°Ăş SkillĹ”Â» Â»ĂłÄ˝Ă“Ĺ”Â¸Â·ĂŽ Ä†Ĺ»ÄŚÂ ËťÄ‚Ă„ĹÂµĂŽÄľĂşĹ”Ëť
##          Ă‡ÄŽĂĂ¶Â¸Â¸ Â±Ă—Â´Ĺ®ĂĂ¶ Ĺ”Ă‡Ä…ÄšÂ°Ë‡ ÄľĹ™ÄľĂ® ĹźÂ¸Ĺ”Ă“
##
class ToolTip(ui.ThinBoard):
 
TOOL_TIP_WIDTH = 190
TOOL_TIP_HEIGHT = 10
 
TEXT_LINE_HEIGHT = 17
 
TITLE_COLOR = grp.GenerateColor(0.9490, 0.9058, 0.7568, 1.0)
SPECIAL_TITLE_COLOR = grp.GenerateColor(1.0, 0.7843, 0.0, 1.0)
NORMAL_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
FONT_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
PRICE_COLOR = 0xffFFB96D
 
HIGH_PRICE_COLOR = SPECIAL_TITLE_COLOR
MIDDLE_PRICE_COLOR = grp.GenerateColor(0.85, 0.85, 0.85, 1.0)
LOW_PRICE_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)
 
ENABLE_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
DISABLE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
 
NEGATIVE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
POSITIVE_COLOR = grp.GenerateColor(0.5411, 0.7254, 0.5568, 1.0)
SPECIAL_POSITIVE_COLOR = grp.GenerateColor(0.6911, 0.8754, 0.7068, 1.0)
SPECIAL_POSITIVE_COLOR2 = grp.GenerateColor(0.8824, 0.9804, 0.8824, 1.0)
 
CONDITION_COLOR = 0xffBEB47D
CAN_LEVEL_UP_COLOR = 0xff8EC292
CANNOT_LEVEL_UP_COLOR = DISABLE_COLOR
NEED_SKILL_POINT_COLOR = 0xff9A9CDB
 
def __init__(self, width = TOOL_TIP_WIDTH, isPickable=FALSE):
ui.ThinBoard.__init__(self, "TOP_MOST")
 
if isPickable:
pass
else:
self.AddFlag("not_pick")
 
self.AddFlag("float")
 
self.followFlag = TRUE
self.toolTipWidth = width
 
self.xPos = -1
self.yPos = -1
 
self.defFontName = locale.UI_DEF_FONT
self.ClearToolTip()
 
def __del__(self):
ui.ThinBoard.__del__(self)
 
def ClearToolTip(self):
self.toolTipHeight = 12
self.childrenList = []
 
def SetFollow(self, flag):
self.followFlag = flag
 
def SetDefaultFontName(self, fontName):
self.defFontName = fontName
 
def AppendSpace(self, size):
self.toolTipHeight += size
self.ResizeToolTip()
 
def AppendHorizontalLine(self):
 
for i in xrange(2):
horizontalLine = ui.Line()
horizontalLine.SetParent(self)
horizontalLine.SetPosition(0, self.toolTipHeight + 3 + i)
horizontalLine.SetWindowHorizontalAlignCenter()
horizontalLine.SetSize(150, 0)
horizontalLine.Show()
 
if 0 == i:
horizontalLine.SetColor(0xff555555)
else:
horizontalLine.SetColor(0xff000000)
 
self.childrenList.append(horizontalLine)
 
self.toolTipHeight += 11
self.ResizeToolTip()
 
def AlignHorizonalCenter(self):
for child in self.childrenList:
(x, y)=child.GetLocalPosition()
child.SetPosition(self.toolTipWidth/2, y)
 
self.ResizeToolTip()
 
def AutoAppendTextLine(self, text, color = FONT_COLOR, centerAlign = TRUE):
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPackedFontColor(color)
textLine.SetText(text)
textLine.SetOutline()
textLine.SetFeather(FALSE)
textLine.Show()
 
if centerAlign:
textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
textLine.SetHorizontalAlignCenter()
 
else:
textLine.SetPosition(10, self.toolTipHeight)
 
self.childrenList.append(textLine)
 
(textWidth, textHeight)=textLine.GetTextSize()
 
textWidth += 40
textHeight += 5
 
if self.toolTipWidth < textWidth:
self.toolTipWidth = textWidth
 
self.toolTipHeight += textHeight
 
return textLine
 
def AppendTextLine(self, text, color = FONT_COLOR, centerAlign = TRUE):
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPackedFontColor(color)
textLine.SetText(text)
textLine.SetOutline()
textLine.SetFeather(FALSE)
textLine.Show()
 
if centerAlign:
textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
textLine.SetHorizontalAlignCenter()
 
else:
textLine.SetPosition(10, self.toolTipHeight)
 
self.childrenList.append(textLine)
 
self.toolTipHeight += self.TEXT_LINE_HEIGHT
self.ResizeToolTip()
 
return textLine
 
def AppendDescription(self, desc, limit, color = FONT_COLOR):
if locale.IsEUROPE():
self.__AppendDescription_WesternLanguage(desc, color)
else:
self.__AppendDescription_EasternLanguage(desc, limit, color)
 
def __AppendDescription_EasternLanguage(self, description, characterLimitation, color=FONT_COLOR):
length = len(description)
if 0 == length:
return
 
lineCount = grpText.GetSplitingTextLineCount(description, characterLimitation)
for i in xrange(lineCount):
if 0 == i:
self.AppendSpace(5)
self.AppendTextLine(grpText.GetSplitingTextLine(description, characterLimitation, i), color)
 
def __AppendDescription_WesternLanguage(self, desc, color=FONT_COLOR):
lines = SplitDescription(desc, DESC_WESTERN_MAX_COLS)
if not lines:
return
 
self.AppendSpace(5)
for line in lines:
self.AppendTextLine(line, color)
 
 
def ResizeToolTip(self):
self.SetSize(self.toolTipWidth, self.TOOL_TIP_HEIGHT + self.toolTipHeight)
 
def SetTitle(self, name):
self.AppendTextLine(name, self.TITLE_COLOR)
 
def GetLimitTextLineColor(self, curValue, limitValue):
if curValue < limitValue:
return self.DISABLE_COLOR
 
return self.ENABLE_COLOR
 
def GetChangeTextLineColor(self, value, isSpecial=FALSE):
if value > 0:
if isSpecial:
return self.SPECIAL_POSITIVE_COLOR
else:
return self.POSITIVE_COLOR
 
if 0 == value:
return self.NORMAL_COLOR
 
return self.NEGATIVE_COLOR
 
def SetToolTipPosition(self, x = -1, y = -1):
self.xPos = x
self.yPos = y
 
def ShowToolTip(self):
self.SetTop()
self.Show()
 
self.OnUpdate()
 
def HideToolTip(self):
self.Hide()
 
def OnUpdate(self):
 
if not self.followFlag:
return
 
x = 0
y = 0
width = self.GetWidth()
height = self.toolTipHeight
 
if -1 == self.xPos and -1 == self.yPos:
 
(mouseX, mouseY) = wndMgr.GetMousePosition()
 
if mouseY < wndMgr.GetScreenHeight() - 300:
y = mouseY + 40
else:
y = mouseY - height - 30
 
x = mouseX - width/2 
 
else:
 
x = self.xPos - width/2
y = self.yPos - height
 
x = max(x, 0)
y = max(y, 0)
x = min(x + width/2, wndMgr.GetScreenWidth() - width/2) - width/2
y = min(y + self.GetHeight(), wndMgr.GetScreenHeight()) - self.GetHeight()
 
parentWindow = self.GetParentProxy()
if parentWindow:
(gx, gy) = parentWindow.GetGlobalPosition()
x -= gx
y -= gy
 
self.SetPosition(x, y)
 
class ItemToolTip(ToolTip):
 
CHARACTER_NAMES = ( 
locale.TOOLTIP_WARRIOR,
locale.TOOLTIP_ASSASSIN,
locale.TOOLTIP_SURA,
locale.TOOLTIP_SHAMAN 
) 
 
CHARACTER_COUNT = len(CHARACTER_NAMES)
WEAR_NAMES = ( 
locale.TOOLTIP_ARMOR, 
locale.TOOLTIP_HELMET, 
locale.TOOLTIP_SHOES, 
locale.TOOLTIP_WRISTLET, 
locale.TOOLTIP_WEAPON, 
locale.TOOLTIP_NECK,
locale.TOOLTIP_EAR,
locale.TOOLTIP_UNIQUE,
locale.TOOLTIP_SHIELD,
locale.TOOLTIP_ARROW,
)
WEAR_COUNT = len(WEAR_NAMES)
 
AFFECT_DICT = {
item.APPLY_MAX_HP : locale.TOOLTIP_MAX_HP,
item.APPLY_MAX_SP : locale.TOOLTIP_MAX_SP,
item.APPLY_CON : locale.TOOLTIP_CON,
item.APPLY_INT : locale.TOOLTIP_INT,
item.APPLY_STR : locale.TOOLTIP_STR,
item.APPLY_DEX : locale.TOOLTIP_DEX,
item.APPLY_ATT_SPEED : locale.TOOLTIP_ATT_SPEED,
item.APPLY_MOV_SPEED : locale.TOOLTIP_MOV_SPEED,
item.APPLY_CAST_SPEED : locale.TOOLTIP_CAST_SPEED,
item.APPLY_HP_REGEN : locale.TOOLTIP_HP_REGEN,
item.APPLY_SP_REGEN : locale.TOOLTIP_SP_REGEN,
item.APPLY_POISON_PCT : locale.TOOLTIP_APPLY_POISON_PCT,
item.APPLY_STUN_PCT : locale.TOOLTIP_APPLY_STUN_PCT,
item.APPLY_SLOW_PCT : locale.TOOLTIP_APPLY_SLOW_PCT,
item.APPLY_CRITICAL_PCT : locale.TOOLTIP_APPLY_CRITICAL_PCT,
item.APPLY_PENETRATE_PCT : locale.TOOLTIP_APPLY_PENETRATE_PCT,
 
item.APPLY_ATTBONUS_WARRIOR : locale.TOOLTIP_APPLY_ATTBONUS_WARRIOR,
item.APPLY_ATTBONUS_ASSASSIN : locale.TOOLTIP_APPLY_ATTBONUS_ASSASSIN,
item.APPLY_ATTBONUS_SURA : locale.TOOLTIP_APPLY_ATTBONUS_SURA,
item.APPLY_ATTBONUS_SHAMAN : locale.TOOLTIP_APPLY_ATTBONUS_SHAMAN,
item.APPLY_ATTBONUS_MONSTER : locale.TOOLTIP_APPLY_ATTBONUS_MONSTER,
 
item.APPLY_ATTBONUS_HUMAN : locale.TOOLTIP_APPLY_ATTBONUS_HUMAN,
item.APPLY_ATTBONUS_ANIMAL : locale.TOOLTIP_APPLY_ATTBONUS_ANIMAL,
item.APPLY_ATTBONUS_ORC : locale.TOOLTIP_APPLY_ATTBONUS_ORC,
item.APPLY_ATTBONUS_MILGYO : locale.TOOLTIP_APPLY_ATTBONUS_MILGYO,
item.APPLY_ATTBONUS_UNDEAD : locale.TOOLTIP_APPLY_ATTBONUS_UNDEAD,
item.APPLY_ATTBONUS_DEVIL : locale.TOOLTIP_APPLY_ATTBONUS_DEVIL,
item.APPLY_STEAL_HP : locale.TOOLTIP_APPLY_STEAL_HP,
item.APPLY_STEAL_SP : locale.TOOLTIP_APPLY_STEAL_SP,
item.APPLY_MANA_BURN_PCT : locale.TOOLTIP_APPLY_MANA_BURN_PCT,
item.APPLY_DAMAGE_SP_RECOVER : locale.TOOLTIP_APPLY_DAMAGE_SP_RECOVER,
item.APPLY_BLOCK : locale.TOOLTIP_APPLY_BLOCK,
item.APPLY_DODGE : locale.TOOLTIP_APPLY_DODGE,
item.APPLY_RESIST_SWORD : locale.TOOLTIP_APPLY_RESIST_SWORD,
item.APPLY_RESIST_TWOHAND : locale.TOOLTIP_APPLY_RESIST_TWOHAND,
item.APPLY_RESIST_DAGGER : locale.TOOLTIP_APPLY_RESIST_DAGGER,
item.APPLY_RESIST_BELL : locale.TOOLTIP_APPLY_RESIST_BELL,
item.APPLY_RESIST_FAN : locale.TOOLTIP_APPLY_RESIST_FAN,
item.APPLY_RESIST_BOW : locale.TOOLTIP_RESIST_BOW,
item.APPLY_RESIST_FIRE : locale.TOOLTIP_RESIST_FIRE,
item.APPLY_RESIST_ELEC : locale.TOOLTIP_RESIST_ELEC,
item.APPLY_RESIST_MAGIC : locale.TOOLTIP_RESIST_MAGIC,
item.APPLY_RESIST_WIND : locale.TOOLTIP_APPLY_RESIST_WIND,
item.APPLY_REFLECT_MELEE : locale.TOOLTIP_APPLY_REFLECT_MELEE,
item.APPLY_REFLECT_CURSE : locale.TOOLTIP_APPLY_REFLECT_CURSE,
item.APPLY_POISON_REDUCE : locale.TOOLTIP_APPLY_POISON_REDUCE,
item.APPLY_KILL_SP_RECOVER : locale.TOOLTIP_APPLY_KILL_SP_RECOVER,
item.APPLY_EXP_DOUBLE_BONUS : locale.TOOLTIP_APPLY_EXP_DOUBLE_BONUS,
item.APPLY_GOLD_DOUBLE_BONUS : locale.TOOLTIP_APPLY_GOLD_DOUBLE_BONUS,
item.APPLY_ITEM_DROP_BONUS : locale.TOOLTIP_APPLY_ITEM_DROP_BONUS,
item.APPLY_POTION_BONUS : locale.TOOLTIP_APPLY_POTION_BONUS,
item.APPLY_KILL_HP_RECOVER : locale.TOOLTIP_APPLY_KILL_HP_RECOVER,
item.APPLY_IMMUNE_STUN : locale.TOOLTIP_APPLY_IMMUNE_STUN,
item.APPLY_IMMUNE_SLOW : locale.TOOLTIP_APPLY_IMMUNE_SLOW,
item.APPLY_IMMUNE_FALL : locale.TOOLTIP_APPLY_IMMUNE_FALL,
item.APPLY_BOW_DISTANCE : locale.TOOLTIP_BOW_DISTANCE,
item.APPLY_DEF_GRADE_BONUS : locale.TOOLTIP_DEF_GRADE,
item.APPLY_ATT_GRADE_BONUS : locale.TOOLTIP_ATT_GRADE,
item.APPLY_MAGIC_ATT_GRADE : locale.TOOLTIP_MAGIC_ATT_GRADE,
item.APPLY_MAGIC_DEF_GRADE : locale.TOOLTIP_MAGIC_DEF_GRADE,
item.APPLY_MAX_STAMINA : locale.TOOLTIP_MAX_STAMINA,
item.APPLY_MALL_ATTBONUS : locale.TOOLTIP_MALL_ATTBONUS,
item.APPLY_MALL_DEFBONUS : locale.TOOLTIP_MALL_DEFBONUS,
item.APPLY_MALL_EXPBONUS : locale.TOOLTIP_MALL_EXPBONUS,
item.APPLY_MALL_ITEMBONUS : locale.TOOLTIP_MALL_ITEMBONUS,
item.APPLY_MALL_GOLDBONUS : locale.TOOLTIP_MALL_GOLDBONUS,
item.APPLY_SKILL_DAMAGE_BONUS : locale.TOOLTIP_SKILL_DAMAGE_BONUS,
item.APPLY_NORMAL_HIT_DAMAGE_BONUS : locale.TOOLTIP_NORMAL_HIT_DAMAGE_BONUS,
item.APPLY_SKILL_DEFEND_BONUS : locale.TOOLTIP_SKILL_DEFEND_BONUS,
item.APPLY_NORMAL_HIT_DEFEND_BONUS : locale.TOOLTIP_NORMAL_HIT_DEFEND_BONUS,
item.APPLY_PC_BANG_EXP_BONUS : locale.TOOLTIP_MALL_EXPBONUS_P_STATIC,
item.APPLY_PC_BANG_DROP_BONUS : locale.TOOLTIP_MALL_ITEMBONUS_P_STATIC,
item.APPLY_RESIST_WARRIOR : locale.TOOLTIP_APPLY_RESIST_WARRIOR,
item.APPLY_RESIST_ASSASSIN : locale.TOOLTIP_APPLY_RESIST_ASSASSIN,
item.APPLY_RESIST_SURA : locale.TOOLTIP_APPLY_RESIST_SURA,
item.APPLY_RESIST_SHAMAN : locale.TOOLTIP_APPLY_RESIST_SHAMAN,
item.APPLY_MAX_HP_PCT : locale.TOOLTIP_APPLY_MAX_HP_PCT,
item.APPLY_MAX_SP_PCT : locale.TOOLTIP_APPLY_MAX_SP_PCT,
item.APPLY_ENERGY : locale.TOOLTIP_ENERGY,
item.APPLY_COSTUME_ATTR_BONUS : locale.TOOLTIP_COSTUME_ATTR_BONUS,
 
# item.APPLY_MAGIC_ATTBONUS_PER : locale.TOOLTIP_MAGIC_ATTBONUS_PER,
# item.APPLY_MELEE_MAGIC_ATTBONUS_PER : locale.TOOLTIP_MELEE_MAGIC_ATTBONUS_PER,
# item.APPLY_RESIST_ICE : locale.TOOLTIP_RESIST_ICE,
# item.APPLY_RESIST_EARTH : locale.TOOLTIP_RESIST_EARTH,
# item.APPLY_RESIST_DARK : locale.TOOLTIP_RESIST_DARK,
# item.APPLY_ANTI_CRITICAL_PCT : locale.TOOLTIP_ANTI_CRITICAL_PCT,
# item.APPLY_ANTI_PENETRATE_PCT : locale.TOOLTIP_ANTI_PENETRATE_PCT,
}
 
ATTRIBUTE_NEED_WIDTH = {
23 : 230,
24 : 230,
25 : 230,
26 : 220,
27 : 210,
 
35 : 210,
36 : 210,
37 : 210,
38 : 210,
39 : 210,
40 : 210,
41 : 210,
 
42 : 220,
43 : 230,
45 : 230,
}
 
ANTI_FLAG_DICT = {
0 : item.ITEM_ANTIFLAG_WARRIOR,
1 : item.ITEM_ANTIFLAG_ASSASSIN,
2 : item.ITEM_ANTIFLAG_SURA,
3 : item.ITEM_ANTIFLAG_SHAMAN,
}
 
FONT_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
 
def __init__(self, *args, **kwargs):
ToolTip.__init__(self, *args, **kwargs)
self.itemVnum = 0
self.isShopItem = FALSE
 
# ÄľÄ†Ĺ”ÄšÄąĹ° ÄąĹ™Ä†ĂĹ”Â» Ă‡Ä„ËťÄ‚Ă‡Ĺ‡ Â¶Â§ Ă‡Ă¶Ĺ”Ă§ Ă„Ĺ‚Â¸Ĺ»ÄąĂŤÂ°Ë‡ Ă‚Ĺ™ĹĽĂ«Ă‡Ĺ‡ Ä˝Ă¶ ÄľĹ™Â´Ă‚ ÄľÄ†Ĺ”ÄšÄąĹ°Ĺ”ÄšÂ¶ĂłÂ¸Ă© Â°ÂĂÂ¦Â·ĂŽ Disable ColorÂ·ĂŽ Ä˝Ĺ‚ĂÂ¤ (Ĺ”ÄšÄ…Äš Â±Ă—Â·Â¸Â°Ă” Ĺ”Ĺ°ÂµĹĽĂ‡ÄŽÂ°Ă Ĺ”Ă–Ĺ”Â¸Ĺ‚Ĺž Ë›Â¨ÄľĂź Ă‡Ĺ‡ Ă‡ÄĹĽĂ¤Â°Ë‡ Ĺ”Ă–ÄľĂ®Ä˝Â)
self.bCannotUseItemForceSetDisableColor = TRUE 
 
def __del__(self):
ToolTip.__del__(self)
 
def SetCannotUseItemForceSetDisableColor(self, enable):
self.bCannotUseItemForceSetDisableColor = enable
 
def CanEquip(self):
if not item.IsEquipmentVID(self.itemVnum):
return TRUE
 
race = player.GetRace()
job = chr.RaceToJob(race)
if not self.ANTI_FLAG_DICT.has_key(job):
return FALSE
 
if item.IsAntiFlag(self.ANTI_FLAG_DICT[job]):
return FALSE
 
sex = chr.RaceToSex(race)
 
MALE = 1
FEMALE = 0
 
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE) and sex == MALE:
return FALSE
 
if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE) and sex == FEMALE:
return FALSE
 
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
 
if item.LIMIT_LEVEL == limitType:
if player.GetStatus(player.LEVEL) < limitValue:
return FALSE
"""
elif item.LIMIT_STR == limitType:
if player.GetStatus(player.ST) < limitValue:
return FALSE
elif item.LIMIT_DEX == limitType:
if player.GetStatus(player.DX) < limitValue:
return FALSE
elif item.LIMIT_INT == limitType:
if player.GetStatus(player.IQ) < limitValue:
return FALSE
elif item.LIMIT_CON == limitType:
if player.GetStatus(player.HT) < limitValue:
return FALSE
"""
 
return TRUE
 
def AppendTextLine(self, text, color = FONT_COLOR, centerAlign = TRUE):
if not self.CanEquip() and self.bCannotUseItemForceSetDisableColor:
color = self.DISABLE_COLOR
 
return ToolTip.AppendTextLine(self, text, color, centerAlign)
 
def ClearToolTip(self):
self.isShopItem = FALSE
self.toolTipWidth = self.TOOL_TIP_WIDTH
ToolTip.ClearToolTip(self)
 
def SetInventoryItem(self, slotIndex):
itemVnum = player.GetItemIndex(slotIndex)
if 0 == itemVnum:
return
 
self.ClearToolTip()
if shop.IsOpen():
if not shop.IsPrivateShop():
item.SelectItem(itemVnum)
self.AppendSellingPrice(player.GetISellItemPrice(slotIndex))
 
metinSlot = [player.GetItemMetinSocket(slotIndex, i) for i in xrange(player.METIN_SOCKET_MAX_NUM)]
attrSlot = [player.GetItemAttribute(slotIndex, i) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
 
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def SetShopItem(self, slotIndex):
itemVnum = shop.GetItemID(slotIndex)
if 0 == itemVnum:
return
 
price = shop.GetItemPrice(slotIndex)
self.ClearToolTip()
self.isShopItem = TRUE
 
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(shop.GetItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(shop.GetItemAttribute(slotIndex, i))
 
self.AddItemData(itemVnum, metinSlot, attrSlot)
self.AppendPrice(price)
 
def SetExchangeOwnerItem(self, slotIndex):
itemVnum = exchange.GetItemVnumFromSelf(slotIndex)
if 0 == itemVnum:
return
 
self.ClearToolTip()
 
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(exchange.GetItemMetinSocketFromSelf(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(exchange.GetItemAttributeFromSelf(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def SetExchangeTargetItem(self, slotIndex):
itemVnum = exchange.GetItemVnumFromTarget(slotIndex)
if 0 == itemVnum:
return
 
self.ClearToolTip()
 
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(exchange.GetItemMetinSocketFromTarget(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(exchange.GetItemAttributeFromTarget(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def SetPrivateShopBuilderItem(self, invenType, invenPos, privateShopSlotIndex):
itemVnum = player.GetItemIndex(invenType, invenPos)
if 0 == itemVnum:
return
 
item.SelectItem(itemVnum)
self.ClearToolTip()
self.AppendSellingPrice(shop.GetPrivateShopItemPrice(invenType, invenPos))
 
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(player.GetItemMetinSocket(invenPos, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(player.GetItemAttribute(invenPos, i))
 
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def SetSafeBoxItem(self, slotIndex):
itemVnum = safebox.GetItemID(slotIndex)
if 0 == itemVnum:
return
 
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(safebox.GetItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(safebox.GetItemAttribute(slotIndex, i))
 
self.AddItemData(itemVnum, metinSlot, attrSlot, safebox.GetItemFlags(slotIndex))
 
def SetMallItem(self, slotIndex):
itemVnum = safebox.GetMallItemID(slotIndex)
if 0 == itemVnum:
return
 
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(safebox.GetMallItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(safebox.GetMallItemAttribute(slotIndex, i))
 
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def SetItemToolTip(self, itemVnum):
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(0)
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append((0, 0))
 
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def __AppendAttackSpeedInfo(self, item):
atkSpd = item.GetValue(0)
 
if atkSpd < 80:
stSpd = locale.TOOLTIP_ITEM_VERY_FAST
elif atkSpd <= 95:
stSpd = locale.TOOLTIP_ITEM_FAST
elif atkSpd <= 105:
stSpd = locale.TOOLTIP_ITEM_NORMAL
elif atkSpd <= 120:
stSpd = locale.TOOLTIP_ITEM_SLOW
else:
stSpd = locale.TOOLTIP_ITEM_VERY_SLOW
 
self.AppendTextLine(locale.TOOLTIP_ITEM_ATT_SPEED % stSpd, self.NORMAL_COLOR)
 
def __AppendAttackGradeInfo(self):
atkGrade = item.GetValue(1)
self.AppendTextLine(locale.TOOLTIP_ITEM_ATT_GRADE % atkGrade, self.GetChangeTextLineColor(atkGrade))
 
def __AppendAttackPowerInfo(self):
minPower = item.GetValue(3)
maxPower = item.GetValue(4)
addPower = item.GetValue(5)
if maxPower > minPower:
self.AppendTextLine(locale.TOOLTIP_ITEM_ATT_POWER % (minPower+addPower, maxPower+addPower), self.POSITIVE_COLOR)
else:
self.AppendTextLine(locale.TOOLTIP_ITEM_ATT_POWER_ONE_ARG % (minPower+addPower), self.POSITIVE_COLOR)
 
def __AppendMagicAttackInfo(self):
minMagicAttackPower = item.GetValue(1)
maxMagicAttackPower = item.GetValue(2)
addPower = item.GetValue(5)
 
if minMagicAttackPower > 0 or maxMagicAttackPower > 0:
if maxMagicAttackPower > minMagicAttackPower:
self.AppendTextLine(locale.TOOLTIP_ITEM_MAGIC_ATT_POWER % (minMagicAttackPower+addPower, maxMagicAttackPower+addPower), self.POSITIVE_COLOR)
else:
self.AppendTextLine(locale.TOOLTIP_ITEM_MAGIC_ATT_POWER_ONE_ARG % (minMagicAttackPower+addPower), self.POSITIVE_COLOR)
 
def __AppendMagicDefenceInfo(self):
magicDefencePower = item.GetValue(0)
 
if magicDefencePower > 0:
self.AppendTextLine(locale.TOOLTIP_ITEM_MAGIC_DEF_POWER % magicDefencePower, self.GetChangeTextLineColor(magicDefencePower))
 
def __AppendAttributeInformation(self, attrSlot):
if 0 != attrSlot:
 
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
value = attrSlot[i][1]
 
if 0 == value:
continue
 
affectString = self.__GetAffectString(type, value)
if affectString:
affectColor = self.__GetAttributeColor(i, value)
self.AppendTextLine(affectString, affectColor)
 
def __GetAttributeColor(self, index, value):
if value > 0:
if index >= 5:
return self.SPECIAL_POSITIVE_COLOR2
else:
return self.SPECIAL_POSITIVE_COLOR
elif value == 0:
return self.NORMAL_COLOR
else:
return self.NEGATIVE_COLOR
 
def __IsPolymorphItem(self, itemVnum):
if itemVnum >= 70103 and itemVnum <= 70106:
return 1
return 0
 
def __SetPolymorphItemTitle(self, monsterVnum):
if locale.IsVIETNAM():
itemName =item.GetItemName()
itemName+=" "
itemName+=nonplayer.GetMonsterName(monsterVnum)
else:
itemName =nonplayer.GetMonsterName(monsterVnum)
itemName+=" "
itemName+=item.GetItemName()
self.SetTitle(itemName)
 
def __SetNormalItemTitle(self):
self.SetTitle(item.GetItemName())
 
def __SetSpecialItemTitle(self):
self.AppendTextLine(item.GetItemName(), self.SPECIAL_TITLE_COLOR)
 
def __SetItemTitle(self, itemVnum, metinSlot, attrSlot):
if locale.IsCANADA():
if 72726 == itemVnum or 72730 == itemVnum:
self.AppendTextLine(item.GetItemName(), grp.GenerateColor(1.0, 0.7843, 0.0, 1.0))
return
 
if self.__IsPolymorphItem(itemVnum):
self.__SetPolymorphItemTitle(metinSlot[0])
else:
if self.__IsAttr(attrSlot):
self.__SetSpecialItemTitle()
return
 
self.__SetNormalItemTitle()
 
def __IsAttr(self, attrSlot):
if not attrSlot:
return FALSE
 
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
if 0 != type:
return TRUE
 
return FALSE
 
def AddRefineItemData(self, itemVnum, metinSlot, attrSlot = 0):
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlotData=metinSlot[i]
if self.GetMetinItemIndex(metinSlotData) == constInfo.ERROR_METIN_STONE:
metinSlot[i]=player.METIN_SOCKET_TYPE_SILVER
 
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
def AddItemData_Offline(self, itemVnum, itemDesc, itemSummary, metinSlot, attrSlot):
self.__AdjustMaxWidth(attrSlot, itemDesc)
self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
 
if self.__IsHair(itemVnum): 
self.__AppendHairIcon(itemVnum)
 
### Description ###
self.AppendDescription(itemDesc, 26)
self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)
 
def AddItemData(self, itemVnum, metinSlot, attrSlot = 0, flags = 0, unbindTime = 0):
self.itemVnum = itemVnum
item.SelectItem(itemVnum)
itemType = item.GetItemType()
itemSubType = item.GetItemSubType()
 
if 50026 == itemVnum:
if 0 != metinSlot:
name = item.GetItemName()
if metinSlot[0] > 0:
name += " "
name += locale.NumberToMoneyString(metinSlot[0])
self.SetTitle(name)
self.ShowToolTip()
return
 
### Skill Book ###
elif 50300 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], locale.TOOLTIP_SKILLBOOK_NAME, 1)
self.ShowToolTip()
return 
elif 70037 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], locale.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
elif 70055 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], locale.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
###########################################################################################
 
 
itemDesc = item.GetItemDescription()
itemSummary = item.GetItemSummary()
 
isCostumeItem = 0
isCostumeHair = 0
isCostumeBody = 0
 
if app.ENABLE_COSTUME_SYSTEM:
if item.ITEM_TYPE_COSTUME == itemType:
isCostumeItem = 1
isCostumeHair = item.COSTUME_TYPE_HAIR == itemSubType
isCostumeBody = item.COSTUME_TYPE_BODY == itemSubType
 
#dbg.TraceError("IS_COSTUME_ITEM! body(%d) hair(%d)" % (isCostumeBody, isCostumeHair))
 
self.__AdjustMaxWidth(attrSlot, itemDesc)
self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
 
### Hair Preview Image ###
if self.__IsHair(itemVnum): 
self.__AppendHairIcon(itemVnum)
 
### Description ###
self.AppendDescription(itemDesc, 26)
self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)
 
### Weapon ###
if item.ITEM_TYPE_WEAPON == itemType:
 
self.__AppendLimitInformation()
 
self.AppendSpace(5)
 
## ĹźĂŽÄ‚Â¤Ĺ”ÄŽ Â°Ä‡ĹĽÄ› Â¸Â¶Â°Ĺ™Ĺ”Â» Â¸ĹĹ”Ăş Ă‡Ä„ËťÄ‚Ă‡ĹÂ´Ĺ®.
if item.WEAPON_FAN == itemSubType:
self.__AppendMagicAttackInfo()
self.__AppendAttackPowerInfo()
 
else:
self.__AppendAttackPowerInfo()
self.__AppendMagicAttackInfo()
 
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
 
self.AppendWearableInformation()
self.__AppendMetinSlotInfo(metinSlot)
 
### Armor ###
elif item.ITEM_TYPE_ARMOR == itemType:
self.__AppendLimitInformation()
 
## Ä…Ä‡ÄľĂ®Â·Ă‚
defGrade = item.GetValue(1)
defBonus = item.GetValue(5)*2 ## Ä…Ä‡ÄľĂ®Â·Ă‚ Ă‡Ä„ËťÄ‚ Ĺ”ĂźÂ¸Ĺ™ ÂµĂ‡Â´Ă‚ Ä…Â®ĂÂ¦Â¸Â¦ Ä˝Ă¶ĂÂ¤
if defGrade > 0:
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_ITEM_DEF_GRADE % (defGrade+defBonus), self.GetChangeTextLineColor(defGrade))
 
self.__AppendMagicDefenceInfo()
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
 
self.AppendWearableInformation()
 
if itemSubType in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR): 
self.__AppendAccessoryMetinSlotInfo(metinSlot, constInfo.GET_ACCESSORY_MATERIAL_VNUM(itemVnum, itemSubType))
else:
self.__AppendMetinSlotInfo(metinSlot)
 
## Ă„ĂšËťĹźÄ‚Ĺ‘ ÄľÄ†Ĺ”ÄšÄąĹ° ##
elif 0 != isCostumeItem:
self.__AppendLimitInformation()
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
 
self.AppendWearableInformation()
 
bHasRealtimeFlag = 0
 
## Â»Ă§ĹĽĂ«Â°Ë‡Â´Ă‰ ËťÄ‚Â°Ĺ ĂÂ¦Ă‡ĹĹ”Äš Ĺ”Ă–Â´Ă‚ĂĂ¶ Ä‚ĹÄľÄ†ĹźÂ¸Â°Ă
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
 
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
 
## Ĺ”Ă–Â´Ĺ®Â¸Ă© Â°ĂĽÂ·Ä‚ ĂÂ¤ĹźÂ¸Â¸Â¦ Ă‡Ä„ËťÄ‚Ă‡Ă”. ex) Ĺ‚Ë›Ĺ”Ĺź ËťÄ‚Â°Ĺ : 6Ĺ”ÄŽ 6ËťÄ‚Â°Ĺ 58ĹźÄ 
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
#dbg.TraceError("1) REAL_TIME flag On ")
 
## Rod ##
elif item.ITEM_TYPE_ROD == itemType:
 
if 0 != metinSlot:
curLevel = item.GetValue(0) / 10
curEXP = metinSlot[0]
maxEXP = item.GetValue(2)
self.__AppendLimitInformation()
self.__AppendRodInformation(curLevel, curEXP, maxEXP)
 
## Pick ##
elif item.ITEM_TYPE_PICK == itemType:
 
if 0 != metinSlot:
curLevel = item.GetValue(0) / 10
curEXP = metinSlot[0]
maxEXP = item.GetValue(2)
self.__AppendLimitInformation()
self.__AppendPickInformation(curLevel, curEXP, maxEXP)
 
## Lottery ##
elif item.ITEM_TYPE_LOTTERY == itemType:
if 0 != metinSlot:
 
ticketNumber = int(metinSlot[0])
stepNumber = int(metinSlot[1])
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_LOTTERY_STEP_NUMBER % (stepNumber), self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_LOTTO_NUMBER % (ticketNumber), self.NORMAL_COLOR);
 
### Metin ###
elif item.ITEM_TYPE_METIN == itemType:
self.AppendMetinInformation()
self.AppendMetinWearInformation()
 
### Fish ###
elif item.ITEM_TYPE_FISH == itemType:
if 0 != metinSlot:
self.__AppendFishInfo(metinSlot[0])
 
## item.ITEM_TYPE_BLEND
elif item.ITEM_TYPE_BLEND == itemType:
self.__AppendLimitInformation()
 
if metinSlot:
affectType = metinSlot[0]
affectValue = metinSlot[1]
time = metinSlot[2]
self.AppendSpace(5)
affectText = self.__GetAffectString(affectType, affectValue)
 
self.AppendTextLine(affectText, self.NORMAL_COLOR)
 
if time > 0:
minute = (time / 60)
second = (time % 60)
timeString = locale.TOOLTIP_POTION_TIME
 
if minute > 0:
timeString += str(minute) + locale.TOOLTIP_POTION_MIN
if second > 0:
timeString += " " + str(second) + locale.TOOLTIP_POTION_SEC
 
self.AppendTextLine(timeString)
else:
self.AppendTextLine(locale.BLEND_POTION_NO_TIME)
else:
self.AppendTextLine("BLEND_POTION_NO_INFO")
 
elif item.ITEM_TYPE_UNIQUE == itemType:
if 0 != metinSlot:
bHasRealtimeFlag = 0
 
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
 
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
 
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0]) 
else:
time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]
 
if 1 == item.GetValue(2): ## ËťĂ‡ËťÄ‚Â°Ĺ Ĺ”ÄšĹĽĂ« Flag / Ĺ”ÄşĂ‚Ĺ™ ÄľÄŚĂ‡ĹÂµÂµ ĂĹÂ´Ĺ®
self.AppendMallItemLastTime(time)
else:
self.AppendUniqueItemLastTime(time)
 
### Use ###
elif item.ITEM_TYPE_USE == itemType:
self.__AppendLimitInformation()
 
if item.USE_POTION == itemSubType or item.USE_POTION_NODELAY == itemSubType:
self.__AppendPotionInformation()
 
elif item.USE_ABILITY_UP == itemSubType:
self.__AppendAbilityPotionInformation()
 
 
## ĹĽÂµÄ˝Â® Â°Â¨ĂĂ¶Â±Ă˘
if 27989 == itemVnum or 76006 == itemVnum:
if 0 != metinSlot:
useCount = int(metinSlot[0])
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_REST_USABLE_COUNT % (6 - useCount), self.NORMAL_COLOR)
 
## Ĺ”ÄšĹźÄ„Ä†Â® Â°Â¨ĂĂ¶Â±Ă˘
elif 50004 == itemVnum:
if 0 != metinSlot:
useCount = int(metinSlot[0])
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_REST_USABLE_COUNT % (10 - useCount), self.NORMAL_COLOR)
 
## Ĺ”ĂšÂµĹĽÄ…Â°ÄľĹ•
elif constInfo.IS_AUTO_POTION(itemVnum):
if 0 != metinSlot:
## 0: ÄŚÂ°Ä˝ĹźÄŚÂ, 1: Â»Ă§ĹĽĂ«Â·Â®, 2: Ä‚ĹÂ·Â®
isActivated = int(metinSlot[0])
usedAmount = float(metinSlot[1])
totalAmount = float(metinSlot[2])
 
if 0 == totalAmount:
totalAmount = 1
 
self.AppendSpace(5)
 
if 0 != isActivated:
self.AppendTextLine("(%s)" % (locale.TOOLTIP_AUTO_POTION_USING), self.SPECIAL_POSITIVE_COLOR)
self.AppendSpace(5)
 
self.AppendTextLine(locale.TOOLTIP_AUTO_POTION_REST % (100.0 - ((usedAmount / totalAmount) * 100.0)), self.POSITIVE_COLOR)
 
## Â±ĂŤÄŚĹ» Â±Ă˘ÄľÄŹĹźĂŽ
elif itemVnum in WARP_SCROLLS:
if 0 != metinSlot:
xPos = int(metinSlot[0])
yPos = int(metinSlot[1])
 
if xPos != 0 and yPos != 0:
(mapName, xBase, yBase) = background.GlobalPositionToMapInfo(xPos, yPos)
 
localeMapName=locale.MINIMAP_ZONE_NAME_DICT.get(mapName, "")
 
self.AppendSpace(5)
 
if localeMapName!="": 
self.AppendTextLine(locale.TOOLTIP_MEMORIZED_POSITION % (localeMapName, int(xPos-xBase)/100, int(yPos-yBase)/100), self.NORMAL_COLOR)
else:
self.AppendTextLine(locale.TOOLTIP_MEMORIZED_POSITION_ERROR % (int(xPos)/100, int(yPos)/100), self.NORMAL_COLOR)
dbg.TraceError("NOT_EXIST_IN_MINIMAP_ZONE_NAME_DICT: %s" % mapName)
 
#####
if item.USE_SPECIAL == itemSubType:
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
 
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
 
## Ĺ”Ă–Â´Ĺ®Â¸Ă© Â°ĂĽÂ·Ä‚ ĂÂ¤ĹźÂ¸Â¸Â¦ Ă‡Ä„ËťÄ‚Ă‡Ă”. ex) Ĺ‚Ë›Ĺ”Ĺź ËťÄ‚Â°Ĺ : 6Ĺ”ÄŽ 6ËťÄ‚Â°Ĺ 58ĹźÄ 
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
else:
# ... Ĺ”ÄšÂ°Äą... Ä˝ÂÄ…Ă¶ĹĽË‡Â´Ă‚ Ĺ”ÄšÂ·Â± ËťÄ‚Â°Ĺ Ä‚Ä˝ÄąÂ© ÄľÄŚÂµĂ‡ÄľĂ® Ĺ”Ă–Â´Ă‚ÂµÄ„...
# ĹĽĂ– Ĺ”ÄšÂ·Â±Â°Ă” Ĺ”Ă–Â´Ă‚ĂĂ¶ ÄľĂ‹ĂĂ¶Â´Ă‚ Â¸Ĺ™Ă‡ÄŽĹ‚Ĺž Â±Ă—Ĺ‚Ă‰ ÂµĂŽĹ”Ăš...
if 0 != metinSlot:
time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]
 
## ËťĂ‡ËťÄ‚Â°Ĺ Ĺ”ÄšĹĽĂ« Flag
if 1 == item.GetValue(2):
self.AppendMallItemLastTime(time)
 
# elif item.USE_TIME_CHARGE_PER == itemSubType:
# bHasRealtimeFlag = 0
# for i in xrange(item.LIMIT_MAX_NUM):
# (limitType, limitValue) = item.GetLimit(i)
 
# if item.LIMIT_REAL_TIME == limitType:
# bHasRealtimeFlag = 1
# if metinSlot[2]:
# self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_PER(metinSlot[2]))
# else:
# self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_PER(item.GetValue(0)))
  
# Ĺ”Ă–Â´Ĺ®Â¸Ă© Â°ĂĽÂ·Ä‚ ĂÂ¤ĹźÂ¸Â¸Â¦ Ă‡Ä„ËťÄ‚Ă‡Ă”. ex) Ĺ‚Ë›Ĺ”Ĺź ËťÄ‚Â°Ĺ : 6Ĺ”ÄŽ 6ËťÄ‚Â°Ĺ 58ĹźÄ 
# if 1 == bHasRealtimeFlag:
# self.AppendMallItemLastTime(metinSlot[0])
 
# elif item.USE_TIME_CHARGE_FIX == itemSubType:
# bHasRealtimeFlag = 0
# for i in xrange(item.LIMIT_MAX_NUM):
# (limitType, limitValue) = item.GetLimit(i)
 
# if item.LIMIT_REAL_TIME == limitType:
# bHasRealtimeFlag = 1
# if metinSlot[2]:
# self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_FIX(metinSlot[2]))
# else:
# self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_FIX(item.GetValue(0)))
 
# Ĺ”Ă–Â´Ĺ®Â¸Ă© Â°ĂĽÂ·Ä‚ ĂÂ¤ĹźÂ¸Â¸Â¦ Ă‡Ä„ËťÄ‚Ă‡Ă”. ex) Ĺ‚Ë›Ĺ”Ĺź ËťÄ‚Â°Ĺ : 6Ĺ”ÄŽ 6ËťÄ‚Â°Ĺ 58ĹźÄ 
# if 1 == bHasRealtimeFlag:
# self.AppendMallItemLastTime(metinSlot[0])
 
elif item.ITEM_TYPE_QUEST == itemType:
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
 
if item.LIMIT_REAL_TIME == limitType:
self.AppendMallItemLastTime(metinSlot[0])
# elif item.ITEM_TYPE_DS == itemType:
# self.AppendTextLine(self.__DragonSoulInfoString(itemVnum))
# self.__AppendAttributeInformation(attrSlot)
# else:
# self.__AppendLimitInformation()
 
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
#dbg.TraceError("LimitType : %d, limitValue : %d" % (limitType, limitValue))
 
if item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
self.AppendRealTimeStartFirstUseLastTime(item, metinSlot, i)
#dbg.TraceError("2) REAL_TIME_START_FIRST_USE flag On ")
 
elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
self.AppendTimerBasedOnWearLastTime(metinSlot)
#dbg.TraceError("1) REAL_TIME flag On ")
 
self.ShowToolTip()
 
def __DragonSoulInfoString (self, dwVnum):
step = (dwVnum / 100) % 10
refine = (dwVnum / 10) % 10
if 0 == step:
return locale.DRAGON_SOUL_STEP_LEVEL1 + " " + locale.DRAGON_SOUL_STRENGTH(refine)
elif 1 == step:
return locale.DRAGON_SOUL_STEP_LEVEL2 + " " + locale.DRAGON_SOUL_STRENGTH(refine)
elif 2 == step:
return locale.DRAGON_SOUL_STEP_LEVEL3 + " " + locale.DRAGON_SOUL_STRENGTH(refine)
elif 3 == step:
return locale.DRAGON_SOUL_STEP_LEVEL4 + " " + locale.DRAGON_SOUL_STRENGTH(refine)
elif 4 == step:
return locale.DRAGON_SOUL_STEP_LEVEL5 + " " + locale.DRAGON_SOUL_STRENGTH(refine)
else:
return ""
 
 
## Ă‡Ä›ÄľĂ®Ĺ”ĂŽÂ°Ë‡?
def __IsHair(self, itemVnum):
return (self.__IsOldHair(itemVnum) or 
self.__IsNewHair(itemVnum) or
self.__IsNewHair2(itemVnum) or
self.__IsNewHair3(itemVnum) or
self.__IsCostumeHair(itemVnum)
)
 
def __IsOldHair(self, itemVnum):
return itemVnum > 73000 and itemVnum < 74000 
 
def __IsNewHair(self, itemVnum):
return itemVnum > 74000 and itemVnum < 75000 
 
def __IsNewHair2(self, itemVnum):
return itemVnum > 75000 and itemVnum < 76000 
 
def __IsNewHair3(self, itemVnum):
return ((74012 < itemVnum and itemVnum < 74022) or
(74262 < itemVnum and itemVnum < 74272) or
(74512 < itemVnum and itemVnum < 74522) or
(74762 < itemVnum and itemVnum < 74772) or
(45000 < itemVnum and itemVnum < 47000))
 
def __IsCostumeHair(self, itemVnum):
return app.ENABLE_COSTUME_SYSTEM and self.__IsNewHair3(itemVnum - 100000)
 
def __AppendHairIcon(self, itemVnum):
itemImage = ui.ImageBox()
itemImage.SetParent(self)
itemImage.Show() 
 
if self.__IsOldHair(itemVnum):
itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum)+".tga")
elif self.__IsNewHair3(itemVnum):
itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
elif self.__IsNewHair(itemVnum): # Â±Ă˘ĂÂ¸ Ă‡Ä›ÄľĂ® Ä…Ĺ™ÄŚĹÂ¸Â¦ ĹĽÂ¬Â°ĂˇËťÄ‚Ă„ĹÄ˝Â Â»Ă§ĹĽĂ«Ă‡ĹÂ´Ĺ®. Â»Ĺ‘Â·ĂŽĹĽĂ® ÄľÄ†Ĺ”ÄšÄąĹ°Ĺ”Ĺź 1000Â¸Â¸ÄąÂ Ä…Ĺ™ÄŚĹÂ°Ë‡ Â´Ä‚ÄľĂşÂ´Ĺ®.
itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum-1000)+".tga")
elif self.__IsNewHair2(itemVnum):
itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
elif self.__IsCostumeHair(itemVnum):
itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum - 100000))
 
itemImage.SetPosition(itemImage.GetWidth()/2, self.toolTipHeight)
self.toolTipHeight += itemImage.GetHeight()
#self.toolTipWidth += itemImage.GetWidth()/2
self.childrenList.append(itemImage)
self.ResizeToolTip()
 
## Â»Ă§Ĺ”ÄšĂĂ®Â°Ë‡ ÄąÂ« Description Ĺ”ÄŽ Â°Ä‡ĹĽÄ› ÄąĹ™Ä†Ă Â»Ă§Ĺ”ÄšĂĂ®Â¸Â¦ ĂÂ¶ĂÂ¤Ă‡ĹÂ´Ĺ®
def __AdjustMaxWidth(self, attrSlot, desc):
newToolTipWidth = self.toolTipWidth
newToolTipWidth = max(self.__AdjustAttrMaxWidth(attrSlot), newToolTipWidth)
newToolTipWidth = max(self.__AdjustDescMaxWidth(desc), newToolTipWidth)
if newToolTipWidth > self.toolTipWidth:
self.toolTipWidth = newToolTipWidth
self.ResizeToolTip()
 
def __AdjustAttrMaxWidth(self, attrSlot):
if 0 == attrSlot:
return self.toolTipWidth
 
maxWidth = self.toolTipWidth
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
value = attrSlot[i][1]
if self.ATTRIBUTE_NEED_WIDTH.has_key(type):
if value > 0:
maxWidth = max(self.ATTRIBUTE_NEED_WIDTH[type], maxWidth)
 
# ATTR_CHANGE_TOOLTIP_WIDTH
#self.toolTipWidth = max(self.ATTRIBUTE_NEED_WIDTH[type], self.toolTipWidth)
#self.ResizeToolTip()
# END_OF_ATTR_CHANGE_TOOLTIP_WIDTH
 
return maxWidth
 
def __AdjustDescMaxWidth(self, desc):
if len(desc) < DESC_DEFAULT_MAX_COLS:
return self.toolTipWidth
 
return DESC_WESTERN_MAX_WIDTH
 
def __SetSkillBookToolTip(self, skillIndex, bookName, skillGrade):
skillName = skill.GetSkillName(skillIndex)
 
if not skillName:
return
 
if locale.IsVIETNAM():
itemName = bookName + " " + skillName
else:
itemName = skillName + " " + bookName
self.SetTitle(itemName)
 
def __AppendPickInformation(self, curLevel, curEXP, maxEXP):
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_PICK_LEVEL % (curLevel), self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_PICK_EXP % (curEXP, maxEXP), self.NORMAL_COLOR)
 
if curEXP == maxEXP:
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_PICK_UPGRADE1, self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_PICK_UPGRADE2, self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_PICK_UPGRADE3, self.NORMAL_COLOR)
 
 
def __AppendRodInformation(self, curLevel, curEXP, maxEXP):
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_FISHINGROD_LEVEL % (curLevel), self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_FISHINGROD_EXP % (curEXP, maxEXP), self.NORMAL_COLOR)
 
if curEXP == maxEXP:
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_FISHINGROD_UPGRADE1, self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_FISHINGROD_UPGRADE2, self.NORMAL_COLOR)
self.AppendTextLine(locale.TOOLTIP_FISHINGROD_UPGRADE3, self.NORMAL_COLOR)
 
def __AppendLimitInformation(self):
 
appendSpace = FALSE
 
for i in xrange(item.LIMIT_MAX_NUM):
 
(limitType, limitValue) = item.GetLimit(i)
 
if limitValue > 0:
if FALSE == appendSpace:
self.AppendSpace(5)
appendSpace = TRUE
 
else:
continue
 
if item.LIMIT_LEVEL == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.LEVEL), limitValue)
self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_LEVEL % (limitValue), color)
"""
elif item.LIMIT_STR == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.ST), limitValue)
self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_STR % (limitValue), color)
elif item.LIMIT_DEX == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.DX), limitValue)
self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_DEX % (limitValue), color)
elif item.LIMIT_INT == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.IQ), limitValue)
self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_INT % (limitValue), color)
elif item.LIMIT_CON == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.HT), limitValue)
self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_CON % (limitValue), color)
"""
 
def __GetAffectString(self, affectType, affectValue):
if 0 == affectType:
return None
 
if 0 == affectValue:
return None
 
try:
return self.AFFECT_DICT[affectType](affectValue)
except TypeError:
return "UNKNOWN_VALUE[%s] %s" % (affectType, affectValue)
except KeyError:
return "UNKNOWN_TYPE[%s] %s" % (affectType, affectValue)
 
def __AppendAffectInformation(self):
for i in xrange(item.ITEM_APPLY_MAX_NUM):
 
(affectType, affectValue) = item.GetAffect(i)
 
affectString = self.__GetAffectString(affectType, affectValue)
if affectString:
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
 
def AppendWearableInformation(self):
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_ITEM_WEARABLE_JOB, self.NORMAL_COLOR)
 
flagList = (
not item.IsAntiFlag(item.ITEM_ANTIFLAG_WARRIOR),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_ASSASSIN),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_SURA),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_SHAMAN))
 
characterNames = ""
for i in xrange(self.CHARACTER_COUNT):
 
name = self.CHARACTER_NAMES[i]
flag = flagList[i]
 
if flag:
characterNames += " "
characterNames += name
 
textLine = self.AppendTextLine(characterNames, self.NORMAL_COLOR, TRUE)
textLine.SetFeather()
 
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE):
textLine = self.AppendTextLine(locale.FOR_FEMALE, self.NORMAL_COLOR, TRUE)
textLine.SetFeather()
 
if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE):
textLine = self.AppendTextLine(locale.FOR_MALE, self.NORMAL_COLOR, TRUE)
textLine.SetFeather()
 
def __AppendPotionInformation(self):
self.AppendSpace(5)
 
healHP = item.GetValue(0)
healSP = item.GetValue(1)
healStatus = item.GetValue(2)
healPercentageHP = item.GetValue(3)
healPercentageSP = item.GetValue(4)
 
if healHP > 0:
self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_HP_POINT % healHP, self.GetChangeTextLineColor(healHP))
if healSP > 0:
self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_SP_POINT % healSP, self.GetChangeTextLineColor(healSP))
if healStatus != 0:
self.AppendTextLine(locale.TOOLTIP_POTION_CURE)
if healPercentageHP > 0:
self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_HP_PERCENT % healPercentageHP, self.GetChangeTextLineColor(healPercentageHP))
if healPercentageSP > 0:
self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_SP_PERCENT % healPercentageSP, self.GetChangeTextLineColor(healPercentageSP))
 
def __AppendAbilityPotionInformation(self):
 
self.AppendSpace(5)
 
abilityType = item.GetValue(0)
time = item.GetValue(1)
point = item.GetValue(2)
 
if abilityType == item.APPLY_ATT_SPEED:
self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_ATTACK_SPEED % point, self.GetChangeTextLineColor(point))
elif abilityType == item.APPLY_MOV_SPEED:
self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_MOVING_SPEED % point, self.GetChangeTextLineColor(point))
 
if time > 0:
minute = (time / 60)
second = (time % 60)
timeString = locale.TOOLTIP_POTION_TIME
 
if minute > 0:
timeString += str(minute) + locale.TOOLTIP_POTION_MIN
if second > 0:
timeString += " " + str(second) + locale.TOOLTIP_POTION_SEC
 
self.AppendTextLine(timeString)
 
def GetPriceColor(self, price):
if price>=constInfo.HIGH_PRICE:
return self.HIGH_PRICE_COLOR
if price>=constInfo.MIDDLE_PRICE:
return self.MIDDLE_PRICE_COLOR
else:
return self.LOW_PRICE_COLOR
 
def AppendPrice(self, price): 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_BUYPRICE  % (locale.NumberToMoneyString(price)), self.GetPriceColor(price))
 
def AppendSellingPrice(self, price):
if item.IsAntiFlag(item.ITEM_ANTIFLAG_SELL): 
self.AppendTextLine(locale.TOOLTIP_ANTI_SELL, self.DISABLE_COLOR)
self.AppendSpace(5)
else:
self.AppendTextLine(locale.TOOLTIP_SELLPRICE % (locale.NumberToMoneyString(price)), self.GetPriceColor(price))
self.AppendSpace(5)
 
def AppendMetinInformation(self):
affectType, affectValue = item.GetAffect(0)
#affectType = item.GetValue(0)
#affectValue = item.GetValue(1)
 
affectString = self.__GetAffectString(affectType, affectValue)
 
if affectString:
self.AppendSpace(5)
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
 
def AppendMetinWearInformation(self):
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_SOCKET_REFINABLE_ITEM, self.NORMAL_COLOR)
 
flagList = (item.IsWearableFlag(item.WEARABLE_BODY),
item.IsWearableFlag(item.WEARABLE_HEAD),
item.IsWearableFlag(item.WEARABLE_FOOTS),
item.IsWearableFlag(item.WEARABLE_WRIST),
item.IsWearableFlag(item.WEARABLE_WEAPON),
item.IsWearableFlag(item.WEARABLE_NECK),
item.IsWearableFlag(item.WEARABLE_EAR),
item.IsWearableFlag(item.WEARABLE_UNIQUE),
item.IsWearableFlag(item.WEARABLE_SHIELD),
item.IsWearableFlag(item.WEARABLE_ARROW))
 
wearNames = ""
for i in xrange(self.WEAR_COUNT):
 
name = self.WEAR_NAMES[i]
flag = flagList[i]
 
if flag:
wearNames += "  "
wearNames += name
 
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
textLine.SetHorizontalAlignCenter()
textLine.SetPackedFontColor(self.NORMAL_COLOR)
textLine.SetText(wearNames)
textLine.Show()
self.childrenList.append(textLine)
 
self.toolTipHeight += self.TEXT_LINE_HEIGHT
self.ResizeToolTip()
 
def GetMetinSocketType(self, number):
if player.METIN_SOCKET_TYPE_NONE == number:
return player.METIN_SOCKET_TYPE_NONE
elif player.METIN_SOCKET_TYPE_SILVER == number:
return player.METIN_SOCKET_TYPE_SILVER
elif player.METIN_SOCKET_TYPE_GOLD == number:
return player.METIN_SOCKET_TYPE_GOLD
else:
item.SelectItem(number)
if item.METIN_NORMAL == item.GetItemSubType():
return player.METIN_SOCKET_TYPE_SILVER
elif item.METIN_GOLD == item.GetItemSubType():
return player.METIN_SOCKET_TYPE_GOLD
elif "USE_PUT_INTO_ACCESSORY_SOCKET" == item.GetUseType(number):
return player.METIN_SOCKET_TYPE_SILVER
 
return player.METIN_SOCKET_TYPE_NONE
 
def GetMetinItemIndex(self, number):
if player.METIN_SOCKET_TYPE_SILVER == number:
return 0
if player.METIN_SOCKET_TYPE_GOLD == number:
return 0
 
return number
 
def __AppendAccessoryMetinSlotInfo(self, metinSlot, mtrlVnum): 
ACCESSORY_SOCKET_MAX_SIZE = 3 
 
cur=min(metinSlot[0], ACCESSORY_SOCKET_MAX_SIZE)
end=min(metinSlot[1], ACCESSORY_SOCKET_MAX_SIZE)
 
affectType1, affectValue1 = item.GetAffect(0)
affectList1=[0, max(1, affectValue1*10/100), max(2, affectValue1*20/100), max(3, affectValue1*40/100)]
 
affectType2, affectValue2 = item.GetAffect(1)
affectList2=[0, max(1, affectValue2*10/100), max(2, affectValue2*20/100), max(3, affectValue2*40/100)]
 
mtrlPos=0
mtrlList=[mtrlVnum]*cur+[player.METIN_SOCKET_TYPE_SILVER]*(end-cur)
for mtrl in mtrlList:
affectString1 = self.__GetAffectString(affectType1, affectList1[mtrlPos+1]-affectList1[mtrlPos]) 
affectString2 = self.__GetAffectString(affectType2, affectList2[mtrlPos+1]-affectList2[mtrlPos])
 
leftTime = 0
if cur == mtrlPos+1:
leftTime=metinSlot[2]
 
self.__AppendMetinSlotInfo_AppendMetinSocketData(mtrlPos, mtrl, affectString1, affectString2, leftTime)
mtrlPos+=1
 
def __AppendMetinSlotInfo(self, metinSlot):
if self.__AppendMetinSlotInfo_IsEmptySlotList(metinSlot):
return
 
for i in xrange(player.METIN_SOCKET_MAX_NUM):
self.__AppendMetinSlotInfo_AppendMetinSocketData(i, metinSlot[i])
 
def __AppendMetinSlotInfo_IsEmptySlotList(self, metinSlot):
if 0 == metinSlot:
return 1
 
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlotData=metinSlot[i]
if 0 != self.GetMetinSocketType(metinSlotData):
if 0 != self.GetMetinItemIndex(metinSlotData):
return 0
 
return 1
 
def __AppendMetinSlotInfo_AppendMetinSocketData(self, index, metinSlotData, custumAffectString="", custumAffectString2="", leftTime=0):
 
slotType = self.GetMetinSocketType(metinSlotData)
itemIndex = self.GetMetinItemIndex(metinSlotData)
 
if 0 == slotType:
return
 
self.AppendSpace(5)
 
slotImage = ui.ImageBox()
slotImage.SetParent(self)
slotImage.Show()
 
## Name
nameTextLine = ui.TextLine()
nameTextLine.SetParent(self)
nameTextLine.SetFontName(self.defFontName)
nameTextLine.SetPackedFontColor(self.NORMAL_COLOR)
nameTextLine.SetOutline()
nameTextLine.SetFeather()
nameTextLine.Show() 
 
self.childrenList.append(nameTextLine)
 
if player.METIN_SOCKET_TYPE_SILVER == slotType:
slotImage.LoadImage("d:/ymir work/ui/game/windows/metin_slot_silver.sub")
elif player.METIN_SOCKET_TYPE_GOLD == slotType:
slotImage.LoadImage("d:/ymir work/ui/game/windows/metin_slot_gold.sub")
 
self.childrenList.append(slotImage)
 
if locale.IsARABIC():
slotImage.SetPosition(self.toolTipWidth - slotImage.GetWidth() - 9, self.toolTipHeight-1)
nameTextLine.SetPosition(self.toolTipWidth - 50, self.toolTipHeight + 2)
else:
slotImage.SetPosition(9, self.toolTipHeight-1)
nameTextLine.SetPosition(50, self.toolTipHeight + 2)
 
metinImage = ui.ImageBox()
metinImage.SetParent(self)
metinImage.Show()
self.childrenList.append(metinImage)
 
if itemIndex:
 
item.SelectItem(itemIndex)
 
## Image
try:
metinImage.LoadImage(item.GetIconImageFileName())
except:
dbg.TraceError("ItemToolTip.__AppendMetinSocketData() - Failed to find image file %d:%s" % 
(itemIndex, item.GetIconImageFileName())
)
 
nameTextLine.SetText(item.GetItemName())
 
## Affect 
affectTextLine = ui.TextLine()
affectTextLine.SetParent(self)
affectTextLine.SetFontName(self.defFontName)
affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
affectTextLine.SetOutline()
affectTextLine.SetFeather()
affectTextLine.Show() 
 
if locale.IsARABIC():
metinImage.SetPosition(self.toolTipWidth - metinImage.GetWidth() - 10, self.toolTipHeight)
affectTextLine.SetPosition(self.toolTipWidth - 50, self.toolTipHeight + 16 + 2)
else:
metinImage.SetPosition(10, self.toolTipHeight)
affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2)
 
if custumAffectString:
affectTextLine.SetText(custumAffectString)
elif itemIndex!=constInfo.ERROR_METIN_STONE:
affectType, affectValue = item.GetAffect(0)
affectString = self.__GetAffectString(affectType, affectValue)
if affectString:
affectTextLine.SetText(affectString)
else:
affectTextLine.SetText(locale.TOOLTIP_APPLY_NOAFFECT)
 
self.childrenList.append(affectTextLine) 
 
if custumAffectString2:
affectTextLine = ui.TextLine()
affectTextLine.SetParent(self)
affectTextLine.SetFontName(self.defFontName)
affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
affectTextLine.SetOutline()
affectTextLine.SetFeather()
affectTextLine.Show()
affectTextLine.SetText(custumAffectString2)
self.childrenList.append(affectTextLine)
self.toolTipHeight += 16 + 2
 
if 0 != leftTime:
timeText = (locale.LEFT_TIME + " : " + locale.SecondToDHM(leftTime))
 
timeTextLine = ui.TextLine()
timeTextLine.SetParent(self)
timeTextLine.SetFontName(self.defFontName)
timeTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
timeTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
timeTextLine.SetOutline()
timeTextLine.SetFeather()
timeTextLine.Show()
timeTextLine.SetText(timeText)
self.childrenList.append(timeTextLine)
self.toolTipHeight += 16 + 2
 
else:
nameTextLine.SetText(locale.TOOLTIP_SOCKET_EMPTY)
 
self.toolTipHeight += 35
self.ResizeToolTip()
 
def __AppendFishInfo(self, size):
if size > 0:
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_FISH_LEN % (float(size) / 100.0), self.NORMAL_COLOR)
 
def AppendUniqueItemLastTime(self, restMin):
restSecond = restMin*60
self.AppendSpace(5)
self.AppendTextLine(locale.LEFT_TIME + " : " + locale.SecondToDHM(restSecond), self.NORMAL_COLOR)
 
def AppendMallItemLastTime(self, endTime):
leftSec = max(0, endTime - app.GetGlobalTimeStamp())
self.AppendSpace(5)
self.AppendTextLine(locale.LEFT_TIME + " : " + locale.SecondToDHM(leftSec), self.NORMAL_COLOR)
 
def AppendTimerBasedOnWearLastTime(self, metinSlot):
if 0 == metinSlot[0]:
self.AppendSpace(5)
self.AppendTextLine(locale.CANNOT_USE, self.DISABLE_COLOR)
else:
endTime = app.GetGlobalTimeStamp() + metinSlot[0]
self.AppendMallItemLastTime(endTime) 
 
def AppendRealTimeStartFirstUseLastTime(self, item, metinSlot, limitIndex): 
useCount = metinSlot[1]
endTime = metinSlot[0]
 
# Ă‡Ĺ Ä…Ĺ™Ĺ”ÄšÂ¶ĂłÂµÂµ Â»Ă§ĹĽĂ«Ă‡ĂźÂ´Ĺ®Â¸Ă© Socket0ĹĽË‡ ĂÄľÂ·Ăˇ ËťÄ‚Â°Ĺ(2012Ĺ‚Ă˘ 3ĹĽĹŻ 1Ĺ”ÄŽ 13ËťÄ‚ 01ĹźÄ Â°Â°Ĺ”Ĺź..) Ĺ”Äš Ä…ĂšĂ‡Ă´Ĺ”Ă–Ĺ”Ëť.
# Â»Ă§ĹĽĂ«Ă‡ÄŽĂĂ¶ ÄľÄÄľĹ‡Â´Ĺ®Â¸Ă© Socket0ĹĽË‡ Ĺ”ÄšĹĽĂ«Â°Ë‡Â´Ă‰ËťÄ‚Â°Ĺ(Ĺ”ÄšÂ¸Â¦ÄąĂ—Â¸Ă© 600 Â°Â°Ĺ”Ĺź Â°Ĺž. Ä‚ÄÂ´ĂśĹ”Â§)Ĺ”Äš ÂµĂ©ÄľĂ®Ĺ”Ă–Ĺ”Â» Ä˝Ă¶ Ĺ”Ă–Â°Ă, 0Ĺ”ÄšÂ¶ĂłÂ¸Ă© Limit ValueĹĽË‡ Ĺ”Ă–Â´Ă‚ Ĺ”ÄšĹĽĂ«Â°Ë‡Â´Ă‰ËťÄ‚Â°ĹĹ”Â» Â»Ă§ĹĽĂ«Ă‡ĹÂ´Ĺ®.
if 0 == useCount:
if 0 == endTime:
(limitType, limitValue) = item.GetLimit(limitIndex)
endTime = limitValue
 
endTime += app.GetGlobalTimeStamp()
 
self.AppendMallItemLastTime(endTime)
 
class HyperlinkItemToolTip(ItemToolTip):
def __init__(self):
ItemToolTip.__init__(self, isPickable=TRUE)
 
def SetHyperlinkItem(self, tokens):
minTokenCount = 3 + player.METIN_SOCKET_MAX_NUM
maxTokenCount = minTokenCount + 2 * player.ATTRIBUTE_SLOT_MAX_NUM
if tokens and len(tokens) >= minTokenCount and len(tokens) <= maxTokenCount:
head, vnum, flag = tokens[:3]
itemVnum = int(vnum, 16)
metinSlot = [int(metin, 16) for metin in tokens[3:6]]
 
rests = tokens[6:]
if rests:
attrSlot = []
 
rests.reverse()
while rests:
key = int(rests.pop(), 16)
if rests:
val = int(rests.pop())
attrSlot.append((key, val))
 
attrSlot += [(0, 0)] * (player.ATTRIBUTE_SLOT_MAX_NUM - len(attrSlot))
else:
attrSlot = [(0, 0)] * player.ATTRIBUTE_SLOT_MAX_NUM
 
self.ClearToolTip()
self.AddItemData(itemVnum, metinSlot, attrSlot)
 
ItemToolTip.OnUpdate(self)
 
def OnUpdate(self):
pass
 
def OnMouseLeftButtonDown(self):
self.Hide()
 
class SkillToolTip(ToolTip):
 
POINT_NAME_DICT = {
player.LEVEL : locale.SKILL_TOOLTIP_LEVEL,
player.IQ : locale.SKILL_TOOLTIP_INT,
}
 
SKILL_TOOL_TIP_WIDTH = 200
PARTY_SKILL_TOOL_TIP_WIDTH = 340
 
PARTY_SKILL_EXPERIENCE_AFFECT_LIST = ( ( 2, 2,  10,),
( 8, 3,  20,),
(14, 4,  30,),
(22, 5,  45,),
(28, 6,  60,),
(34, 7,  80,),
(38, 8, 100,), )
 
PARTY_SKILL_PLUS_GRADE_AFFECT_LIST = ( ( 4, 2, 1, 0,),
(10, 3, 2, 0,),
(16, 4, 2, 1,),
(24, 5, 2, 2,), )
 
PARTY_SKILL_ATTACKER_AFFECT_LIST = ( ( 36, 3, ),
( 26, 1, ),
( 32, 2, ), )
 
SKILL_GRADE_NAME = { player.SKILL_GRADE_MASTER : locale.SKILL_GRADE_NAME_MASTER,
player.SKILL_GRADE_GRAND_MASTER : locale.SKILL_GRADE_NAME_GRAND_MASTER,
player.SKILL_GRADE_PERFECT_MASTER : locale.SKILL_GRADE_NAME_PERFECT_MASTER, }
 
AFFECT_NAME_DICT = {
"HP" : locale.TOOLTIP_SKILL_AFFECT_ATT_POWER,
"ATT_GRADE" : locale.TOOLTIP_SKILL_AFFECT_ATT_GRADE,
"DEF_GRADE" : locale.TOOLTIP_SKILL_AFFECT_DEF_GRADE,
"ATT_SPEED" : locale.TOOLTIP_SKILL_AFFECT_ATT_SPEED,
"MOV_SPEED" : locale.TOOLTIP_SKILL_AFFECT_MOV_SPEED,
"DODGE" : locale.TOOLTIP_SKILL_AFFECT_DODGE,
"RESIST_NORMAL" : locale.TOOLTIP_SKILL_AFFECT_RESIST_NORMAL,
"REFLECT_MELEE" : locale.TOOLTIP_SKILL_AFFECT_REFLECT_MELEE,
}
AFFECT_APPEND_TEXT_DICT = {
"DODGE" : "%",
"RESIST_NORMAL" : "%",
"REFLECT_MELEE" : "%",
}
 
def __init__(self):
ToolTip.__init__(self, self.SKILL_TOOL_TIP_WIDTH)
def __del__(self):
ToolTip.__del__(self)
 
def SetSkill(self, skillIndex, skillLevel = -1):
 
if 0 == skillIndex:
return
 
if skill.SKILL_TYPE_GUILD == skill.GetSkillType(skillIndex):
 
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
 
self.AppendDefaultData(skillIndex)
self.AppendSkillConditionData(skillIndex)
self.AppendGuildSkillData(skillIndex, skillLevel)
 
else:
 
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
 
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillGrade = player.GetSkillGrade(slotIndex)
skillLevel = player.GetSkillLevel(slotIndex)
skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
skillNextPercentage = player.GetSkillNextEfficientPercentage(slotIndex)
 
self.AppendDefaultData(skillIndex)
self.AppendSkillConditionData(skillIndex)
self.AppendSkillDataNew(slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage)
self.AppendSkillRequirement(skillIndex, skillLevel)
 
self.ShowToolTip()
 
def SetSkillNew(self, slotIndex, skillIndex, skillGrade, skillLevel):
 
if 0 == skillIndex:
return
 
if player.SKILL_INDEX_TONGSOL == skillIndex:
 
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillLevel = player.GetSkillLevel(slotIndex)
 
self.AppendDefaultData(skillIndex)
self.AppendPartySkillData(skillGrade, skillLevel)
 
elif player.SKILL_INDEX_RIDING == skillIndex:
 
slotIndex = player.GetSkillSlotIndex(skillIndex)
self.AppendSupportSkillDefaultData(skillIndex, skillGrade, skillLevel, 30)
 
elif player.SKILL_INDEX_SUMMON == skillIndex:
 
maxLevel = 10
 
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
 
## Description
description = skill.GetSkillDescription(skillIndex)
self.AppendDescription(description, 25)
 
if skillLevel == 10:
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
self.AppendTextLine(locale.SKILL_SUMMON_DESCRIPTION % (skillLevel*10), self.NORMAL_COLOR)
 
else:
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
self.__AppendSummonDescription(skillLevel, self.NORMAL_COLOR)
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL % (skillLevel+1), self.NEGATIVE_COLOR)
self.__AppendSummonDescription(skillLevel+1, self.NEGATIVE_COLOR)
 
elif skill.SKILL_TYPE_GUILD == skill.GetSkillType(skillIndex):
 
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
 
self.AppendDefaultData(skillIndex)
self.AppendSkillConditionData(skillIndex)
self.AppendGuildSkillData(skillIndex, skillLevel)
 
else:
 
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
 
slotIndex = player.GetSkillSlotIndex(skillIndex)
 
skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
skillNextPercentage = player.GetSkillNextEfficientPercentage(slotIndex)
 
self.AppendDefaultData(skillIndex, skillGrade)
self.AppendSkillConditionData(skillIndex)
self.AppendSkillDataNew(slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage)
self.AppendSkillRequirement(skillIndex, skillLevel)
 
self.ShowToolTip()
 
def __SetSkillTitle(self, skillIndex, skillGrade):
self.SetTitle(skill.GetSkillName(skillIndex, skillGrade))
self.__AppendSkillGradeName(skillIndex, skillGrade)
 
def __AppendSkillGradeName(self, skillIndex, skillGrade): 
if self.SKILL_GRADE_NAME.has_key(skillGrade):
self.AppendSpace(5)
self.AppendTextLine(self.SKILL_GRADE_NAME[skillGrade] % (skill.GetSkillName(skillIndex, 0)), self.CAN_LEVEL_UP_COLOR)
 
def SetSkillOnlyName(self, slotIndex, skillIndex, skillGrade):
if 0 == skillIndex:
return
 
slotIndex = player.GetSkillSlotIndex(skillIndex)
 
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
 
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade) 
self.AppendDefaultData(skillIndex, skillGrade)
self.AppendSkillConditionData(skillIndex) 
self.ShowToolTip()
 
def AppendDefaultData(self, skillIndex, skillGrade = 0):
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
 
## Level Limit
levelLimit = skill.GetSkillLevelLimit(skillIndex)
if levelLimit > 0:
 
color = self.NORMAL_COLOR
if player.GetStatus(player.LEVEL) < levelLimit:
color = self.NEGATIVE_COLOR
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_LEVEL % (levelLimit), color)
 
## Description
description = skill.GetSkillDescription(skillIndex)
self.AppendDescription(description, 25)
 
def AppendSupportSkillDefaultData(self, skillIndex, skillGrade, skillLevel, maxLevel):
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
 
## Description
description = skill.GetSkillDescription(skillIndex)
self.AppendDescription(description, 25)
 
if 1 == skillGrade:
skillLevel += 19
elif 2 == skillGrade:
skillLevel += 29
elif 3 == skillGrade:
skillLevel = 40
 
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL_WITH_MAX % (skillLevel, maxLevel), self.NORMAL_COLOR)
 
def AppendSkillConditionData(self, skillIndex):
conditionDataCount = skill.GetSkillConditionDescriptionCount(skillIndex)
if conditionDataCount > 0:
self.AppendSpace(5)
for i in xrange(conditionDataCount):
self.AppendTextLine(skill.GetSkillConditionDescription(skillIndex, i), self.CONDITION_COLOR)
 
def AppendGuildSkillData(self, skillIndex, skillLevel):
skillMaxLevel = 7
skillCurrentPercentage = float(skillLevel) / float(skillMaxLevel)
skillNextPercentage = float(skillLevel+1) / float(skillMaxLevel)
## Current Level
if skillLevel > 0:
if self.HasSkillLevelDescription(skillIndex, skillLevel):
self.AppendSpace(5)
if skillLevel == skillMaxLevel:
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
else:
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
 
#####
 
for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillCurrentPercentage), self.ENABLE_COLOR)
 
## Cooltime
coolTime = skill.GetSkillCoolTime(skillIndex, skillCurrentPercentage)
if coolTime > 0:
self.AppendTextLine(locale.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.ENABLE_COLOR)
 
## SP
needGSP = skill.GetSkillNeedSP(skillIndex, skillCurrentPercentage)
if needGSP > 0:
self.AppendTextLine(locale.TOOLTIP_NEED_GSP % (needGSP), self.ENABLE_COLOR)
 
## Next Level
if skillLevel < skillMaxLevel:
if self.HasSkillLevelDescription(skillIndex, skillLevel+1):
self.AppendSpace(5)
self.AppendTextLine(locale.TOOLTIP_NEXT_SKILL_LEVEL_1 % (skillLevel+1, skillMaxLevel), self.DISABLE_COLOR)
 
#####
 
for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillNextPercentage), self.DISABLE_COLOR)
 
## Cooltime
coolTime = skill.GetSkillCoolTime(skillIndex, skillNextPercentage)
if coolTime > 0:
self.AppendTextLine(locale.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.DISABLE_COLOR)
 
## SP
needGSP = skill.GetSkillNeedSP(skillIndex, skillNextPercentage)
if needGSP > 0:
self.AppendTextLine(locale.TOOLTIP_NEED_GSP % (needGSP), self.DISABLE_COLOR)
 
def AppendSkillDataNew(self, slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage):
 
self.skillMaxLevelStartDict = { 0 : 17, 1 : 7, 2 : 10, }
self.skillMaxLevelEndDict = { 0 : 20, 1 : 10, 2 : 10, }
 
skillLevelUpPoint = 1
realSkillGrade = player.GetSkillGrade(slotIndex)
skillMaxLevelStart = self.skillMaxLevelStartDict.get(realSkillGrade, 15)
skillMaxLevelEnd = self.skillMaxLevelEndDict.get(realSkillGrade, 20)
 
## Current Level
if skillLevel > 0:
if self.HasSkillLevelDescription(skillIndex, skillLevel):
self.AppendSpace(5)
if skillGrade == skill.SKILL_GRADE_COUNT:
pass
elif skillLevel == skillMaxLevelEnd:
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
else:
self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
self.AppendSkillLevelDescriptionNew(skillIndex, skillCurrentPercentage, self.ENABLE_COLOR)
 
## Next Level
if skillGrade != skill.SKILL_GRADE_COUNT:
if skillLevel < skillMaxLevelEnd:
if self.HasSkillLevelDescription(skillIndex, skillLevel+skillLevelUpPoint):
self.AppendSpace(5)
## HPĹźÂ¸Â°Â, Â°ĂĽÄąĂ«ÄŚÂ¸Ă‡Ă‡ ĹźÂ¸ĂÂ¶ËťĹźÄąĹ‚Ĺ”Ă‡ Â°Ä‡ĹĽÄ›
if skillIndex == 141 or skillIndex == 142:
self.AppendTextLine(locale.TOOLTIP_NEXT_SKILL_LEVEL_3 % (skillLevel+1), self.DISABLE_COLOR)
else:
self.AppendTextLine(locale.TOOLTIP_NEXT_SKILL_LEVEL_1 % (skillLevel+1, skillMaxLevelEnd), self.DISABLE_COLOR)
self.AppendSkillLevelDescriptionNew(skillIndex, skillNextPercentage, self.DISABLE_COLOR)
 
def AppendSkillLevelDescriptionNew(self, skillIndex, skillPercentage, color):
 
affectDataCount = skill.GetNewAffectDataCount(skillIndex)
if affectDataCount > 0:
for i in xrange(affectDataCount):
type, minValue, maxValue = skill.GetNewAffectData(skillIndex, i, skillPercentage)
 
if not self.AFFECT_NAME_DICT.has_key(type):
continue
 
minValue = int(minValue)
maxValue = int(maxValue)
affectText = self.AFFECT_NAME_DICT[type]
 
if "HP" == type:
if minValue < 0 and maxValue < 0:
minValue *= -1
maxValue *= -1
 
else:
affectText = locale.TOOLTIP_SKILL_AFFECT_HEAL
 
affectText += str(minValue)
if minValue != maxValue:
affectText += " - " + str(maxValue)
affectText += self.AFFECT_APPEND_TEXT_DICT.get(type, "")
 
#import debugInfo
#if debugInfo.IsDebugMode():
# affectText = "!!" + affectText
 
self.AppendTextLine(affectText, color)
 
else:
for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillPercentage), color)
 
 
## Duration
duration = skill.GetDuration(skillIndex, skillPercentage)
if duration > 0:
self.AppendTextLine(locale.TOOLTIP_SKILL_DURATION % (duration), color)
 
## Cooltime
coolTime = skill.GetSkillCoolTime(skillIndex, skillPercentage)
if coolTime > 0:
self.AppendTextLine(locale.TOOLTIP_SKILL_COOL_TIME + str(coolTime), color)
 
## SP
needSP = skill.GetSkillNeedSP(skillIndex, skillPercentage)
if needSP != 0:
continuationSP = skill.GetSkillContinuationSP(skillIndex, skillPercentage)
 
if skill.IsUseHPSkill(skillIndex):
self.AppendNeedHP(needSP, continuationSP, color)
else:
self.AppendNeedSP(needSP, continuationSP, color)
 
def AppendSkillRequirement(self, skillIndex, skillLevel):
 
skillMaxLevel = skill.GetSkillMaxLevel(skillIndex)
 
if skillLevel >= skillMaxLevel:
return
 
isAppendHorizontalLine = FALSE
 
## Requirement
if skill.IsSkillRequirement(skillIndex):
 
if not isAppendHorizontalLine:
isAppendHorizontalLine = TRUE
self.AppendHorizontalLine()
 
requireSkillName, requireSkillLevel = skill.GetSkillRequirementData(skillIndex)
 
color = self.CANNOT_LEVEL_UP_COLOR
if skill.CheckRequirementSueccess(skillIndex):
color = self.CAN_LEVEL_UP_COLOR
self.AppendTextLine(locale.TOOLTIP_REQUIREMENT_SKILL_LEVEL % (requireSkillName, requireSkillLevel), color)
 
## Require Stat
requireStatCount = skill.GetSkillRequireStatCount(skillIndex)
if requireStatCount > 0:
 
for i in xrange(requireStatCount):
type, level = skill.GetSkillRequireStatData(skillIndex, i)
if self.POINT_NAME_DICT.has_key(type):
 
if not isAppendHorizontalLine:
isAppendHorizontalLine = TRUE
self.AppendHorizontalLine()
 
name = self.POINT_NAME_DICT[type]
color = self.CANNOT_LEVEL_UP_COLOR
if player.GetStatus(type) >= level:
color = self.CAN_LEVEL_UP_COLOR
self.AppendTextLine(locale.TOOLTIP_REQUIREMENT_STAT_LEVEL % (name, level), color)
 
def HasSkillLevelDescription(self, skillIndex, skillLevel):
if skill.GetSkillAffectDescriptionCount(skillIndex) > 0:
return TRUE
if skill.GetSkillCoolTime(skillIndex, skillLevel) > 0:
return TRUE
if skill.GetSkillNeedSP(skillIndex, skillLevel) > 0:
return TRUE
 
return FALSE
 
def AppendMasterAffectDescription(self, index, desc, color):
self.AppendTextLine(desc, color)
 
def AppendNextAffectDescription(self, index, desc):
self.AppendTextLine(desc, self.DISABLE_COLOR)
 
def AppendNeedHP(self, needSP, continuationSP, color):
 
self.AppendTextLine(locale.TOOLTIP_NEED_HP % (needSP), color)
 
if continuationSP > 0:
self.AppendTextLine(locale.TOOLTIP_NEED_HP_PER_SEC % (continuationSP), color)
 
def AppendNeedSP(self, needSP, continuationSP, color):
 
if -1 == needSP:
self.AppendTextLine(locale.TOOLTIP_NEED_ALL_SP, color)
 
else:
self.AppendTextLine(locale.TOOLTIP_NEED_SP % (needSP), color)
 
if continuationSP > 0:
self.AppendTextLine(locale.TOOLTIP_NEED_SP_PER_SEC % (continuationSP), color)
 
def AppendPartySkillData(self, skillGrade, skillLevel):
 
if 1 == skillGrade:
skillLevel += 19
elif 2 == skillGrade:
skillLevel += 29
elif 3 == skillGrade:
skillLevel =  40
 
if skillLevel <= 0:
return
 
skillIndex = player.SKILL_INDEX_TONGSOL
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillPower = player.GetSkillCurrentEfficientPercentage(slotIndex)
if locale.IsBRAZIL():
k = skillPower
else:
k = player.GetSkillLevel(skillIndex) / 100.0
self.AppendSpace(5)
self.AutoAppendTextLine(locale.TOOLTIP_PARTY_SKILL_LEVEL % skillLevel, self.NORMAL_COLOR)
 
if skillLevel>=10:
self.AutoAppendTextLine(locale.PARTY_SKILL_ATTACKER % chop( 10 + 60 * k ))
 
if skillLevel>=20:
self.AutoAppendTextLine(locale.PARTY_SKILL_BERSERKER  % chop(1 + 5 * k))
self.AutoAppendTextLine(locale.PARTY_SKILL_TANKER  % chop(50 + 1450 * k))
 
if skillLevel>=25:
self.AutoAppendTextLine(locale.PARTY_SKILL_BUFFER % chop(5 + 45 * k ))
 
if skillLevel>=35:
self.AutoAppendTextLine(locale.PARTY_SKILL_SKILL_MASTER % chop(25 + 600 * k ))
 
if skillLevel>=40:
self.AutoAppendTextLine(locale.PARTY_SKILL_DEFENDER % chop( 5 + 30 * k ))
 
self.AlignHorizonalCenter()
 
def __AppendSummonDescription(self, skillLevel, color):
if skillLevel > 1:
self.AppendTextLine(locale.SKILL_SUMMON_DESCRIPTION % (skillLevel * 10), color)
elif 1 == skillLevel:
self.AppendTextLine(locale.SKILL_SUMMON_DESCRIPTION % (15), color)
elif 0 == skillLevel:
self.AppendTextLine(locale.SKILL_SUMMON_DESCRIPTION % (10), color)
 
 
if __name__ == "__main__": 
import app
import wndMgr
import systemSetting
import mouseModule
import grp
import ui
 
#wndMgr.SetOutlineFlag(TRUE)
 
app.SetMouseHandler(mouseModule.mouseController)
app.SetHairColorEnable(TRUE)
wndMgr.SetMouseHandler(mouseModule.mouseController)
wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
app.Create("METIN2 CLOSED BETA", systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
mouseModule.mouseController.Create()
 
toolTip = ItemToolTip()
toolTip.ClearToolTip()
#toolTip.AppendTextLine("Test")
desc = "Item descriptions:|increase of width of display to 35 digits per row AND installation of function that the displayed words are not broken up in two parts, but instead if one word is too long to be displayed in this row, this word will start in the next row."
summ = ""
 
toolTip.AddItemData_Offline(10, desc, summ, 0, 0) 
toolTip.Show()
 
app.Loop()

Mr-OMGWTF · 28 Lutego 2014

Pomoże ktoś ?

Mr-OMGWTF · 28 Lutego 2014

Do zamknięcia

Zaloguj się

👋 Witaj na MPCForum!

Problem z Clientem

Rekomendowane odpowiedzi

Mr-OMGWTF

Mr-OMGWTF

Czegewara.

Czegewara.

Mr-OMGWTF

Mr-OMGWTF

Mr-OMGWTF

Mr-OMGWTF

Mr-OMGWTF

Mr-OMGWTF

Zarchiwizowany