import ui
import uiScriptLocale
import wndMgr
import player
import miniMap
import locale
import net
import app
import colorInfo
import constInfo
import background

class MapTextToolTip(ui.Window):
def __init__(self):
ui.Window.__init__(self)

textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetHorizontalAlignCenter()
textLine.SetOutline()
textLine.SetHorizontalAlignRight()
textLine.Show()
self.textLine = textLine

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

def SetText(self, text):
self.textLine.SetText(text)

def SetTooltipPosition(self, PosX, PosY):
if locale.IsARABIC():
w, h = self.textLine.GetTextSize()
self.textLine.SetPosition(PosX - w - 5, PosY)
else:
self.textLine.SetPosition(PosX - 5, PosY)

def SetTextColor(self, TextColor):
self.textLine.SetPackedFontColor(TextColor)

def GetTextSize(self):
return self.textLine.GetTextSize()

class AtlasWindow(ui.ScriptWindow):

class AtlasRenderer(ui.Window):
def __init__(self):
ui.Window.__init__(self)
self.AddFlag("not_pick")

def OnUpdate(self):
miniMap.UpdateAtlas()

def OnRender(self):
(x, y) = self.GetGlobalPosition()
fx = float(x)
fy = float(y)
miniMap.RenderAtlas(fx, fy)

def HideAtlas(self):
miniMap.HideAtlas()

def ShowAtlas(self):
miniMap.ShowAtlas()

def __init__(self):
self.tooltipInfo = MapTextToolTip()
self.tooltipInfo.Hide()
self.infoGuildMark = ui.MarkBox()
self.infoGuildMark.Hide()
self.AtlasMainWindow = None
self.mapName = ""
self.board = 0

ui.ScriptWindow.__init__(self)

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

def SetMapName(self, mapName):
if 949==app.GetDefaultCodePage():
try:
self.board.SetTitleName(locale.MINIMAP_ZONE_NAME_DICT[mapName])
except:
pass

def LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/AtlasWindow.py")
except:
import exception
exception.Abort("AtlasWindow.LoadWindow.LoadScript")

try:
self.board = self.GetChild("board")

except:
import exception
exception.Abort("AtlasWindow.LoadWindow.BindObject")

self.AtlasMainWindow = self.AtlasRenderer()
self.board.SetCloseEvent(self.Hide)
self.AtlasMainWindow.SetParent(self.board)
self.AtlasMainWindow.SetPosition(7, 30)
self.tooltipInfo.SetParent(self.board)
self.infoGuildMark.SetParent(self.board)
self.SetPosition(wndMgr.GetScreenWidth() - 136 - 256 - 10, 0)
self.Hide()

miniMap.RegisterAtlasWindow(self)

def Destroy(self):
miniMap.UnregisterAtlasWindow()
self.ClearDictionary()
self.AtlasMainWindow = None
self.tooltipAtlasClose = 0
self.tooltipInfo = None
self.infoGuildMark = None
self.board = None

def OnUpdate(self):

if not self.tooltipInfo:
return

if not self.infoGuildMark:
return

self.infoGuildMark.Hide()
self.tooltipInfo.Hide()

if FALSE == self.board.IsIn():
return

(mouseX, mouseY) = wndMgr.GetMousePosition()
(bFind, sName, iPosX, iPosY, dwTextColor, dwGuildID) = miniMap.GetAtlasInfo(mouseX, mouseY)

if FALSE == bFind:
return

if "empty_guild_area" == sName:
sName = locale.GUILD_EMPTY_AREA

if locale.IsARABIC() and sName[-1].isalnum():
self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
else:
self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))

(x, y) = self.GetGlobalPosition()
self.tooltipInfo.SetTooltipPosition(mouseX - x, mouseY - y)
self.tooltipInfo.SetTextColor(dwTextColor)
self.tooltipInfo.Show()
self.tooltipInfo.SetTop()

