import os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import snd
import chat
import textTail
import snd
import net
import effect
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import messenger
import localeInfo
import constInfo
import exchange
import ime
import time
import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import time
import uiTombola

# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST

# OFFLINE_SHOP_PRICE_LIST
import uiOfflineShopBuilder
# END_OF_OFFLINE_SHOP_PRICE_LIST
import uiOfflineShop

import mouseModule
import consoleModule
import localeInfo

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander

from _weakref import proxy
from switchbot import Bot

# TEXTTAIL_LIVINGTIME_CONTROL
#if localeInfo.IsJAPAN():
# app.SetTextTailLivingTime(8.0)
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL

# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = None

if localeInfo.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUE

if localeInfo.IsCIBN10():
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = "YT2W"

cameraDistance = 1550.0
cameraPitch = 27.0
cameraRotation = 0.0
cameraHeight = 100.0

testAlignment = 0
BPisLodaded = 0

class GameWindow(ui.ScriptWindow):
def __init__(self, stream):
ui.ScriptWindow.__init__(self, "GAME")
self.SetWindowName("game")
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
player.SetGameWindow(self)
self.utilizareTaste = time.clock() + 5

self.quickSlotPageIndex = 0
self.lastPKModeSendedTime = 0
self.pressNumber = None
self.switchbot = Bot()
self.switchbot.Hide()

self.guildWarQuestionDialog = None
self.interface = None
self.targetBoard = None
self.console = None
self.mapNameShower = None
self.affectShower = None
self.playerGauge = None

self.stream=stream
self.interface = interfaceModule.Interface()
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()

constInfo.wndTombola = uiTombola.TombolaWindow()

self.curtain = uiPhaseCurtain.PhaseCurtain()
self.curtain.speed = 0.03
self.curtain.Hide()

self.targetBoard = uiTarget.TargetBoard()
self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
self.targetBoard.Hide()

self.console = consoleModule.ConsoleWindow()
self.console.BindGameClass(self)
self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)
self.console.Hide()

self.mapNameShower = uiMapNameShower.MapNameShower()
self.affectShower = uiAffectShower.AffectShower()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)
self.playerGauge.Hide()

#wj 2014.1.2. ESC키를 누를 시 우선적으로 DropQuestionDialog를 끄도록 만들었다. 하지만 처음에 itemDropQuestionDialog가 선언되어 있지 않아 ERROR가 발생하여 init에서 선언과 동시에 초기화 시킴.
self.itemDropQuestionDialog = None

self.__SetQuickSlotMode()

self.__ServerCommand_Build()
self.__ProcessPreservedServerCommand()

self.timeLine = ui.TextLine()
self.timeLine.SetFontName(localeInfo.UI_DEF_FONT)
self.timeLine.SetFontColor( 255, 045, 0)
self.timeLine.SetPosition((wndMgr.GetScreenWidth() - 130) / 2, 180)

def __del__(self):
player.SetGameWindow(0)
net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)
ui.ScriptWindow.__del__(self)

def Open(self):
app.SetFrameSkip(1)

self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())

self.quickSlotPageIndex = 0
self.PickingCharacterIndex = -1
self.PickingItemIndex = -1
self.consoleEnable = FALSE
self.isShowDebugInfo = FALSE
self.ShowNameFlag = FALSE

self.enableXMasBoom = FALSE
self.startTimeXMasBoom = 0.0
self.indexXMasBoom = 0

global cameraDistance, cameraPitch, cameraRotation, cameraHeight

app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)

constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
constInfo.SET_DEFAULT_CHRNAME_COLOR()
constInfo.SET_DEFAULT_FOG_LEVEL()
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()

# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

import event
event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)

textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

if constInfo.PVPMODE_TEST_ENABLE:
self.testPKMode = ui.TextLine()
self.testPKMode.SetFontName(localeInfo.UI_DEF_FONT)
self.testPKMode.SetPosition(0, 15)
self.testPKMode.SetWindowHorizontalAlignCenter()
self.testPKMode.SetHorizontalAlignCenter()
self.testPKMode.SetFeather()
self.testPKMode.SetOutline()
self.testPKMode.Show()

self.testAlignment = ui.TextLine()
self.testAlignment.SetFontName(localeInfo.UI_DEF_FONT)
self.testAlignment.SetPosition(0, 35)
self.testAlignment.SetWindowHorizontalAlignCenter()
self.testAlignment.SetHorizontalAlignCenter()
self.testAlignment.SetFeather()
self.testAlignment.SetOutline()
self.testAlignment.Show()

self.__BuildKeyDict()
self.__BuildDebugInfo()

# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST

# OFFLINE_SHOP_PRICE_LIST
uiOfflineShopBuilder.Clear()
# END_OF_OFFLINE_SHOP_PRICE_LIST

# UNKNOWN_UPDATE
exchange.InitTrading()
# END_OF_UNKNOWN_UPDATE

if debugInfo.IsDebugMode():
self.ToggleDebugInfo()

## Sound
snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())
snd.SetSoundVolume(systemSetting.GetSoundVolume())

