Skocz do zawartości

  • 👋 Witaj na MPCForum!

    Przeglądasz forum jako gość, co oznacza, że wiele świetnych funkcji jest jeszcze przed Tobą! 😎

    • ✅ Pełny dostęp do działów i ukrytych treści
    • ✅ Możliwość pisania i odpowiadania w tematach
    • ✅ System prywatnych wiadomości
    • ✅ Zbieranie reputacji i rozwijanie swojego profilu
    • ✅ Członkostwo w jednej z największych społeczności graczy

    👉 Dołączenie zajmie Ci mniej niż minutę – a zyskasz znacznie więcej!

    Zarejestruj się teraz

Czyste serverfiles by Terenzo.

Terenzo.

Przez Terenzo.
w Kosz

Rekomendowane odpowiedzi

  • Odpowiedzi 6 tys.
  • Dodano
  • Ostatniej odpowiedzi

Top użytkownicy w tym temacie

Top użytkownicy w tym temacie

xXEragoN94Xx Uczeń

xXEragoN94Xx

Opublikowano
Uczeń

xXEragoN94Xx

Opublikowano

Witam mam problem z klientem a mianowicie z item_proto ponieważ wyskakują mi krzaki mógł by ktoś mi podesłać jakiś program do edycji lub drugie item_proto bez krzaków ?? 

n3xtxd Uczeń

n3xtxd

Opublikowano
Uczeń

n3xtxd

Opublikowano

 

1. Za każdym razem gdy loguję się na te stare konta, po załadowaniu paska wywala całkowicie metina. (myślę, że z nowymi jest to samo)

2. Gdy chcę zrobić nową postać, po wybraniu królestwa -> dalej -> czarny ekran....

 

O co chodzi? ;/

syserr:

To jest ukryta treść, proszę

@Up tez mam ten problem prosze o pomoc

Terenzo. Weteran

Terenzo.

Opublikowano
Weteran

Terenzo.

  • Autor
Opublikowano

@Up tez mam ten problem prosze o pomoc

zmień program do pakowania, bo ten który teraz masz uszkadza pliki podczas rozpakowywania. w temacie dałem poprawnie rozpakowane root.

n3xtxd Uczeń

n3xtxd

Opublikowano
Uczeń

n3xtxd

Opublikowano (edytowane)

Problem polega na tym że root jest ok bo łączy mnie tylko podczas wyboru postaci stwarzając nową i wybierając królestwo pojawia się czarny ekran ;/

 

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, inventorySlotIndex, privateShopSlotIndex):
itemVnum = player.GetItemIndex(inventorySlotIndex)
if 0 == itemVnum:
return

item.SelectItem(itemVnum)
self.ClearToolTip()
self.AppendSellingPrice(shop.GetPrivateShopItemPrice(inventorySlotIndex))

metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(player.GetItemMetinSocket(inventorySlotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(player.GetItemAttribute(inventorySlotIndex, 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[0]
value = attrSlot[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[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
if self.GetMetinItemIndex(metinSlotData) == constInfo.ERROR_METIN_STONE:
metinSlot=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])

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 __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[0]
value = attrSlot[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
flag = flagList

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
flag = flagList

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)

def __AppendMetinSlotInfo_IsEmptySlotList(self, metinSlot):
if 0 == metinSlot:
return 1

for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlotData=metinSlot
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()

 

Dodałem zawartość tego pliku bo nie wiem co mam sprawdzić ;c 

Edytowane przez n3xtxd
Terenzo. Weteran

Terenzo.

Opublikowano
Weteran

Terenzo.

  • Autor
Opublikowano

Problem polega na tym że root jest ok bo łączy mnie tylko podczas wyboru postaci stwarzając nową i wybierając królestwo pojawia się czarny ekran ;/

sprawdź zawartość pliku uitooltip.py

n3xtxd Uczeń

n3xtxd

Opublikowano
Uczeń

n3xtxd

Opublikowano

Dobra może inaczej są dwie różne sytuacje i daje wpisy z syserr

1.Loguje się na stworzoną wcześniej postać na koncie Ethoard...ładuje się i buum wyłącza klient

Syserr:

 

0414 00:52:20817 :: CMapBase::LoadProperty(FileName=metin2_map_b1\MapProperty.txt) - LoadMultipleTextData ERROR ĆÄŔĎŔĚ ľřŔ» °ˇ´ÉĽşŔĚ ¸ą˝Ŕ´Ď´Ů.
0414 00:52:20817 :: CMapManager::LoadMap() Invalid Map Type
0414 00:52:20817 :: CPythonBackground::SelectViewDistanceNum(int eNum=0) mc_pcurEnvironmentData is NULL

 

2.Robię nową postać na nowym koncie,wybieram królestwo i buum czarny ekran...

Syserr:

 

0414 00:56:10767 :: Traceback (most recent call last):

0414 00:56:10767 :: File "uiPhaseCurtain.py", line 61, in OnUpdate

0414 00:56:10767 :: File "networkModule.py", line 150, in __ChangePhaseWindow

0414 00:56:10767 :: File "introCreate.py", line 235, in Open

0414 00:56:10767 :: AttributeError
0414 00:56:10768 :: :
0414 00:56:10768 :: 'module' object has no attribute 'ToolTip'
0414 00:56:10768 ::

 

polek2 Pomocnik

polek2

Opublikowano
Pomocnik

polek2

Opublikowano

Witam mam problem bo nie mogę coś się połączyć z FTP.

Mysql działa normalnie

próbuje za pomocą total comandera sie połączyć co może być przyczyną ze nie łączy się.?

OG4R3K Pomocnik

OG4R3K

Opublikowano
Pomocnik

OG4R3K

Opublikowano

Witam mam problem bo nie mogę coś się połączyć z FTP.

Mysql działa normalnie

próbuje za pomocą total comandera sie połączyć co może być przyczyną ze nie łączy się.?

 

Nie wiem jak jest w comander'ze ale w FilleZilla  podajesz serwer: ip hamachi z końcówką .100, nazwa użutkownika: root, hasło: takie jakie masz ustawione do logowania się do maszyny, port: 22

Nexoria Nowicjusz

Nexoria

Opublikowano
Nowicjusz

Nexoria

Opublikowano

Nie mogę połączyć się z bazą danych coś z portami 10061

Może sprawdź Sysser w Game, lub odinstaluj MYSQL na nowo wgraj.

w6qirs.jpg

Dawid9121 Pomocnik

Dawid9121

Opublikowano
Pomocnik

Dawid9121

Opublikowano (edytowane)

n3xtxd Ziomek mam tan sam problem prosze o pomoc nwm co się dzieje a tam co pisał terenzo żeby sprawdzić uitooltip.py to nie mam nic napisane :/

Edytowane przez Dawid9121
Swiezu Bywalec

Swiezu

Opublikowano
Bywalec

Swiezu

Opublikowano

Nieodblokowany prot? Ip z .100 jesli w hamatchi

 

733761405517115815990.png

"To, że milczę, nie znaczy, że nie mam nic do powiedzenia" ~Jonathan Carroll

Dawid9121 Pomocnik

Dawid9121

Opublikowano
Pomocnik

Dawid9121

Opublikowano (edytowane)

terenzo thx wszystko śmiga tylko pytanie dlaczego  nie działało jak rozpakowałem archiverm 2.3 , a ty czym rozpakowywałeś  ? 

Edytowane przez Dawid9121
Dawid9121 Pomocnik

Dawid9121

Opublikowano
Pomocnik

Dawid9121

Opublikowano (edytowane)

terenzo jak jeszcze mozesz to zerknij na blad z konsili po wyłączeniu serwera mam takie cos http://speedy.sh/g9N6d/Bez-tytulu.png i później nie idzie sie z postacią połączyć 

 

Już ok siostra mi wyłączyła portmapa ;p ale błędy nie znikły w konsoli ;/

 

Już sb poradziłem :D błędy znikły 

Edytowane przez Dawid9121
WeedProjects Uczeń

WeedProjects

Opublikowano
Uczeń

WeedProjects

Opublikowano

no niestety, nie mogę polecic pliczkow .pare razy pracowalem na nich i za każdym razem było coś nie tak, po tygodniu nie działal zaden quest, sysery puste . szkoda gadac, lepiej sciagcie by terenzo ale na game 2089

Swiezu Bywalec

Swiezu

Opublikowano
Bywalec

Swiezu

Opublikowano

Czy wie ktoś jak zrobić PET'y żeby się poruszały ? tzn nie stały tak sztywno, tylko ruszały się po przywołaniu jak na PL'u czy balmorze ?

733761405517115815990.png

"To, że milczę, nie znaczy, że nie mam nic do powiedzenia" ~Jonathan Carroll

Swiezu Bywalec

Swiezu

Opublikowano
Bywalec

Swiezu

Opublikowano (edytowane)

Na game 40k nie będzie jeszcze nic poważnego, dłuuugo :P
Jest to stosunkowo b.nowa wersja i strach pomyśleć jakie może mieć bugi.

@Edit
Czy wie ktoś jak zrobić PET'y żeby się poruszały ? Jak np. konie po przywołaniu, żeby nie stał w miejscu tylko się ruszał :P

Edytowane przez osa1022

733761405517115815990.png

"To, że milczę, nie znaczy, że nie mam nic do powiedzenia" ~Jonathan Carroll

Gość
Ten temat został zamknięty. Brak możliwości dodania odpowiedzi.
Tematy
×
×
  • Dodaj nową pozycję...