if 0 != dwGuildID:
textWidth, textHeight = self.tooltipInfo.GetTextSize()
self.infoGuildMark.SetIndex(dwGuildID)
self.infoGuildMark.SetPosition(mouseX - x - textWidth - 18 - 5, mouseY - y)
self.infoGuildMark.Show()

def Hide(self):
if self.AtlasMainWindow:
self.AtlasMainWindow.HideAtlas()
self.AtlasMainWindow.Hide()
ui.ScriptWindow.Hide(self)

def Show(self):
if self.AtlasMainWindow:
(bGet, iSizeX, iSizeY) = miniMap.GetAtlasSize()
if bGet:
self.SetSize(iSizeX + 15, iSizeY + 38)

if locale.IsARABIC():
self.board.SetPosition(iSizeX+15, 0)

self.board.SetSize(iSizeX + 15, iSizeY + 38)
#self.AtlasMainWindow.SetSize(iSizeX, iSizeY)
self.AtlasMainWindow.ShowAtlas()
self.AtlasMainWindow.Show()
ui.ScriptWindow.Show(self)

def SetCenterPositionAdjust(self, x, y):
self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)

def OnPressEscapeKey(self):
self.Hide()
return TRUE

def __RegisterMiniMapColor(type, rgb):
miniMap.RegisterColor(type, rgb[0], rgb[1], rgb[2])

class MiniMap(ui.ScriptWindow):

CANNOT_SEE_INFO_MAP_DICT = {
"metin2_map_monkeydungeon" : FALSE,
"metin2_map_monkeydungeon_02" : FALSE,
"metin2_map_monkeydungeon_03" : FALSE,
"metin2_map_devilsCatacomb" : FALSE,
}

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

self.__Initialize()

miniMap.Create()
miniMap.SetScale(2.0)

self.AtlasWindow = AtlasWindow()
self.AtlasWindow.LoadWindow()
self.AtlasWindow.Hide()

self.tooltipMiniMapOpen = MapTextToolTip()
self.tooltipMiniMapOpen.SetText(locale.MINIMAP)
self.tooltipMiniMapOpen.Show()
self.tooltipMiniMapClose = MapTextToolTip()
self.tooltipMiniMapClose.SetText(locale.UI_CLOSE)
self.tooltipMiniMapClose.Show()
self.tooltipScaleUp = MapTextToolTip()
self.tooltipScaleUp.SetText(locale.MINIMAP_INC_SCALE)
self.tooltipScaleUp.Show()
self.tooltipScaleDown = MapTextToolTip()
self.tooltipScaleDown.SetText(locale.MINIMAP_DEC_SCALE)
self.tooltipScaleDown.Show()
self.tooltipAtlasOpen = MapTextToolTip()
self.tooltipAtlasOpen.SetText(locale.MINIMAP_SHOW_AREAMAP)
self.tooltipAtlasOpen.Show()
self.tooltipInfo = MapTextToolTip()
self.tooltipInfo.Show()

if miniMap.IsAtlas():
self.tooltipAtlasOpen.SetText(locale.MINIMAP_SHOW_AREAMAP)
else:
self.tooltipAtlasOpen.SetText(locale.MINIMAP_CAN_NOT_SHOW_AREAMAP)

self.tooltipInfo = MapTextToolTip()
self.tooltipInfo.Show()

self.mapName = ""

self.isLoaded = 0
self.canSeeInfo = TRUE

# AUTOBAN
self.imprisonmentDuration = 0
self.imprisonmentEndTime = 0
self.imprisonmentEndTimeText = ""
# END_OF_AUTOBAN

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

def __Initialize(self):
self.positionInfo = 0
self.observerCount = 0

self.OpenWindow = 0
self.CloseWindow = 0
self.ScaleUpButton = 0
self.ScaleDownButton = 0
self.MiniMapHideButton = 0
self.MiniMapShowButton = 0
self.AtlasShowButton = 0