netFieldMusicFileName = net.GetFieldMusicFileName()
if netFieldMusicFileName:
snd.FadeInMusic("BGM/" + netFieldMusicFileName)
elif musicInfo.fieldMusic != "":
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)

self.__SetQuickSlotMode()
self.__SelectQuickPage(self.quickSlotPageIndex)

self.SetFocus()
self.Show()
app.ShowCursor()

net.SendEnterGamePacket()

# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT

# NPC가 큐브시스템으로 만들 수 있는 아이템들의 목록을 캐싱
# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
self.cubeInformation = {}
self.currentCubeNPC = 0

def Close(self):
self.Hide()

global cameraDistance, cameraPitch, cameraRotation, cameraHeight
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()

if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)

self.onPressKeyDict = None
self.onClickKeyDict = None

chat.Close()
snd.StopAllSound()
grp.InitScreenEffect()
chr.Destroy()
textTail.Clear()
quest.Clear()
background.Destroy()
guild.Destroy()
constInfo.wndTombola.Close()
messenger.Destroy()
skill.ClearSkillData()
wndMgr.Unlock()
mouseModule.mouseController.DeattachObject()

if self.guildWarQuestionDialog:
self.guildWarQuestionDialog.Close()

self.guildNameBoard = None
self.partyRequestQuestionDialog = None
self.partyInviteQuestionDialog = None
self.guildInviteQuestionDialog = None
self.guildWarQuestionDialog = None
self.messengerAddFriendQuestion = None

# UNKNOWN_UPDATE
self.itemDropQuestionDialog = None
# END_OF_UNKNOWN_UPDATE

# QUEST_CONFIRM
self.confirmDialog = None
# END_OF_QUEST_CONFIRM

self.PrintCoord = None
self.FrameRate = None
self.Pitch = None
self.Splat = None
self.TextureNum = None
self.ObjectNum = None
self.ViewDistance = None
self.PrintMousePos = None

self.ClearDictionary()

self.playerGauge = None
self.mapNameShower = None
self.affectShower = None

if self.console:
self.console.BindGameClass(0)
self.console.Close()
self.console=None

if self.targetBoard:
self.targetBoard.Destroy()
self.targetBoard = None

if self.interface:
self.interface.HideAllWindows()
self.interface.Close()
self.interface=None

player.ClearSkillDict()
player.ResetCameraRotation()

self.KillFocus()
app.HideCursor()

print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"

def __BuildKeyDict(self):
onPressKeyDict = {}

##PressKey 는 누르고 있는 동안 계속 적용되는 키이다.

## 숫자 단축키 퀵슬롯에 이용된다.(이후 숫자들도 퀵 슬롯용 예약)
## F12 는 클라 디버그용 키이므로 쓰지 않는 게 좋다.
onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1)
onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2)
onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3)
onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4)
onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5)
onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6)
onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7)
onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8)
onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9)
onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4)
onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5)
onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6)
onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)
onPressKeyDict[app.DIK_F5] = lambda : self.__toggleSwitchbot()
onPressKeyDict[app.DIK_P] = lambda : self.__toggleSwitchbot()
onPressKeyDict[app.DIK_F6] = lambda : self.__quikeqchange()
onPressKeyDict[app.DIK_X] = lambda : self.__BonusPage()
onPressKeyDict[app.DIK_F7] = lambda : self.__Radio()

onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()
onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()
onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()
onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()

#캐릭터 이동키
onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()
onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()
onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()
onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()
onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()
onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()
onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()
onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)
#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_G] = self.__PressGKey
onPressKeyDict[app.DIK_Q] = self.__PressQKey

onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()
onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
onPressKeyDict[app.DIK_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()
#onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()

onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()

# CUBE_TEST
#onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
# CUBE_TEST_END

self.onPressKeyDict = onPressKeyDict

onClickKeyDict = {}
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()

onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_G] = lambda: self.__ReleaseGKey()
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()

#if constInfo.PVPMODE_ACCELKEY_ENABLE:
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()

self.onClickKeyDict=onClickKeyDict

def __PressNumKey(self,num):
if time.clock() >= self.utilizareTaste:
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):

if num >= 1 and num <= 9:
if(chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1,int(num)-1)
net.SendEmoticon(int(num)-1)
else:
if num >= 1 and num <= 4:
self.pressNumber(num-1)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Mai asteapta cateva secunde pentru a putea folosi comanda.")

def __ClickBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
return
else:
if constInfo.PVPMODE_ACCELKEY_ENABLE:
self.ChangePKMode()


def __PressJKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
#net.SendChatPacket("/user_horse_ride")
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
for i in xrange(player.INVENTORY_PAGE_SIZE):
if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
net.SendItemUsePacket(i)
break
def __PressHKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")
else:
self.interface.OpenHelpWindow()

def __PressBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_back")
else:
state = "EMOTICON"
self.interface.ToggleCharacterWindow(state)

def __PressFKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_feed")
else:
app.ZoomCamera(app.CAMERA_TO_POSITIVE)

def __PressGKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/ride")
else:
if self.ShowNameFlag:
self.interface.ToggleGuildWindow()
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)