self.tooltipMiniMapOpen = 0
self.tooltipMiniMapClose = 0
self.tooltipScaleUp = 0
self.tooltipScaleDown = 0
self.tooltipAtlasOpen = 0
self.tooltipInfo = None
self.serverInfo = None

def SetMapName(self, mapName):
self.mapName=mapName
self.AtlasWindow.SetMapName(mapName)

if self.CANNOT_SEE_INFO_MAP_DICT.has_key(mapName):
self.canSeeInfo = FALSE
self.HideMiniMap()
self.tooltipMiniMapOpen.SetText(locale.MINIMAP_CANNOT_SEE)
else:
self.canSeeInfo = TRUE
self.ShowMiniMap()
self.tooltipMiniMapOpen.SetText(locale.MINIMAP)

# AUTOBAN
def SetImprisonmentDuration(self, duration):
self.imprisonmentDuration = duration
self.imprisonmentEndTime = app.GetGlobalTimeStamp() + duration

self.__UpdateImprisonmentDurationText()

def __UpdateImprisonmentDurationText(self):
restTime = max(self.imprisonmentEndTime - app.GetGlobalTimeStamp(), 0)

imprisonmentEndTimeText = locale.SecondToDHM(restTime)
if imprisonmentEndTimeText != self.imprisonmentEndTimeText:
self.imprisonmentEndTimeText = imprisonmentEndTimeText
self.serverInfo.SetText("%s: %s" % (uiScriptLocale.AUTOBAN_QUIZ_REST_TIME, self.imprisonmentEndTimeText))
# END_OF_AUTOBAN

def Show(self):
self.__LoadWindow()

ui.ScriptWindow.Show(self)

def __LoadWindow(self):
if self.isLoaded == 1:
return

self.isLoaded = 1

try:
pyScrLoader = ui.PythonScriptLoader()
if locale.IsARABIC():
pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "Minimap.py")
else:
pyScrLoader.LoadScriptFile(self, "UIScript/MiniMap.py")
except:
import exception
exception.Abort("MiniMap.LoadWindow.LoadScript")

try:
self.OpenWindow = self.GetChild("OpenWindow")
self.MiniMapWindow = self.GetChild("MiniMapWindow")
self.ScaleUpButton = self.GetChild("ScaleUpButton")
self.ScaleDownButton = self.GetChild("ScaleDownButton")
self.MiniMapHideButton = self.GetChild("MiniMapHideButton")
self.AtlasShowButton = self.GetChild("AtlasShowButton")
self.CloseWindow = self.GetChild("CloseWindow")
self.MiniMapShowButton = self.GetChild("MiniMapShowButton")
self.positionInfo = self.GetChild("PositionInfo")
self.observerCount = self.GetChild("ObserverCount")
self.serverInfo = self.GetChild("ServerInfo")
except:
import exception
exception.Abort("MiniMap.LoadWindow.Bind")

if constInfo.MINIMAP_POSITIONINFO_ENABLE==0:
self.positionInfo.Hide()

self.serverInfo.SetText(net.GetServerInfo())
self.ScaleUpButton.SetEvent(ui.__mem_func__(self.ScaleUp))
self.ScaleDownButton.SetEvent(ui.__mem_func__(self.ScaleDown))
self.MiniMapHideButton.SetEvent(ui.__mem_func__(self.HideMiniMap))
self.MiniMapShowButton.SetEvent(ui.__mem_func__(self.ShowMiniMap))

if miniMap.IsAtlas():
self.AtlasShowButton.SetEvent(ui.__mem_func__(self.ShowAtlas))

(ButtonPosX, ButtonPosY) = self.MiniMapShowButton.GetGlobalPosition()
self.tooltipMiniMapOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)

(ButtonPosX, ButtonPosY) = self.MiniMapHideButton.GetGlobalPosition()
self.tooltipMiniMapClose.SetTooltipPosition(ButtonPosX, ButtonPosY)

(ButtonPosX, ButtonPosY) = self.ScaleUpButton.GetGlobalPosition()
self.tooltipScaleUp.SetTooltipPosition(ButtonPosX, ButtonPosY)

(ButtonPosX, ButtonPosY) = self.ScaleDownButton.GetGlobalPosition()
self.tooltipScaleDown.SetTooltipPosition(ButtonPosX, ButtonPosY)

(ButtonPosX, ButtonPosY) = self.AtlasShowButton.GetGlobalPosition()
self.tooltipAtlasOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)

self.ShowMiniMap()

def Destroy(self):
self.HideMiniMap()

self.AtlasWindow.Destroy()
self.AtlasWindow = None

self.ClearDictionary()

self.__Initialize()

def UpdateObserverCount(self, observerCount):
if observerCount>0:
self.observerCount.Show()
elif observerCount<=0:
self.observerCount.Hide()

self.observerCount.SetText(locale.MINIMAP_OBSERVER_COUNT % observerCount)

def OnUpdate(self):
(x, y, z) = player.GetMainCharacterPosition()
miniMap.Update(x, y)

self.positionInfo.SetText("(%.0f, %.0f)" % (x/100, y/100))

if self.tooltipInfo:
if TRUE == self.MiniMapWindow.IsIn():
(mouseX, mouseY) = wndMgr.GetMousePosition()
(bFind, sName, iPosX, iPosY, dwTextColor) = miniMap.GetInfo(mouseX, mouseY)
if bFind == 0:
self.tooltipInfo.Hide()
elif not self.canSeeInfo:
self.tooltipInfo.SetText("%s(%s)" % (sName, locale.UI_POS_UNKNOWN))
self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
self.tooltipInfo.SetTextColor(dwTextColor)
self.tooltipInfo.Show()
else:
if locale.IsARABIC() and sName[-1].isalnum():
self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
else:
self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))
self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
self.tooltipInfo.SetTextColor(dwTextColor)
self.tooltipInfo.Show()
else:
self.tooltipInfo.Hide()

# AUTOBAN
if self.imprisonmentDuration:
self.__UpdateImprisonmentDurationText()
# END_OF_AUTOBAN

if TRUE == self.MiniMapShowButton.IsIn():
self.tooltipMiniMapOpen.Show()
else:
self.tooltipMiniMapOpen.Hide()

if TRUE == self.MiniMapHideButton.IsIn():
self.tooltipMiniMapClose.Show()
else:
self.tooltipMiniMapClose.Hide()

if TRUE == self.ScaleUpButton.IsIn():
self.tooltipScaleUp.Show()
else:
self.tooltipScaleUp.Hide()

if TRUE == self.ScaleDownButton.IsIn():
self.tooltipScaleDown.Show()
else:
self.tooltipScaleDown.Hide()

if TRUE == self.AtlasShowButton.IsIn():
self.tooltipAtlasOpen.Show()
else:
self.tooltipAtlasOpen.Hide()

def OnRender(self):
(x, y) = self.GetGlobalPosition()
fx = float(x)
fy = float(y)
miniMap.Render(fx + 4.0, fy + 5.0)

def Close(self):
self.HideMiniMap()

def HideMiniMap(self):
miniMap.Hide()
self.OpenWindow.Hide()
self.CloseWindow.Show()

def ShowMiniMap(self):
if not self.canSeeInfo:
return

miniMap.Show()
self.OpenWindow.Show()
self.CloseWindow.Hide()

def isShowMiniMap(self):
return miniMap.isShow()

def ScaleUp(self):
miniMap.ScaleUp()

def ScaleDown(self):
miniMap.ScaleDown()

def ShowAtlas(self):
if not miniMap.IsAtlas():
return
if not self.AtlasWindow.IsShow():
self.AtlasWindow.Show()

def ToggleAtlasWindow(self):
if not miniMap.IsAtlas():
return
if self.AtlasWindow.IsShow():
self.AtlasWindow.Hide()
else:
self.AtlasWindow.Show()