def __ReleaseGKey(self):
app.PitchCamera(app.CAMERA_STOP)

def __PressQKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if 0==interfaceModule.IsQBHide:
interfaceModule.IsQBHide = 1
self.interface.HideAllQuestButton()
else:
interfaceModule.IsQBHide = 0
self.interface.ShowAllQuestButton()
else:
app.RotateCamera(app.CAMERA_TO_NEGATIVE)

def __SetQuickSlotMode(self):
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)

def __SetQuickPageMode(self):
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)

def __PressQuickSlot(self, localSlotIndex):
if time.clock() >= self.utilizareTaste:
player.RequestUseLocalQuickSlot(localSlotIndex)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Mai asteapta cateva secunde pentru a putea folosi comanda.")

def __SelectQuickPage(self, pageIndex):
self.quickSlotPageIndex = pageIndex
player.SetQuickPage(pageIndex)

def ToggleDebugInfo(self):
self.isShowDebugInfo = not self.isShowDebugInfo

if self.isShowDebugInfo:
self.PrintCoord.Show()
self.FrameRate.Show()
self.Pitch.Show()
self.Splat.Show()
self.TextureNum.Show()
self.ObjectNum.Show()
self.ViewDistance.Show()
self.PrintMousePos.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()
self.PrintMousePos.Hide()

def __BuildDebugInfo(self):
## Character Position Coordinate
self.PrintCoord = ui.TextLine()
self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)

## Frame Rate
self.FrameRate = ui.TextLine()
self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)

## Camera Pitch
self.Pitch = ui.TextLine()
self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)

## Splat
self.Splat = ui.TextLine()
self.Splat.SetFontName(localeInfo.UI_DEF_FONT)
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)

##
self.PrintMousePos = ui.TextLine()
self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)

# TextureNum
self.TextureNum = ui.TextLine()
self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)

# 오브젝트 그리는 개수
self.ObjectNum = ui.TextLine()
self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)

# 시야거리
self.ViewDistance = ui.TextLine()
self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
self.ViewDistance.SetPosition(0, 0)

#Saat
self.timeLine.SetWindowHorizontalAlignCenter()
self.timeLine.SetHorizontalAlignCenter()
self.timeLine.SetFeather()
self.timeLine.SetOutline()
self.timeLine.Show()

def __NotifyError(self, msg):
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)

def ChangePKMode(self):

if not app.IsPressed(app.DIK_LCONTROL):
return

if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
return

curTime = app.GetTime()
if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
return

self.lastPKModeSendedTime = curTime

curPKMode = player.GetPKMode()
nextPKMode = curPKMode + 1
if nextPKMode == player.PK_MODE_PROTECT:
if 0 == player.GetGuildID():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OPTION_PVPMODE_CANNOT_SET_GUILD_MODE)
nextPKMode = 0
else:
nextPKMode = player.PK_MODE_GUILD

elif nextPKMode == player.PK_MODE_MAX_NUM:
nextPKMode = 0

net.SendChatPacket("/PKMode " + str(nextPKMode))
print "/PKMode " + str(nextPKMode)

def OnChangePKMode(self):

self.interface.OnChangePKMode()

try:
self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])
except KeyError:
print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())

if constInfo.PVPMODE_TEST_ENABLE:
curPKMode = player.GetPKMode()
alignment, grade = chr.testGetPKData()
self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }
self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))
self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + localeInfo.TITLE_NAME_LIST[grade] + ")")

###############################################################################################
###############################################################################################
## Game Callback Functions

# Start
def StartGame(self):
self.RefreshInventory()
self.RefreshEquipment()
self.RefreshCharacter()
self.RefreshSkill()

# Refresh
def CheckGameButton(self):
if self.interface:
self.interface.CheckGameButton()

def RefreshAlignment(self):
self.interface.RefreshAlignment()

def RefreshStatus(self):
self.CheckGameButton()

if self.interface:
self.interface.RefreshStatus()

if self.playerGauge:
self.playerGauge.RefreshGauge()

def RefreshStamina(self):
self.interface.RefreshStamina()

def RefreshSkill(self):
self.CheckGameButton()
if self.interface:
self.interface.RefreshSkill()

def RefreshQuest(self):
self.interface.RefreshQuest()

def RefreshMessenger(self):
self.interface.RefreshMessenger()

def RefreshGuildInfoPage(self):
self.interface.RefreshGuildInfoPage()

def RefreshGuildBoardPage(self):
self.interface.RefreshGuildBoardPage()

def RefreshGuildMemberPage(self):
self.interface.RefreshGuildMemberPage()

def RefreshGuildMemberPageGradeComboBox(self):
self.interface.RefreshGuildMemberPageGradeComboBox()

def RefreshGuildSkillPage(self):
self.interface.RefreshGuildSkillPage()

def RefreshGuildGradePage(self):
self.interface.RefreshGuildGradePage()

def RefreshMobile(self):
if self.interface:
self.interface.RefreshMobile()

def OnMobileAuthority(self):
self.interface.OnMobileAuthority()

def OnBlockMode(self, mode):
self.interface.OnBlockMode(mode)

def OpenQuestWindow(self, skin, idx):
if constInfo.INPUT_IGNORE == 1:
return
else:
self.interface.OpenQuestWindow(skin, idx)

def AskGuildName(self):

guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(localeInfo.GUILD_NAME)
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))
guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))
guildNameBoard.Open()

self.guildNameBoard = guildNameBoard

def ConfirmGuildName(self):
guildName = self.guildNameBoard.GetText()
if not guildName:
return

if net.IsInsultIn(guildName):
self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
return

net.SendAnswerMakeGuildPacket(guildName)
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE

def CancelGuildName(self):
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE

## Refine
def PopupMessage(self, msg):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, 0, localeInfo.UI_OK)

def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)

def AppendMaterialToRefineDialog(self, vnum, count):
self.interface.AppendMaterialToRefineDialog(vnum, count)

def RunUseSkillEvent(self, slotIndex, coolTime):
self.interface.OnUseSkill(slotIndex, coolTime)

def ClearAffects(self):
self.affectShower.ClearAffects()

def SetAffect(self, affect):
self.affectShower.SetAffect(affect)

def ResetAffect(self, affect):
self.affectShower.ResetAffect(affect)

# UNKNOWN_UPDATE
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
self.BINARY_DragonSoulGiveQuilification()

def BINARY_NEW_RemoveAffect(self, type, pointIdx):
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulDeactivate()



# END_OF_UNKNOWN_UPDATE

def ActivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnActivateSkill(slotIndex)

def DeactivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnDeactivateSkill(slotIndex)

def RefreshEquipment(self):
if self.interface:
self.interface.RefreshInventory()

def RefreshInventory(self):
if self.interface:
self.interface.RefreshInventory()

def RefreshCharacter(self):
if self.interface:
self.interface.RefreshCharacter()

def OnGameOver(self):
self.CloseTargetBoard()
self.OpenRestartDialog()

def OpenRestartDialog(self):
self.interface.OpenRestartDialog()

def ChangeCurrentSkill(self, skillSlotNumber):
self.interface.OnChangeCurrentSkill(skillSlotNumber)

## TargetBoard
def SetPCTargetBoard(self, vid, name):
self.targetBoard.Open(vid, name)

if app.IsPressed(app.DIK_LCONTROL):

if not player.IsSameEmpire(vid):
return

if player.IsMainCharacterIndex(vid):
return
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
return

self.interface.OpenWhisperDialog(name)


def RefreshTargetBoardByVID(self, vid):
self.targetBoard.RefreshByVID(vid)

def RefreshTargetBoardByName(self, name):
self.targetBoard.RefreshByName(name)

def __RefreshTargetBoard(self):
self.targetBoard.Refresh()

def SetHPTargetBoard(self, vid, hpPercentage):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)

self.targetBoard.SetHP(hpPercentage)
self.targetBoard.Show()

def CloseTargetBoardIfDifferent(self, vid):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.Close()

def CloseTargetBoard(self):
self.targetBoard.Close()

## View Equipment
def OpenEquipmentDialog(self, vid):
self.interface.OpenEquipmentDialog(vid)

def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)

def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)

def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)

# SHOW_LOCAL_MAP_NAME
def ShowMapName(self, mapName, x, y):

if self.mapNameShower:
self.mapNameShower.ShowMapName(mapName, x, y)

if self.interface:
self.interface.SetMapName(mapName)
# END_OF_SHOW_LOCAL_MAP_NAME

def BINARY_OpenAtlasWindow(self):
self.interface.BINARY_OpenAtlasWindow()

## Chat
def OnRecvWhisper(self, mode, name, line):
if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(mode, name, line)
self.interface.RecvWhisper(name)

def OnRecvWhisperSystemMessage(self, mode, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
self.interface.RecvWhisper(name)

def OnRecvWhisperError(self, mode, name, line):
if localeInfo.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
self.interface.RecvWhisper(name)

def RecvWhisper(self, name):
self.interface.RecvWhisper(name)

def OnPickMoney(self, money):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))

def OnShopError(self, type):
try:
self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])
except KeyError:
self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))

def OnSafeBoxError(self):
self.PopupMessage(localeInfo.SAFEBOX_ERROR)

def OnFishingSuccess(self, isFish, fishName):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_SUCCESS(isFish, fishName), 2000)

# ADD_FISHING_MESSAGE
def OnFishingNotifyUnknown(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_UNKNOWN)

def OnFishingWrongPlace(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_WRONG_PLACE)
# END_OF_ADD_FISHING_MESSAGE

def OnFishingNotify(self, isFish, fishName):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_NOTIFY(isFish, fishName))

def OnFishingFailure(self):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_FAILURE, 2000)

def OnCannotPickItem(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_PICK_ITEM)

# MINING
def OnCannotMining(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_MINING)
# END_OF_MINING

def OnCannotUseSkill(self, vid, type):
if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
textTail.RegisterInfoTail(vid, localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])

if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_SKILL_ERROR_CHAT_DICT[type])

def OnCannotShotError(self, vid, type):
textTail.RegisterInfoTail(vid, localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))

## PointReset
def StartPointReset(self):
self.interface.OpenPointResetDialog()

## Shop
def StartShop(self, vid):
self.interface.OpenShopDialog(vid)

def EndShop(self):
self.interface.CloseShopDialog()

def RefreshShop(self):
self.interface.RefreshShopDialog()

def SetShopSellingPrice(self, Price):
pass

## OfflineShop
def StartOfflineShop(self, vid):
self.interface.OpenOfflineShopDialog(vid)

def EndOfflineShop(self):
self.interface.CloseOfflineShopDialog()

def RefreshOfflineShop(self):
self.interface.RefreshOfflineShopDialog()

## Exchange
def StartExchange(self):
self.interface.StartExchange()

def EndExchange(self):
self.interface.EndExchange()

def RefreshExchange(self):
self.interface.RefreshExchange()

## Party
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
partyInviteQuestionDialog = uiCommon.QuestionDialog()
partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open()
partyInviteQuestionDialog.partyLeaderVID = leaderVID
self.partyInviteQuestionDialog = partyInviteQuestionDialog

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:
return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

distance = player.GetCharacterDistance(partyLeaderVID)
if distance < 0.0 or distance > 5000:
answer = FALSE

net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

self.partyInviteQuestionDialog.Close()
self.partyInviteQuestionDialog = None

def AddPartyMember(self, pid, name):
self.interface.AddPartyMember(pid, name)

def UpdatePartyMemberInfo(self, pid):
self.interface.UpdatePartyMemberInfo(pid)

def RemovePartyMember(self, pid):
self.interface.RemovePartyMember(pid)
self.__RefreshTargetBoard()

def LinkPartyMember(self, pid, vid):
self.interface.LinkPartyMember(pid, vid)

def UnlinkPartyMember(self, pid):
self.interface.UnlinkPartyMember(pid)

def UnlinkAllPartyMember(self):
self.interface.UnlinkAllPartyMember()

def ExitParty(self):
self.interface.ExitParty()
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())

def ChangePartyParameter(self, distributionMode):
self.interface.ChangePartyParameter(distributionMode)

## Messenger
def OnMessengerAddFriendQuestion(self, name):
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
messengerAddFriendQuestion.SetText1(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open()
messengerAddFriendQuestion.name = name
self.messengerAddFriendQuestion = messengerAddFriendQuestion

def OnAcceptAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth y " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE

def OnDenyAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth n " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE

def OnCloseAddFriendQuestionDialog(self):
self.messengerAddFriendQuestion.Close()
self.messengerAddFriendQuestion = None
return TRUE

## SafeBox
def OpenSafeboxWindow(self, size):
self.interface.OpenSafeboxWindow(size)

def RefreshSafebox(self):
self.interface.RefreshSafebox()

def RefreshSafeboxMoney(self):
self.interface.RefreshSafeboxMoney()

# ITEM_MALL
def OpenMallWindow(self, size):
self.interface.OpenMallWindow(size)

def RefreshMall(self):
self.interface.RefreshMall()
# END_OF_ITEM_MALL

## Guild
def RecvGuildInviteQuestion(self, guildID, guildName):
guildInviteQuestionDialog = uiCommon.QuestionDialog()
guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialog

def AnswerGuildInvite(self, answer):

if not self.guildInviteQuestionDialog:
return

guildLeaderVID = self.guildInviteQuestionDialog.guildID
net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)

self.guildInviteQuestionDialog.Close()
self.guildInviteQuestionDialog = None


def DeleteGuild(self):
self.interface.DeleteGuild()

## Clock
def ShowClock(self, second):
self.interface.ShowClock(second)

def HideClock(self):
self.interface.HideClock()

## Emotion
def BINARY_ActEmotion(self, emotionIndex):
if self.interface.wndCharacter:
self.interface.wndCharacter.ActEmotion(emotionIndex)

###############################################################################################
###############################################################################################
## Keyboard Functions

def CheckFocus(self):
if FALSE == self.IsFocus():
if TRUE == self.interface.IsOpenChat():
self.interface.ToggleChat()

self.SetFocus()

def SaveScreen(self):
print "save screen"

# SCREENSHOT_CWDSAVE
if SCREENSHOT_CWDSAVE:
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
os.mkdir(os.getcwd()+os.sep+"screenshot")

(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
elif SCREENSHOT_DIR:
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVE

if succeeded:
pass
"""
chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
"""
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)

# def ShowConsole(self):
# if debugInfo.IsDebugMode() or TRUE == self.consoleEnable:
# player.EndKeyWalkingImmediately()
# self.console.OpenWindow()

def ShowName(self):
self.ShowNameFlag = TRUE
self.playerGauge.EnableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex+1)

# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):

if systemSetting.IsAlwaysShowName():
return TRUE

if self.ShowNameFlag:
return TRUE

return FALSE
# END_OF_ADD_ALWAYS_SHOW_NAME

def HideName(self):
self.ShowNameFlag = FALSE
self.playerGauge.DisableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex)

def ShowMouseImage(self):
self.interface.ShowMouseImage()

def HideMouseImage(self):
self.interface.HideMouseImage()

def StartAttack(self):
player.SetAttackKeyState(TRUE)

def EndAttack(self):
player.SetAttackKeyState(FALSE)

def MoveUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, TRUE)

def MoveDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, TRUE)

def MoveLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, TRUE)

def MoveRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, TRUE)

def StopUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, FALSE)

def StopDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, FALSE)

def StopLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, FALSE)

def StopRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, FALSE)

def PickUpItem(self):
player.PickCloseItem()

###############################################################################################
###############################################################################################
## Event Handler

def OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
return

if key == app.DIK_ESC:
self.RequestDropItem(FALSE)
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

try:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raise

return TRUE

def OnKeyUp(self, key):
try:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raise

return TRUE

def OnMouseLeftButtonDown(self):
if self.interface.BUILD_OnMouseLeftButtonDown():
return

if mouseModule.mouseController.isAttached():
self.CheckFocus()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
return
else:
self.CheckFocus()
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);

return TRUE

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():
return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType:

if player.ITEM_MONEY == attachedItemIndex:
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
else:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

## DragonSoul
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

mouseModule.mouseController.DeattachObject()

else:
hyperlink = ui.GetHyperlink()
if hyperlink:
if app.IsPressed(app.DIK_LALT):
link = chat.GetLinkFromHyperlink(hyperlink)
ime.PasteString(link)
else:
self.interface.MakeHyperlinkTooltip(hyperlink)
return
else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)

#player.EndMouseWalking()
return TRUE

def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos) and player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)

def __PutMoney(self, attachedType, attachedMoney, dstChrID):
if TRUE == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeElkAddPacket(attachedMoney)
else:
self.__DropMoney(attachedType, attachedMoney)

def __DropMoney(self, attachedType, attachedMoney):
# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP
if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP2
if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

if attachedMoney>=1000:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
return

itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedMoney
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
self.itemDropQuestionDialog = itemDropQuestionDialog

def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP
if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
# END_OFF_OFFLINESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP2
if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)

else:
if player.SLOT_TYPE_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()

## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)

item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()

## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def RequestDropItem(self, answer):
if not self.itemDropQuestionDialog:
return

if answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumber

if player.SLOT_TYPE_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")
else:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

# PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

def OnMouseRightButtonDown(self):

self.CheckFocus()

if TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()

else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)

return TRUE

def OnMouseRightButtonUp(self):
if TRUE == mouseModule.mouseController.isAttached():
return TRUE

player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
return TRUE

def OnMouseMiddleButtonDown(self):
player.SetMouseMiddleButtonState(player.MBS_PRESS)

def OnMouseMiddleButtonUp(self):
player.SetMouseMiddleButtonState(player.MBS_CLICK)

def OnUpdate(self):
app.UpdateGame()

if self.mapNameShower.IsShow():
self.mapNameShower.Update()

if self.isShowDebugInfo:
self.UpdateDebugInfo()

if self.enableXMasBoom:
self.__XMasBoom_Update()

if 1 == constInfo.AUTO_PICK_UP:
self.PickUpItem()

if int(int(self.interface.LastContactTimeStamp) + self.interface.WaitTime) < int(app.GetTime()) and self.interface.State == "Kapali":
self.interface.State = "Acik"

self.interface.BUILD_OnUpdate()

localtime = localtime = time.strftime("%d.%m.%y %H:%M:%S")
self.timeLine.SetText(localtime)
self.timeLine.Show()

def UpdateDebugInfo(self):
#
# 캐릭터 좌표 및 FPS 출력
(x, y, z) = player.GetMainCharacterPosition()
nUpdateTime = app.GetUpdateTime()
nUpdateFPS = app.GetUpdateFPS()
nRenderFPS = app.GetRenderFPS()
nFaceCount = app.GetFaceCount()
fFaceSpeed = app.GetFaceSpeed()
nST=background.GetRenderShadowTime()
(fAveRT, nCurRT) = app.GetRenderTime()
(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
if iPatch == 0:
iPatch = 1

#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()

#self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
#xMouse, yMouse = wndMgr.GetMousePosition()
#self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))

#self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPS, nUpdateTime, fFaceSpeed))

#if fAveRT>1.0:
#self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))

#self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
#self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))

def OnRender(self):
app.RenderGame()

if self.console.Console.collision:
background.RenderCollision()
chr.RenderCollision()

(x, y) = app.GetCursorPosition()

########################
# Picking
########################
textTail.UpdateAllTextTail()

if TRUE == wndMgr.IsPickedWindow(self.hWnd):

self.PickingCharacterIndex = chr.Pick()

if -1 != self.PickingCharacterIndex:
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
if 0 != self.targetBoard.GetTargetVID():
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())

# ADD_ALWAYS_SHOW_NAME
if not self.__IsShowName():
self.PickingItemIndex = item.Pick()
if -1 != self.PickingItemIndex:
textTail.ShowItemTextTail(self.PickingItemIndex)
# END_OF_ADD_ALWAYS_SHOW_NAME

## Show all name in the range

# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME

textTail.UpdateShowingTextTail()
textTail.ArrangeTextTail()
if -1 != self.PickingItemIndex:
textTail.SelectItemName(self.PickingItemIndex)

grp.PopState()
grp.SetInterfaceRenderState()

textTail.Render()
textTail.HideAllTextTail()

def OnPressEscapeKey(self):
if app.TARGET == app.GetCursor():
app.SetCursor(app.NORMAL)

if constInfo.wndTombola.IsShow():
constInfo.wndTombola.Close()

elif TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()

else:
self.interface.OpenSystemDialog()

return TRUE

def OnIMEReturn(self):
if app.IsPressed(app.DIK_LSHIFT):
self.interface.OpenWhisperDialogWithoutTarget()
else:
self.interface.ToggleChat()
return TRUE

def OnPressExitKey(self):
self.interface.ToggleSystemDialog()
return TRUE

## BINARY CALLBACK
######################################################################################

# WEDDING
def BINARY_LoverInfo(self, name, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnAddLover(name, lovePoint)
if self.affectShower:
self.affectShower.SetLoverInfo(name, lovePoint)

def BINARY_UpdateLovePoint(self, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)
if self.affectShower:
self.affectShower.OnUpdateLovePoint(lovePoint)
# END_OF_WEDDING

# QUEST_CONFIRM
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
confirmDialog = uiCommon.QuestionDialogWithTimeLimit()
confirmDialog.Open(msg, timeout)
confirmDialog.SetAcceptEvent(lambda answer=TRUE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
confirmDialog.SetCancelEvent(lambda answer=FALSE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
self.confirmDialog = confirmDialog
# END_OF_QUEST_CONFIRM

# GIFT command
def Gift_Show(self):
self.interface.ShowGift()

# CUBE
def BINARY_Cube_Open(self, npcVNUM):
self.currentCubeNPC = npcVNUM

self.interface.OpenCubeWindow()


if npcVNUM not in self.cubeInformation:
net.SendChatPacket("/cube r_info")
else:
cubeInfoList = self.cubeInformation[npcVNUM]

i = 0
for cubeInfo in cubeInfoList:
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])

j = 0
for materialList in cubeInfo["materialList"]:
for materialInfo in materialList:
itemVnum, itemCount = materialInfo
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)
j = j + 1

i = i + 1

self.interface.wndCube.Refresh()

def BINARY_Cube_Close(self):
self.interface.CloseCubeWindow()

# 제작에 필요한 골드, 예상되는 완성품의 VNUM과 개수 정보 update
def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
self.interface.UpdateCubeInfo(gold, itemVnum, count)

def BINARY_Cube_Succeed(self, itemVnum, count):
print "큐브 제작 성공"
self.interface.SucceedCubeWork(itemVnum, count)
pass

def BINARY_Cube_Failed(self):
print "큐브 제작 실패"
self.interface.FailedCubeWork()
pass

def BINARY_Cube_ResultList(self, npcVNUM, listText):
# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 이런식으로 "/" 문자로 구분된 리스트를 줌
#print listText

if npcVNUM == 0:
npcVNUM = self.currentCubeNPC

self.cubeInformation[npcVNUM] = []

try:
for eachInfoText in listText.split("/"):
eachInfo = eachInfoText.split(",")
itemVnum = int(eachInfo[0])
itemCount = int(eachInfo[1])

self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount})
self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)

resultCount = len(self.cubeInformation[npcVNUM])
requestCount = 7
modCount = resultCount % requestCount
splitCount = resultCount / requestCount
for i in xrange(splitCount):
#print("/cube r_info %d %d" % (i * requestCount, requestCount))
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))

if 0 < modCount:
#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))
net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))

except RuntimeError, msg:
dbg.TraceError(msg)
return 0

pass

def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
try:
#print listText

if 3 > len(listText):
dbg.TraceError("Wrong Cube Material Infomation")
return 0



eachResultList = listText.split("@")

cubeInfo = self.cubeInformation[self.currentCubeNPC]

itemIndex = 0
for eachResultText in eachResultList:
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
materialList = cubeInfo[startIndex + itemIndex]["materialList"]

gold = 0
splitResult = eachResultText.split("/")
if 1 < len(splitResult):
gold = int(splitResult[1])

#print "splitResult : ", splitResult
eachMaterialList = splitResult[0].split("&")

i = 0
for eachMaterialText in eachMaterialList:
complicatedList = eachMaterialText.split("|")

if 0 < len(complicatedList):
for complicatedText in complicatedList:
(itemVnum, itemCount) = complicatedText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

materialList.append((itemVnum, itemCount))

else:
itemVnum, itemCount = eachMaterialText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

materialList.append((itemVnum, itemCount))

i = i + 1



itemIndex = itemIndex + 1

self.interface.wndCube.Refresh()


except RuntimeError, msg:
dbg.TraceError(msg)
return 0

pass

# END_OF_CUBE

# 용혼석
def BINARY_Highlight_Item(self, inven_type, inven_pos):
self.interface.Highligt_Item(inven_type, inven_pos)

def BINARY_DragonSoulGiveQuilification(self):
self.interface.DragonSoulGiveQuilification()

def BINARY_DragonSoulRefineWindow_Open(self):
self.interface.OpenDragonSoulRefineWindow()

def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)

def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)

# END of DRAGON SOUL REFINE WINDOW

def BINARY_SetBigMessage(self, message):
self.interface.bigBoard.SetTip(message)

def BINARY_SetTipMessage(self, message):
self.interface.tipBoard.SetTip(message)

def BINARY_AppendNotifyMessage(self, type):
if not type in localeInfo.NOTIFY_MESSAGE:
return
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])

def BINARY_Guild_EnterGuildArea(self, areaID):
self.interface.BULID_EnterGuildArea(areaID)

def BINARY_Guild_ExitGuildArea(self, areaID):
self.interface.BULID_ExitGuildArea(areaID)

def BINARY_GuildWar_OnSendDeclare(self, guildID):
pass

def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName == masterName:
self.__GuildWar_OpenAskDialog(guildID, warType)

def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)

def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
self.interface.OnStartGuildWar(guildSelf, guildOpp)

def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
self.interface.OnEndGuildWar(guildSelf, guildOpp)

def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):
self.interface.BINARY_SetObserverMode(isEnable)

def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2, memberCount2, observerCount):
guildID1 = int(guildID1)
guildID2 = int(guildID2)
memberCount1 = int(memberCount1)
memberCount2 = int(memberCount2)
observerCount = int(observerCount)

self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)
self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

# REMOVED_GUILD_BUG_FIX
if "Noname" == guildName:
return
# END_OF_REMOVED_GUILD_BUG_FIX

import uiGuild
questionDialog = uiGuild.AcceptGuildWarDialog()
questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)
questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)
questionDialog.Open(guildName, warType)

self.guildWarQuestionDialog = questionDialog

def __GuildWar_CloseAskDialog(self):
self.guildWarQuestionDialog.Close()
self.guildWarQuestionDialog = None

def __GuildWar_OnAccept(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/war " + guildName)
self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/nowar " + guildName)
self.__GuildWar_CloseAskDialog()

return 1
## BINARY CALLBACK
######################################################################################

def __ServerCommand_Build(self):
serverCommandList={
"ConsoleEnable" : self.__Console_Enable,
"DayMode" : self.__DayMode_Update,
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
"CloseRestartWindow" : self.__RestartDialog_Close,
"OpenPrivateShop" : self.__PrivateShop_Open,
"OpenOfflineShop" : self.__OfflineShop_Open,
"PartyHealReady" : self.PartyHealReady,
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
"CloseSafebox" : self.CommandCloseSafebox,

# ITEM_MALL
"CloseMall" : self.CommandCloseMall,
"ShowMeMallPassword" : self.AskMallPassword,
"item_mall" : self.__ItemMall_Open,
# END_OF_ITEM_MALL

"RefineSuceeded" : self.RefineSuceededMessage,
"RefineFailed" : self.RefineFailedMessage,
"xmas_snow" : self.__XMasSnow_Enable,
"xmas_boom" : self.__XMasBoom_Enable,
"xmas_song" : self.__XMasSong_Enable,
"xmas_tree" : self.__XMasTree_Enable,
"newyear_boom" : self.__XMasBoom_Enable,
"PartyRequest" : self.__PartyRequestQuestion,
"PartyRequestDenied" : self.__PartyRequestDenied,
"horse_state" : self.__Horse_UpdateState,
"hide_horse_state" : self.__Horse_HideState,
"WarUC" : self.__GuildWar_UpdateMemberCount,
"test_server" : self.__EnableTestServerFlag,
"mall" : self.__InGameShop_Show,

# WEDDING
"lover_login" : self.__LoginLover,
"lover_logout" : self.__LogoutLover,
"lover_near" : self.__LoverNear,
"lover_far" : self.__LoverFar,
"lover_divorce" : self.__LoverDivorce,
"PlayMusic" : self.__PlayMusic,
# END_OF_WEDDING

# PRIVATE_SHOP_PRICE_LIST
"MyShopPriceList" : self.__PrivateShop_PriceList,
# END_OF_PRIVATE_SHOP_PRICE_LIST

#DASH
"getinputbegin" : self.__Input_Get_Dash_1,
"getinputend" : self.__Input_Get_Dash_2,
"getinput" : self.__Input_Get_Dash_3,
"securitate_index" : self.SecuriateQuestIndex,
"sistem_negot_verificare_nume" : self.__Sistem_negot_verificare_nume,
"securiate_cont" : self.SecuriateCont,
"activareinv" : self.ActivareInv,
#DASH
#Tombola System
"OnPrepare" : self.__PrepareTombola,
"OnRun" : self.__RunTombola,
"openTombola" : self.__OpenTombola,
"closeTombola" : self.__CloseTombola,
"tombola" : self.SetTombola,
"get_input_value" : self.GetInputValue,
"get_input_start" : self.GetInputOn,
"get_input_end" : self.GetInputOff,
#End Tombala System
}

self.serverCommander=stringCommander.Analyzer()
for serverCommandItem in serverCommandList.items():
self.serverCommander.SAFE_RegisterCallBack(
serverCommandItem[0], serverCommandItem[1]
)