Jump to content
Maintenance ×
×
×
  • Create New...

Post Guild Comment Flood Mysql


Recommended Posts

  • Moon

1. Make a guild

2. Put that code in uiGuild.py in OnUpdate function

		net.SendGuildPostCommentPacket("")

3. In your console type "top" and check "mysql" process

4. Check your table player.guild_comment to...

 

Fix:

## 1.guild.h
// 1.1.Search:
        EventMap    m_GuildInviteEventMap;
// 1.1.Add after:
    protected:
        int         m_guildPostCommentPulse;
       
## 2.guild.cpp
// 2.1.Search function:
void CGuild::AddComment(LPCHARACTER ch, const std::string& str)
{
    ...
}
// 2.1.Replace with:
void CGuild::AddComment(LPCHARACTER ch, const std::string& str)
{
    if (str.length() > GUILD_COMMENT_MAX_LEN || str.length() == 0) // Added string null verification
        return;
   
    // Compare last pulse with current pulse and notify the player
    if (m_guildPostCommentPulse > thecore_pulse()) {
        int deltaInSeconds = ((m_guildPostCommentPulse / PASSES_PER_SEC(1)) - (thecore_pulse() / PASSES_PER_SEC(1)));
        int minutes = deltaInSeconds / 60;
        int seconds = (deltaInSeconds - (minutes * 60));
 
        ch->ChatPacket(CHAT_TYPE_INFO, "You can post a new comment in: %02d minutes and %02d seconds!", minutes, seconds);
        return;
    }
 
    char text[GUILD_COMMENT_MAX_LEN * 2 + 1];
    DBManager::instance().EscapeString(text, sizeof(text), str.c_str(), str.length());
 
    DBManager::instance().FuncAfterQuery(void_bind(std::bind1st(std::mem_fun(&CGuild::RefreshCommentForce),this),ch->GetPlayerID()),
            "INSERT INTO guild_comment%s(guild_id, name, notice, content, time) VALUES(%u, '%s', %d, '%s', NOW())",
            get_table_postfix(), m_data.guild_id, ch->GetName(), (str[0] == '!') ? 1 : 0, text);
       
    // Set comment pulse to 10 minutes
    m_guildPostCommentPulse = thecore_pulse() + PASSES_PER_SEC(10*60);
}

 

  • Metin2 Dev 1
  • Love 8
Link to comment
Share on other sites

  • Moon
La 11/11/2017 la 16:05, kingshero a spus:

not effect when put  code in uiGuild.py in OnUpdate function net.SendGuildPostCommentPacket("")

and when add OnUpdate in game.py the account logout only 

 

There are more classes in uiGuild.py , make sure you put in right class (GuildWindow).

  • Love 1
Link to comment
Share on other sites

Spoiler

class GuildWindow(ui.ScriptWindow):

    JOB_NAME = {    0 : localeInfo.JOB_WARRIOR,
            1 : localeInfo.JOB_ASSASSIN,
            2 : localeInfo.JOB_SURA,
            3 : localeInfo.JOB_SHAMAN, }

    if app.ENABLE_WOLFMAN_CHARACTER:
        JOB_NAME.update({4 : localeInfo.JOB_WOLFMAN,})

    GUILD_SKILL_PASSIVE_SLOT = 0
    GUILD_SKILL_ACTIVE_SLOT = 1
    GUILD_SKILL_AFFECT_SLOT = 2

    GRADE_SLOT_NAME = 0
    GRADE_ADD_MEMBER_AUTHORITY = 1
    GRADE_REMOVE_MEMBER_AUTHORITY = 2
    GRADE_NOTICE_AUTHORITY = 3
    GRADE_SKILL_AUTHORITY = 4

    MEMBER_LINE_COUNT = 13

    class PageWindow(ui.ScriptWindow):
        def __init__(self, parent, filename):
            ui.ScriptWindow.__init__(self)
            self.SetParent(parent)
            self.filename = filename
        def GetScriptFileName(self):
            return self.filename

    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.isLoaded=0

        self.__Initialize()

    def __del__(self):
        ui.ScriptWindow.__del__(self)
        print " ==================================== DESTROIED GUILD WINDOW"

    def __Initialize(self):

        self.board = None
        self.pageName = None
        self.tabDict = None
        self.tabButtonDict = None
        self.pickDialog = None
        self.questionDialog = None
        self.offerDialog = None
        self.popupDialog = None
        self.moneyDialog = None
        self.changeGradeNameDialog = None
        self.popup = None

        self.popupMessage = None
        self.commentSlot = None

        self.pageWindow = None
        self.tooltipSkill = None

        self.memberLinePos = 0

        self.enemyGuildNameList = []

    def Open(self):
        self.Show()
        self.SetTop()

        guildID = net.GetGuildID()
        self.largeMarkBox.SetIndex(guildID)
        self.largeMarkBox.SetScale(3)

    def Close(self):
        self.__CloseAllGuildMemberPageGradeComboBox()
        self.offerDialog.Close()
        self.popupDialog.Hide()
        self.changeGradeNameDialog.Hide()
        self.tooltipSkill.Hide()
        self.Hide()

        self.pickDialog = None
        self.questionDialog = None
        self.popup = None

    def Destroy(self):
        self.ClearDictionary()

        if self.offerDialog:
            self.offerDialog.Destroy()

        if self.popupDialog:
            self.popupDialog.ClearDictionary()

        if self.changeGradeNameDialog:
            self.changeGradeNameDialog.ClearDictionary()

        if self.pageWindow:
            for window in self.pageWindow.values():
                window.ClearDictionary()

        self.__Initialize()

    def Show(self):
        if self.isLoaded==0:
            self.isLoaded=1

            self.__LoadWindow()

        self.RefreshGuildInfoPage()
        self.RefreshGuildBoardPage()
        self.RefreshGuildMemberPage()
        self.RefreshGuildSkillPage()
        self.RefreshGuildGradePage()

        ui.ScriptWindow.Show(self)

    def __LoadWindow(self):
        global DISABLE_GUILD_SKILL
        try:
            pyScrLoader = ui.PythonScriptLoader()

            if localeInfo.IsARABIC() :
                pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "guildwindow.py")
            else:
                pyScrLoader.LoadScriptFile(self, "uiscript/guildwindow.py")

            self.popupDialog = ui.ScriptWindow()
            pyScrLoader.LoadScriptFile(self.popupDialog, "UIScript/PopupDialog.py")

            self.changeGradeNameDialog = ChangeGradeNameDialog()
            pyScrLoader.LoadScriptFile(self.changeGradeNameDialog, "uiscript/changegradenamedialog.py")

            if localeInfo.IsARABIC():
                self.pageWindow = {
                    "GUILD_INFO"    : self.PageWindow(self, "uiscript/guildwindow_guildinfopage_eu.py"),
                    "BOARD"            : self.PageWindow(self, "uiscript/guildwindow_boardpage.py"),
                    "MEMBER"        : self.PageWindow(self, "uiscript/guildwindow_memberpage.py"),
                    "BASE_INFO"        : self.PageWindow(self, "uiscript/guildwindow_baseinfopage.py"),
                    "SKILL"            : self.PageWindow(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "guildwindow_guildskillpage.py"),
                    "GRADE"            : self.PageWindow(self, "uiscript/guildwindow_gradepage.py"),
                }
            elif localeInfo.IsJAPAN() :
                self.pageWindow = {
                    "GUILD_INFO"    : self.PageWindow(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "guildwindow_guildinfopage.py"),
                    "BOARD"            : self.PageWindow(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "guildwindow_boardpage.py"),
                    "MEMBER"        : self.PageWindow(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "guildwindow_memberpage.py"),
                    "BASE_INFO"        : self.PageWindow(self, "uiscript/guildwindow_baseinfopage.py"),
                    "SKILL"            : self.PageWindow(self, "uiscript/guildwindow_guildskillpage.py"),
                    "GRADE"            : self.PageWindow(self, "uiscript/guildwindow_gradepage.py"),
                }
            elif localeInfo.IsVIETNAM() :   # 다표시
                self.pageWindow = {
                    "GUILD_INFO"    : self.PageWindow(self, "uiscript/guildwindow_guildinfopage_eu.py"),
                    "BOARD"            : self.PageWindow(self, "uiscript/guildwindow_boardpage.py"),
                    "MEMBER"        : self.PageWindow(self, "uiscript/guildwindow_memberpage.py"),
                    "BASE_INFO"        : self.PageWindow(self, "uiscript/guildwindow_baseinfopage.py"),
                    "SKILL"            : self.PageWindow(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "guildwindow_guildskillpage.py"),
                    "GRADE"            : self.PageWindow(self, "uiscript/guildwindow_gradepage.py"),
                }
            elif localeInfo.IsEUROPE() and not app.GetLocalePath() == "locale/ca" :
                self.pageWindow = {
                    "GUILD_INFO"    : self.PageWindow(self, "uiscript/guildwindow_guildinfopage_eu.py"),
                    "BOARD"            : self.PageWindow(self, "uiscript/guildwindow_boardpage.py"),
                    "MEMBER"        : self.PageWindow(self, "uiscript/guildwindow_memberpage.py"),
                    "BASE_INFO"        : self.PageWindow(self, "uiscript/guildwindow_baseinfopage.py"),
                    "SKILL"            : self.PageWindow(self, "uiscript/guildwindow_guildskillpage.py"),
                    "GRADE"            : self.PageWindow(self, "uiscript/guildwindow_gradepage.py"),
                }
            else:
                self.pageWindow = {
                    "GUILD_INFO"    : self.PageWindow(self, "uiscript/guildwindow_guildinfopage.py"),
                    "BOARD"            : self.PageWindow(self, "uiscript/guildwindow_boardpage.py"),
                    "MEMBER"        : self.PageWindow(self, "uiscript/guildwindow_memberpage.py"),
                    "BASE_INFO"        : self.PageWindow(self, "uiscript/guildwindow_baseinfopage.py"),
                    "SKILL"            : self.PageWindow(self, "uiscript/guildwindow_guildskillpage.py"),
                    "GRADE"            : self.PageWindow(self, "uiscript/guildwindow_gradepage.py"),
                }

            for window in self.pageWindow.values():
                pyScrLoader.LoadScriptFile(window, window.GetScriptFileName())

        except:
            import exception
            exception.Abort("GuildWindow.__LoadWindow.LoadScript")

        try:
            getObject = self.GetChild

            self.board = getObject("Board")
            self.pageName = {
                "GUILD_INFO"    : localeInfo.GUILD_TILE_INFO,
                "BOARD"            : localeInfo.GUILD_TILE_BOARD,
                "MEMBER"        : localeInfo.GUILD_TILE_MEMBER,
                "BASE_INFO"        : localeInfo.GUILD_TILE_BASEINFO,
                "SKILL"            : localeInfo.GUILD_TILE_SKILL,
                "GRADE"            : localeInfo.GUILD_TILE_GRADE,
            }

            self.tabDict = {
                "GUILD_INFO"    : getObject("Tab_01"),
                "BOARD"            : getObject("Tab_02"),
                "MEMBER"        : getObject("Tab_03"),
                "BASE_INFO"        : getObject("Tab_04"),
                "SKILL"            : getObject("Tab_05"),
                "GRADE"            : getObject("Tab_06"),
            }
            self.tabButtonDict = {
                "GUILD_INFO"    : getObject("Tab_Button_01"),
                "BOARD"            : getObject("Tab_Button_02"),
                "MEMBER"        : getObject("Tab_Button_03"),
                "BASE_INFO"        : getObject("Tab_Button_04"),
                "SKILL"            : getObject("Tab_Button_05"),
                "GRADE"            : getObject("Tab_Button_06"),
            }

            ## QuestionDialog
            self.popupMessage = self.popupDialog.GetChild("message")
            self.popupDialog.GetChild("accept").SetEvent(ui.__mem_func__(self.popupDialog.Hide))

            ## ChangeGradeName
            self.changeGradeNameDialog.GetChild("AcceptButton").SetEvent(ui.__mem_func__(self.OnChangeGradeName))
            self.changeGradeNameDialog.GetChild("CancelButton").SetEvent(ui.__mem_func__(self.changeGradeNameDialog.Hide))
            self.changeGradeNameDialog.GetChild("Board").SetCloseEvent(ui.__mem_func__(self.changeGradeNameDialog.Hide))
            self.changeGradeNameDialog.gradeNameSlot = self.changeGradeNameDialog.GetChild("GradeNameValue")
            self.changeGradeNameDialog.gradeNameSlot.OnIMEReturn = ui.__mem_func__(self.OnChangeGradeName)
            self.changeGradeNameDialog.gradeNameSlot.OnPressEscapeKey = ui.__mem_func__(self.changeGradeNameDialog.Close)

            ## Comment
            self.commentSlot = self.pageWindow["BOARD"].GetChild("CommentValue")
            self.commentSlot.OnIMEReturn = ui.__mem_func__(self.OnPostComment)
            #self.commentSlot.OnKeyDown = ui.__mem_func__(self.OnKeyDownInBoardPage)
            self.commentSlot.OnKeyDown = lambda key, argSelf=self: argSelf.OnKeyDownInBoardPage(key)

            ## RefreshButton
            self.pageWindow["BOARD"].GetChild("RefreshButton").SetEvent(ui.__mem_func__(self.OnRefreshComments))

            ## ScrollBar
            scrollBar = self.pageWindow["MEMBER"].GetChild("ScrollBar")
            scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScrollMemberLine))
            self.pageWindow["MEMBER"].scrollBar = scrollBar

        except:
            import exception
            exception.Abort("GuildWindow.__LoadWindow.BindObject")

        self.__MakeInfoPage()
        self.__MakeBoardPage()
        self.__MakeMemberPage()
        self.__MakeBaseInfoPage()
        self.__MakeSkillPage()
        self.__MakeGradePage()

        for page in self.pageWindow.values():
            page.UpdateRect()

        for key, btn in self.tabButtonDict.items():
            btn.SetEvent(self.SelectPage, key)

        self.tabButtonDict["BASE_INFO"].Disable()

        if DISABLE_GUILD_SKILL:
            self.tabButtonDict["SKILL"].Disable()

        self.board.SetCloseEvent(ui.__mem_func__(self.Close))
        self.board.SetTitleColor(0xffffffff)
        self.SelectPage("GUILD_INFO")

        #self.offerDialog = uiPickMoney.PickMoneyDialog()
        self.offerDialog = uiPickMoney.PickMoneyWithoutWon()
        self.offerDialog.LoadDialog()
        self.offerDialog.SetMax(9)
        self.offerDialog.SetTitleName(localeInfo.GUILD_OFFER_EXP)
        self.offerDialog.SetAcceptEvent(ui.__mem_func__(self.OnOffer))

    def __MakeInfoPage(self):
        page = self.pageWindow["GUILD_INFO"]

        try:
            page.nameSlot = page.GetChild("GuildNameValue")
            page.masterNameSlot = page.GetChild("GuildMasterNameValue")
            page.guildLevelSlot = page.GetChild("GuildLevelValue")
            page.curExpSlot = page.GetChild("CurrentExperienceValue")
            page.lastExpSlot = page.GetChild("LastExperienceValue")
            page.memberCountSlot = page.GetChild("GuildMemberCountValue")
            page.levelAverageSlot = page.GetChild("GuildMemberLevelAverageValue")
            page.uploadMarkButton = page.GetChild("UploadGuildMarkButton")
            page.uploadSymbolButton = page.GetChild("UploadGuildSymbolButton")
            page.declareWarButton = page.GetChild("DeclareWarButton")

            try:
                page.guildMoneySlot = page.GetChild("GuildMoneyValue")
            except KeyError:
                page.guildMoneySlot = None

            try:
                page.GetChild("DepositButton").SetEvent(ui.__mem_func__(self.__OnClickDepositButton))
                page.GetChild("WithdrawButton").SetEvent(ui.__mem_func__(self.__OnClickWithdrawButton))
            except KeyError:
                pass

            page.uploadMarkButton.SetEvent(ui.__mem_func__(self.__OnClickSelectGuildMarkButton))
            page.uploadSymbolButton.SetEvent(ui.__mem_func__(self.__OnClickSelectGuildSymbolButton))
            page.declareWarButton.SetEvent(ui.__mem_func__(self.__OnClickDeclareWarButton))
            page.GetChild("OfferButton").SetEvent(ui.__mem_func__(self.__OnClickOfferButton))
            page.GetChild("EnemyGuildCancel1").Hide()
            page.GetChild("EnemyGuildCancel2").Hide()
            page.GetChild("EnemyGuildCancel3").Hide()
            page.GetChild("EnemyGuildCancel4").Hide()
            page.GetChild("EnemyGuildCancel5").Hide()
            page.GetChild("EnemyGuildCancel6").Hide()

            self.enemyGuildNameList.append(page.GetChild("EnemyGuildName1"))
            self.enemyGuildNameList.append(page.GetChild("EnemyGuildName2"))
            self.enemyGuildNameList.append(page.GetChild("EnemyGuildName3"))
            self.enemyGuildNameList.append(page.GetChild("EnemyGuildName4"))
            self.enemyGuildNameList.append(page.GetChild("EnemyGuildName5"))
            self.enemyGuildNameList.append(page.GetChild("EnemyGuildName6"))

            self.largeMarkBox = page.GetChild("LargeGuildMark")
        except:
            import exception
            exception.Abort("GuildWindow.__MakeInfoPage")

        self.largeMarkBox.AddFlag("not_pick")

        self.markSelectDialog=uiUploadMark.MarkSelectDialog()
        self.markSelectDialog.SAFE_SetSelectEvent(self.__OnSelectMark)

        self.symbolSelectDialog=uiUploadMark.SymbolSelectDialog()
        self.symbolSelectDialog.SAFE_SetSelectEvent(self.__OnSelectSymbol)


    def __MakeBoardPage(self):

        i = 0
        lineStep = 20
        page = self.pageWindow["BOARD"]

        page.boardDict = {}

        for i in xrange(12):

            yPos = 25 + i * lineStep

            ## NoticeMark
            if localeInfo.IsJAPAN():
                noticeMarkImage = ui.MakeImageBox(page, "d:/ymir work/ui/game/guild/notice_mark.sub", 15, yPos+3)
            else:
                noticeMarkImage = ui.MakeImageBox(page, "d:/ymir work/ui/game/guild/notice_mark.sub", 5, yPos+3)
            noticeMarkImage.Hide()
            page.Children.append(noticeMarkImage)

            ## Name
            ## 13.12.02 아랍수정
            if localeInfo.IsJAPAN():
                nameSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_100x18.sub", 9, yPos)
            elif localeInfo.IsARABIC():
                nameSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_03.sub", 255, yPos)
            else:
                nameSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_03.sub", 15, yPos)
            nameSlot = ui.MakeTextLine(nameSlotImage)
            page.Children.append(nameSlotImage)
            page.Children.append(nameSlot)

            ## Delete Button
            if localeInfo.IsARABIC():
                deleteButton = ui.MakeButton(page, 3, yPos + 3, localeInfo.GUILD_DELETE, "d:/ymir work/ui/public/", "close_button_01.sub", "close_button_02.sub", "close_button_03.sub")
            else:
                deleteButton = ui.MakeButton(page, 340, yPos + 3, localeInfo.GUILD_DELETE, "d:/ymir work/ui/public/", "close_button_01.sub", "close_button_02.sub", "close_button_03.sub")
            deleteButton.SetEvent(ui.__mem_func__(self.OnDeleteComment), i)
            page.Children.append(deleteButton)

            ## Comment
            ## 13.12.02 아랍수정
            commentSlot = CommentSlot()
            commentSlot.SetParent(page)
            if localeInfo.IsARABIC():
                commentSlot.SetPosition(25, yPos)
            else:
                commentSlot.SetPosition(114, yPos)
            commentSlot.Show()
            page.Children.append(commentSlot)

            boardSlotList = []
            boardSlotList.append(noticeMarkImage)
            boardSlotList.append(nameSlot)
            boardSlotList.append(commentSlot)
            page.boardDict = boardSlotList

        ## PostComment - Have to make this here for that fit tooltip's position.
        ## 13.12.02 아랍수정
        if localeInfo.IsARABIC():
            postCommentButton = ui.MakeButton(page, 3, 273, localeInfo.GUILD_COMMENT, "d:/ymir work/ui/game/taskbar/", "Send_Chat_Button_01.sub", "Send_Chat_Button_02.sub", "Send_Chat_Button_03.sub")
        else:
            postCommentButton = ui.MakeButton(page, 337, 273, localeInfo.GUILD_COMMENT, "d:/ymir work/ui/game/taskbar/", "Send_Chat_Button_01.sub", "Send_Chat_Button_02.sub", "Send_Chat_Button_03.sub")
        postCommentButton.SetEvent(ui.__mem_func__(self.OnPostComment))
        page.Children.append(postCommentButton)

    def __MakeMemberPage(self):

        page = self.pageWindow["MEMBER"]

        lineStep = 20
        page.memberDict = {}

        for i in xrange(self.MEMBER_LINE_COUNT):

            inverseLineIndex = self.MEMBER_LINE_COUNT - i - 1
            yPos = 28 + inverseLineIndex*lineStep
            ## 13.12.02 아랍 수정
            ## Name
            if localeInfo.IsJAPAN():
                nameSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_100x18.sub", 15, yPos)
            elif localeInfo.IsARABIC():
                nameSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_100x18.sub", 255, yPos)
            else:
                nameSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_03.sub", 10, yPos)
            nameSlot = ui.MakeTextLine(nameSlotImage)
            page.Children.append(nameSlotImage)
            page.Children.append(nameSlot)

            ## Grade
            gradeSlot = ui.ComboBox()
            gradeSlot.SetParent(page)
            if localeInfo.IsJAPAN():
                gradeSlot.SetPosition(117, yPos-1)
            elif localeInfo.IsARABIC():
                gradeSlot.SetPosition(192, yPos-1)
            else:
                gradeSlot.SetPosition(101, yPos-1)
            gradeSlot.SetSize(61, 18)
            gradeSlot.SetEvent(lambda gradeNumber, lineIndex=inverseLineIndex, argSelf=proxy(self): argSelf.OnChangeMemberGrade(lineIndex, gradeNumber))
            gradeSlot.Show()
            page.Children.append(gradeSlot)

            ## Job
            if localeInfo.IsJAPAN():
                jobSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 181, yPos)
            elif localeInfo.IsARABIC():
                jobSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 145, yPos)
            else:
                jobSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 170, yPos)
            jobSlot = ui.MakeTextLine(jobSlotImage)
            page.Children.append(jobSlotImage)
            page.Children.append(jobSlot)

            ## Level
            if localeInfo.IsJAPAN():
                levelSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 221, yPos)
            elif localeInfo.IsARABIC():
                levelSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 106, yPos)
            else:
                levelSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 210, yPos)
            levelSlot = ui.MakeTextLine(levelSlotImage)
            page.Children.append(levelSlotImage)
            page.Children.append(levelSlot)

            ## Offer
            if localeInfo.IsJAPAN():
                offerSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 261, yPos)
            elif localeInfo.IsARABIC():
                offerSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 66, yPos)
            else:
                offerSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 250, yPos)
            offerSlot = ui.MakeTextLine(offerSlotImage)
            page.Children.append(offerSlotImage)
            page.Children.append(offerSlot)

            ## General Enable
            event = lambda argSelf=proxy(self), argIndex=inverseLineIndex: apply(argSelf.OnEnableGeneral, (argIndex,))
            if localeInfo.IsJAPAN():
                generalEnableCheckBox = CheckBox(page, 307, yPos, event, "d:/ymir work/ui/public/Parameter_Slot_00.sub")
            elif localeInfo.IsARABIC():
                generalEnableCheckBox = CheckBox(page, 22, yPos, event, "d:/ymir work/ui/public/Parameter_Slot_00.sub")
            else:
                generalEnableCheckBox = CheckBox(page, 297, yPos, event, "d:/ymir work/ui/public/Parameter_Slot_00.sub")
            page.Children.append(generalEnableCheckBox)

            memberSlotList = []
            memberSlotList.append(nameSlot)
            memberSlotList.append(gradeSlot)
            memberSlotList.append(jobSlot)
            memberSlotList.append(levelSlot)
            memberSlotList.append(offerSlot)
            memberSlotList.append(generalEnableCheckBox)
            page.memberDict[inverseLineIndex] = memberSlotList

    def __MakeBaseInfoPage(self):

        page = self.pageWindow["BASE_INFO"]

        page.buildingDataDict = {}

        lineStep = 20
        GUILD_BUILDING_MAX_NUM = 7

        yPos = 95 + 35

        for i in xrange(GUILD_BUILDING_MAX_NUM):

            nameSlotImage = ui.MakeSlotBar(page, 15, yPos, 78, 17)
            nameSlot = ui.MakeTextLine(nameSlotImage)
            page.Children.append(nameSlotImage)
            page.Children.append(nameSlot)
            nameSlot.SetText(localeInfo.GUILD_BUILDING_NAME)

            gradeSlotImage = ui.MakeSlotBar(page, 99, yPos, 26, 17)
            gradeSlot = ui.MakeTextLine(gradeSlotImage)
            page.Children.append(gradeSlotImage)
            page.Children.append(gradeSlot)
            gradeSlot.SetText(localeInfo.GUILD_BUILDING_GRADE)

            RESOURCE_MAX_NUM = 6
            for j in xrange(RESOURCE_MAX_NUM):
                resourceSlotImage = ui.MakeSlotBar(page, 131 + 29*j, yPos, 26, 17)
                resourceSlot = ui.MakeTextLine(resourceSlotImage)
                page.Children.append(resourceSlotImage)
                page.Children.append(resourceSlot)
                resourceSlot.SetText(localeInfo.GUILD_GEM)

            event = lambda *arg: None
            powerSlot = CheckBox(page, 308, yPos, event, "d:/ymir work/ui/public/Parameter_Slot_00.sub")
            page.Children.append(powerSlot)

            yPos += lineStep

    def __MakeSkillPage(self):

        page = self.pageWindow["SKILL"]

        page.skillPoint = page.GetChild("Skill_Plus_Value")
        page.passiveSlot = page.GetChild("Passive_Skill_Slot_Table")
        page.activeSlot = page.GetChild("Active_Skill_Slot_Table")
        page.affectSlot = page.GetChild("Affect_Slot_Table")
        page.gpGauge = page.GetChild("Dragon_God_Power_Gauge")
        page.gpValue = page.GetChild("Dragon_God_Power_Value")
        page.btnHealGSP = page.GetChild("Heal_GSP_Button")

        page.activeSlot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
        page.activeSlot.SetOverInItemEvent(lambda slotNumber, type=self.GUILD_SKILL_ACTIVE_SLOT: self.OverInItem(slotNumber, type))
        page.activeSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
        page.activeSlot.SetSelectItemSlotEvent(lambda slotNumber, type=self.GUILD_SKILL_ACTIVE_SLOT: self.OnPickUpGuildSkill(slotNumber, type))
        page.activeSlot.SetUnselectItemSlotEvent(lambda slotNumber, type=self.GUILD_SKILL_ACTIVE_SLOT: self.OnUseGuildSkill(slotNumber, type))
        page.activeSlot.SetPressedSlotButtonEvent(lambda slotNumber, type=self.GUILD_SKILL_ACTIVE_SLOT: self.OnUpGuildSkill(slotNumber, type))
        page.activeSlot.AppendSlotButton("d:/ymir work/ui/game/windows/btn_plus_up.sub",\
                                        "d:/ymir work/ui/game/windows/btn_plus_over.sub",\
                                        "d:/ymir work/ui/game/windows/btn_plus_down.sub")
        page.passiveSlot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
        page.passiveSlot.SetOverInItemEvent(lambda slotNumber, type=self.GUILD_SKILL_PASSIVE_SLOT: self.OverInItem(slotNumber, type))
        page.passiveSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
        page.passiveSlot.SetPressedSlotButtonEvent(lambda slotNumber, type=self.GUILD_SKILL_PASSIVE_SLOT: self.OnUpGuildSkill(slotNumber, type))
        page.passiveSlot.AppendSlotButton("d:/ymir work/ui/game/windows/btn_plus_up.sub",\
                                        "d:/ymir work/ui/game/windows/btn_plus_over.sub",\
                                        "d:/ymir work/ui/game/windows/btn_plus_down.sub")
        page.affectSlot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
        page.affectSlot.SetOverInItemEvent(lambda slotNumber, type=self.GUILD_SKILL_AFFECT_SLOT: self.OverInItem(slotNumber, type))
        page.affectSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
        page.btnHealGSP.SetEvent(ui.__mem_func__(self.__OnOpenHealGSPBoard))

        ## Passive
        """
        for i in xrange(len(playerSettingModule.PASSIVE_GUILD_SKILL_INDEX_LIST)):

            slotIndex = page.passiveSlot.GetStartIndex()+i
            skillIndex = playerSettingModule.PASSIVE_GUILD_SKILL_INDEX_LIST

            page.passiveSlot.SetSkillSlot(slotIndex, skillIndex, 0)
            page.passiveSlot.RefreshSlot()
            guild.SetSkillIndex(slotIndex, i)
        """

        ## Active
        for i in xrange(len(playerSettingModule.ACTIVE_GUILD_SKILL_INDEX_LIST)):

            slotIndex = page.activeSlot.GetStartIndex()+i
            skillIndex = playerSettingModule.ACTIVE_GUILD_SKILL_INDEX_LIST

            page.activeSlot.SetSkillSlot(slotIndex, skillIndex, 0)
            page.activeSlot.SetCoverButton(slotIndex)
            page.activeSlot.RefreshSlot()
            guild.SetSkillIndex(slotIndex, len(playerSettingModule.PASSIVE_GUILD_SKILL_INDEX_LIST)+i)

    def __MakeGradePage(self):

        lineStep = 18
        page = self.pageWindow["GRADE"]

        page.gradeDict = {}

        for i in xrange(15):

            yPos = 22 + i*lineStep
            index = i+1
            ## 13.12.02 아랍 수정
            ## GradeNumber
            if localeInfo.IsARABIC():
                gradeNumberSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 310, yPos)
            else:
                gradeNumberSlotImage = ui.MakeImageBox(page, "d:/ymir work/ui/public/Parameter_Slot_00.sub", 14, yPos)
            gradeNumberSlot = ui.MakeTextLine(gradeNumberSlotImage)
            gradeNumberSlot.SetText(str(i+1))
            page.Children.append(gradeNumberSlotImage)
            page.Children.append(gradeNumberSlot)

            ## GradeName
            if localeInfo.IsARABIC():
                gradeNameSlot = EditableTextSlot(page, 242, yPos)
            else:
                gradeNameSlot = EditableTextSlot(page, 58, yPos)
            gradeNameSlot.SetEvent(ui.__mem_func__(self.OnOpenChangeGradeName), index)
            page.Children.append(gradeNameSlot)

            ## Invite Authority
            event = lambda argSelf=proxy(self), argIndex=index, argAuthority=1<<0: apply(argSelf.OnCheckAuthority, (argIndex,argAuthority))
            if localeInfo.IsARABIC():
                inviteAuthorityCheckBox = CheckBox(page, 185, yPos, event)
            else:
                inviteAuthorityCheckBox = CheckBox(page, 124, yPos, event)
            page.Children.append(inviteAuthorityCheckBox)

            ## DriveOut Authority
            event = lambda argSelf=proxy(self), argIndex=index, argAuthority=1<<1: apply(argSelf.OnCheckAuthority, (argIndex,argAuthority))
            if localeInfo.IsARABIC():
                driveoutAuthorityCheckBox = CheckBox(page, 128, yPos, event)
            else:
                driveoutAuthorityCheckBox = CheckBox(page, 181, yPos, event)
            page.Children.append(driveoutAuthorityCheckBox)

            ## Notice Authority
            event = lambda argSelf=proxy(self), argIndex=index, argAuthority=1<<2: apply(argSelf.OnCheckAuthority, (argIndex,argAuthority))
            if localeInfo.IsARABIC():
                noticeAuthorityCheckBox = CheckBox(page, 71, yPos, event)
            else:
                noticeAuthorityCheckBox = CheckBox(page, 238, yPos, event)
            page.Children.append(noticeAuthorityCheckBox)

            ## Skill Authority
            event = lambda argSelf=proxy(self), argIndex=index, argAuthority=1<<3: apply(argSelf.OnCheckAuthority, (argIndex,argAuthority))
            if localeInfo.IsARABIC():
                skillAuthorityCheckBox = CheckBox(page, 14, yPos, event)
            else:
                skillAuthorityCheckBox = CheckBox(page, 295, yPos, event)
            page.Children.append(skillAuthorityCheckBox)

            gradeSlotList = []
            gradeSlotList.append(gradeNameSlot)
            gradeSlotList.append(inviteAuthorityCheckBox)
            gradeSlotList.append(driveoutAuthorityCheckBox)
            gradeSlotList.append(noticeAuthorityCheckBox)
            gradeSlotList.append(skillAuthorityCheckBox)
            page.gradeDict[index] = gradeSlotList

        masterSlotList = page.gradeDict[1]
        for slot in masterSlotList:
            slot.Disable()

    def CanOpen(self):
        return guild.IsGuildEnable()

    def Open(self):
        self.Show()
        self.SetTop()

        guildID = net.GetGuildID()
        self.largeMarkBox.SetIndex(guildID)
        self.largeMarkBox.SetScale(3)
        ## 13.12.02 아랍수정
        if localeInfo.IsARABIC():
            self.largeMarkBox.SetPosition(self.largeMarkBox.GetWidth()+32,1)

    def Close(self):
        self.__CloseAllGuildMemberPageGradeComboBox()
        self.offerDialog.Close()
        self.popupDialog.Hide()
        self.changeGradeNameDialog.Hide()
        self.Hide()

        if self.tooltipSkill:
            self.tooltipSkill.Hide()

        self.pickDialog = None
        self.questionDialog = None
        self.moneyDialog = None

    def Destroy(self):
        self.ClearDictionary()
        self.board = None
        self.pageName = None
        self.tabDict = None
        self.tabButtonDict = None
        self.pickDialog = None
        self.questionDialog = None
        self.markSelectDialog = None
        self.symbolSelectDialog = None

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

        if self.popupDialog:
            self.popupDialog.ClearDictionary()
            self.popupDialog = None

        if self.changeGradeNameDialog:
            self.changeGradeNameDialog.ClearDictionary()
            self.changeGradeNameDialog = None

        self.popupMessage = None
        self.commentSlot = None

        if self.pageWindow:
            for window in self.pageWindow.values():
                window.ClearDictionary()

        self.pageWindow = None
        self.tooltipSkill = None
        self.moneyDialog = None

        self.enemyGuildNameList = []

    def DeleteGuild(self):
        self.RefreshGuildInfoPage()
        self.RefreshGuildBoardPage()
        self.RefreshGuildMemberPage()
        self.RefreshGuildSkillPage()
        self.RefreshGuildGradePage()
        self.Hide()

    def SetSkillToolTip(self, tooltipSkill):
        self.tooltipSkill = tooltipSkill

    def SelectPage(self, arg):

        if "BOARD" == arg:
            self.OnRefreshComments()

        for key, btn in self.tabButtonDict.items():
            if arg != key:
                btn.SetUp()
        for key, img in self.tabDict.items():
            if arg == key:
                img.Show()
            else:
                img.Hide()
        for key, page in self.pageWindow.items():
            if arg == key:
                page.Show()
            else:
                page.Hide()
        self.board.SetTitleName(self.pageName[arg])
        self.__CloseAllGuildMemberPageGradeComboBox()

    def __CloseAllGuildMemberPageGradeComboBox(self):

        page = self.pageWindow["MEMBER"]
        for key, slotList in page.memberDict.items():
            slotList[1].CloseListBox()

    def RefreshGuildInfoPage(self):

        if self.isLoaded==0:
            return

        global DISABLE_DECLARE_WAR
        page = self.pageWindow["GUILD_INFO"]
        page.nameSlot.SetText(guild.GetGuildName())
        page.masterNameSlot.SetText(guild.GetGuildMasterName())
        page.guildLevelSlot.SetText(str(guild.GetGuildLevel()))
        if page.guildMoneySlot:
            page.guildMoneySlot.SetText(str(guild.GetGuildMoney()))

        curExp, lastExp = guild.GetGuildExperience()
        curExp *= 100
        lastExp *= 100
        page.curExpSlot.SetText(str(curExp))
        page.lastExpSlot.SetText(str(lastExp))

        curMemberCount, maxMemberCount = guild.GetGuildMemberCount()
        if maxMemberCount== 0xffff:
            page.memberCountSlot.SetText("%d / %s " % (curMemberCount, localeInfo.GUILD_MEMBER_COUNT_INFINITY))
        else:
            page.memberCountSlot.SetText("%d / %d" % (curMemberCount, maxMemberCount))

        page.levelAverageSlot.SetText(str(guild.GetGuildMemberLevelAverage()))

        ## 길드장만 길드 마크와 길드전 신청 버튼을 볼 수 있음
        mainCharacterName = player.GetMainCharacterName()
        masterName = guild.GetGuildMasterName()

        if mainCharacterName == masterName:
            page.uploadMarkButton.Show()

            if DISABLE_DECLARE_WAR:
                page.declareWarButton.Hide()
            else:
                page.declareWarButton.Show()

            if guild.HasGuildLand():
                page.uploadSymbolButton.Show()
            else:
                page.uploadSymbolButton.Hide()
        else:
            page.uploadMarkButton.Hide()
            page.declareWarButton.Hide()
            page.uploadSymbolButton.Hide()

        ## Refresh 시에 길드전 정보 업데이트
        for i in xrange(guild.ENEMY_GUILD_SLOT_MAX_COUNT):
            name = guild.GetEnemyGuildName(i)
            nameTextLine = self.enemyGuildNameList
            if name:
                nameTextLine.SetText(name)
            else:
                nameTextLine.SetText(localeInfo.GUILD_INFO_ENEMY_GUILD_EMPTY)

    def __GetGuildBoardCommentData(self, index):
        commentID, chrName, comment = guild.GetGuildBoardCommentData(index)
        if 0==commentID:
            if ""==chrName:
                chrName=localeInfo.UI_NONAME
            if ""==comment:
                comment=localeInfo.UI_NOCONTENTS

        return commentID, chrName, comment

    def RefreshGuildBoardPage(self):

        if self.isLoaded==0:
            return

        page = self.pageWindow["BOARD"]

        self.BOARD_LINE_MAX_NUM = 12
        lineIndex = 0

        commentCount = guild.GetGuildBoardCommentCount()
        for i in xrange(commentCount):

            commentID, chrName, comment = self.__GetGuildBoardCommentData(i)

            if not comment:
                continue

            slotList = page.boardDict[lineIndex]

            if "!" == comment[0]:
                slotList[0].Show()
                slotList[1].SetText(chrName)
                slotList[2].SetText(comment[1:])

            else:
                slotList[0].Hide()
                slotList[1].SetText(chrName)
                slotList[2].SetText(comment)

            lineIndex += 1

        for i in xrange(self.BOARD_LINE_MAX_NUM - lineIndex):
            slotList = page.boardDict[lineIndex+i]
            slotList[0].Hide()
            slotList[1].SetText("")
            slotList[2].SetText("")

    def RefreshGuildMemberPage(self):

        if self.isLoaded==0:
            return

        page = self.pageWindow["MEMBER"]

        ## ScrollBar
        count = guild.GetMemberCount()
        if count > self.MEMBER_LINE_COUNT:
            page.scrollBar.SetMiddleBarSize(float(self.MEMBER_LINE_COUNT) / float(count))
            page.scrollBar.Show()
        else:
            page.scrollBar.Hide()
        self.RefreshGuildMemberPageGradeComboBox()
        self.RefreshGuildMemberPageMemberList()

    def RefreshGuildMemberPageMemberList(self):

        if self.isLoaded==0:
            return

        page = self.pageWindow["MEMBER"]

        for line, slotList in page.memberDict.items():

            gradeComboBox = slotList[1]
            gradeComboBox.Disable()

            if not guild.IsMember(line):
                slotList[0].SetText("")
                slotList[2].SetText("")
                slotList[3].SetText("")
                slotList[4].SetText("")
                slotList[5].SetCheck(False)
                continue

            pid, name, grade, race, level, offer, general = self.GetMemberData(line)
            if pid < 0:
                continue

            job = chr.RaceToJob(race)

            guildExperienceSummary = guild.GetGuildExperienceSummary()

            offerPercentage = 0
            if guildExperienceSummary > 0:
                offerPercentage = int(float(offer) / float(guildExperienceSummary) * 100.0)

            slotList[0].SetText(name)
            slotList[2].SetText(self.JOB_NAME.get(job, "?"))
            slotList[3].SetText(str(level))
            slotList[4].SetText(str(offerPercentage) + "%")
            slotList[5].SetCheck(general)
            gradeComboBox.SetCurrentItem(guild.GetGradeName(grade))
            if 1 != grade:
                gradeComboBox.Enable()

    def RefreshGuildMemberPageGradeComboBox(self):

        if self.isLoaded==0:
            return

        page = self.pageWindow["MEMBER"]

        self.CAN_CHANGE_GRADE_COUNT = 15 - 1
        for key, slotList in page.memberDict.items():

            gradeComboBox = slotList[1]
            gradeComboBox.Disable()

            if not guild.IsMember(key):
                continue

            pid, name, grade, job, level, offer, general = self.GetMemberData(key)
            if pid < 0:
                continue

            gradeComboBox.ClearItem()
            for i in xrange(self.CAN_CHANGE_GRADE_COUNT):
                gradeComboBox.InsertItem(i+2, guild.GetGradeName(i+2))
            gradeComboBox.SetCurrentItem(guild.GetGradeName(grade))
            if 1 != grade:
                gradeComboBox.Enable()

    def RefreshGuildSkillPage(self):

        if self.isLoaded==0:
            return

        page = self.pageWindow["SKILL"]

        curPoint, maxPoint = guild.GetDragonPowerPoint()
        maxPoint = max(maxPoint, 1)
        page.gpValue.SetText(str(curPoint) + " / " + str(maxPoint))

        percentage = (float(curPoint) / float(maxPoint) * 100) * (float(173) / float(95))
        page.gpGauge.SetPercentage(int(percentage), 100)

        skillPoint = guild.GetGuildSkillPoint()
        page.skillPoint.SetText(str(skillPoint))

        page.passiveSlot.HideAllSlotButton()
        page.activeSlot.HideAllSlotButton()

        ## Passive
        """
        for i in xrange(len(playerSettingModule.PASSIVE_GUILD_SKILL_INDEX_LIST)):

            slotIndex = page.passiveSlot.GetStartIndex()+i
            skillIndex = playerSettingModule.PASSIVE_GUILD_SKILL_INDEX_LIST
            skillLevel = guild.GetSkillLevel(slotIndex)
            skillMaxLevel = skill.GetSkillMaxLevel(skillIndex)

            page.passiveSlot.SetSlotCount(slotIndex, skillLevel)
            if skillPoint > 0:
                if skillLevel < skillMaxLevel:
                    page.passiveSlot.ShowSlotButton(slotIndex)
        """

        ## Active
        for i in xrange(len(playerSettingModule.ACTIVE_GUILD_SKILL_INDEX_LIST)):

            slotIndex = page.activeSlot.GetStartIndex()+i
            skillIndex = playerSettingModule.ACTIVE_GUILD_SKILL_INDEX_LIST
            skillLevel = guild.GetSkillLevel(slotIndex)
            skillMaxLevel = skill.GetSkillMaxLevel(skillIndex)

            page.activeSlot.SetSlotCount(slotIndex, skillLevel)

            if skillLevel <= 0:
                page.activeSlot.DisableCoverButton(slotIndex)
            else:
                page.activeSlot.EnableCoverButton(slotIndex)

            if skillPoint > 0:
                if skillLevel < skillMaxLevel:
                    page.activeSlot.ShowSlotButton(slotIndex)

    def RefreshGuildGradePage(self):

        if self.isLoaded==0:
            return

        page = self.pageWindow["GRADE"]

        for key, slotList in page.gradeDict.items():
            name, authority = guild.GetGradeData(int(key))

            slotList[self.GRADE_SLOT_NAME].SetText(name)
            slotList[self.GRADE_ADD_MEMBER_AUTHORITY].SetCheck(authority & guild.AUTH_ADD_MEMBER)
            slotList[self.GRADE_REMOVE_MEMBER_AUTHORITY].SetCheck(authority & guild.AUTH_REMOVE_MEMBER)
            slotList[self.GRADE_NOTICE_AUTHORITY].SetCheck(authority & guild.AUTH_NOTICE)
            slotList[self.GRADE_SKILL_AUTHORITY].SetCheck(authority & guild.AUTH_SKILL)

    ## GuildInfo

    def __PopupMessage(self, msg):
        self.popupMessage.SetText(msg)
        self.popupDialog.SetTop()
        self.popupDialog.Show()

    def __OnClickSelectGuildMarkButton(self):
        if guild.GetGuildLevel() < int(localeInfo.GUILD_MARK_MIN_LEVEL):
            self.__PopupMessage(localeInfo.GUILD_MARK_NOT_ENOUGH_LEVEL)
        elif not guild.MainPlayerHasAuthority(guild.AUTH_NOTICE):
            self.__PopupMessage(localeInfo.GUILD_NO_NOTICE_PERMISSION)
        else:
            self.markSelectDialog.Open()

    def __OnClickSelectGuildSymbolButton(self):
        if guild.MainPlayerHasAuthority(guild.AUTH_NOTICE):
            self.symbolSelectDialog.Open()
        else:
            self.__PopupMessage(localeInfo.GUILD_NO_NOTICE_PERMISSION)

    def __OnClickDeclareWarButton(self):
        inputDialog = DeclareGuildWarDialog()
        inputDialog.Open()
        self.inputDialog = inputDialog

    def __OnSelectMark(self, markFileName):
        ret = net.UploadMark("upload/"+markFileName)

        # MARK_BUG_FIX
        if net.ERROR_MARK_UPLOAD_NEED_RECONNECT == ret:
            self.__PopupMessage(localeInfo.UPLOAD_MARK_UPLOAD_NEED_RECONNECT);

        return ret
        # END_OF_MARK_BUG_FIX

    def __OnSelectSymbol(self, symbolFileName):
        net.UploadSymbol("upload/"+symbolFileName)

    def __OnClickOfferButton(self):

        curEXP = unsigned32(player.GetStatus(player.EXP))

        if curEXP <= 100:
            self.__PopupMessage(localeInfo.GUILD_SHORT_EXP);
            return

        self.offerDialog.Open(curEXP, 100)

    def __OnClickDepositButton(self):
        moneyDialog = uiPickMoney2.PickMoneyDialog()
        moneyDialog.LoadDialog()
        moneyDialog.SetMax(6)
        moneyDialog.SetTitleName(localeInfo.GUILD_DEPOSIT)
        moneyDialog.SetAcceptEvent(ui.__mem_func__(self.OnDeposit))
        moneyDialog.Open(player.GetMoney())
        self.moneyDialog = moneyDialog

    def __OnClickWithdrawButton(self):
        moneyDialog = uiPickMoney2.PickMoneyDialog()
        moneyDialog.LoadDialog()
        moneyDialog.SetMax(6)
        moneyDialog.SetTitleName(localeInfo.GUILD_WITHDRAW)
        moneyDialog.SetAcceptEvent(ui.__mem_func__(self.OnWithdraw))
        moneyDialog.Open(guild.GetGuildMoney())
        self.moneyDialog = moneyDialog

    def __OnBlock(self):
        popup = uiCommon.PopupDialog()
        popup.SetText(localeInfo.NOT_YET_SUPPORT)
        popup.SetAcceptEvent(self.__OnClosePopupDialog)
        popup.Open()
        self.popup = popup

    def __OnClosePopupDialog(self):
        self.popup = None

    def OnDeposit(self, money):
        net.SendGuildDepositMoneyPacket(money)

    def OnWithdraw(self, money):
        net.SendGuildWithdrawMoneyPacket(money)

    def OnOffer(self, exp):
        net.SendGuildOfferPacket(exp)

    ## Board
    def OnPostComment(self):

        text = self.commentSlot.GetText()
        if not text:
            return False

        net.SendGuildPostCommentPacket(text[:50])
        self.commentSlot.SetText("")
        return True

    def OnDeleteComment(self, index):

        commentID, chrName, comment = self.__GetGuildBoardCommentData(index)
        net.SendGuildDeleteCommentPacket(commentID)

    def OnRefreshComments(self):
        net.SendGuildRefreshCommentsPacket(0)

    def OnKeyDownInBoardPage(self, key):
        if key == 63:
            self.OnRefreshComments()
        return True

    ## Member
    ## OnEnableGeneral
    def OnChangeMemberGrade(self, lineIndex, gradeNumber):
        PID = guild.MemberIndexToPID(lineIndex + self.memberLinePos)
        net.SendGuildChangeMemberGradePacket(PID, gradeNumber)

    def OnEnableGeneral(self, lineIndex):
        if not guild.IsMember(lineIndex):
            return

        pid, name, grade, job, level, offer, general = self.GetMemberData(lineIndex)
        if pid < 0:
            return

        net.SendGuildChangeMemberGeneralPacket(pid, 1 - general)

    ## Grade
    def OnOpenChangeGradeName(self, arg):
        self.changeGradeNameDialog.SetGradeNumber(arg)
        self.changeGradeNameDialog.Open()

    def OnChangeGradeName(self):
        self.changeGradeNameDialog.Hide()
        gradeNumber = self.changeGradeNameDialog.GetGradeNumber()
        gradeName = self.changeGradeNameDialog.GetGradeName()

        if len(gradeName) == 0:
            gradeName = localeInfo.GUILD_DEFAULT_GRADE

        net.SendGuildChangeGradeNamePacket(gradeNumber, gradeName)
        return True

    def OnCheckAuthority(self, argIndex, argAuthority):
        name, authority = guild.GetGradeData(argIndex)
        net.SendGuildChangeGradeAuthorityPacket(argIndex, authority ^ argAuthority)

    def OnScrollMemberLine(self):
        scrollBar = self.pageWindow["MEMBER"].scrollBar
        pos = scrollBar.GetPos()

        count = guild.GetMemberCount()
        newLinePos = int(float(count - self.MEMBER_LINE_COUNT) * pos)

        if newLinePos != self.memberLinePos:
            self.memberLinePos = newLinePos
            self.RefreshGuildMemberPageMemberList()
            self.__CloseAllGuildMemberPageGradeComboBox()

    def GetMemberData(self, localPos):
        return guild.GetMemberData(localPos + self.memberLinePos)

    ## Guild Skill
    def __OnOpenHealGSPBoard(self):

        curPoint, maxPoint = guild.GetDragonPowerPoint()

        if maxPoint - curPoint <= 0:
            self.__PopupMessage(localeInfo.GUILD_CANNOT_HEAL_GSP_ANYMORE)
            return

        pickDialog = uiPickMoney2.PickMoneyDialog()
        pickDialog.LoadDialog()
        pickDialog.SetMax(9)
        pickDialog.SetTitleName(localeInfo.GUILD_HEAL_GSP)
        pickDialog.SetAcceptEvent(ui.__mem_func__(self.__OnOpenHealGSPQuestionDialog))
        pickDialog.Open(maxPoint - curPoint, 1)
        self.pickDialog = pickDialog

    def __OnOpenHealGSPQuestionDialog(self, healGSP):

        money = healGSP * constInfo.GUILD_MONEY_PER_GSP

        questionDialog = uiCommon.QuestionDialog()
        questionDialog.SetText(localeInfo.GUILD_DO_YOU_HEAL_GSP % (money, healGSP))
        questionDialog.SetAcceptEvent(ui.__mem_func__(self.__OnHealGSP))
        questionDialog.SetCancelEvent(ui.__mem_func__(self.__OnCloseQuestionDialog))
        questionDialog.SetWidth(400)
        questionDialog.Open()
        questionDialog.healGSP = healGSP
        self.questionDialog = questionDialog

    def __OnHealGSP(self):
        net.SendGuildChargeGSPPacket(self.questionDialog.healGSP)
        self.__OnCloseQuestionDialog()

    def __OnCloseQuestionDialog(self):
        if self.questionDialog:
            self.questionDialog.Close()
        self.questionDialog = None

    def OnPickUpGuildSkill(self, skillSlotIndex, type):

        mouseController = mouseModule.mouseController

        if False == mouseController.isAttached():

            skillIndex = player.GetSkillIndex(skillSlotIndex)
            skillLevel = guild.GetSkillLevel(skillSlotIndex)

            if skill.CanUseSkill(skillIndex) and skillLevel > 0:

                if app.IsPressed(app.DIK_LCONTROL):

                    player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_SKILL, skillSlotIndex)
                    return

                mouseController.AttachObject(self, player.SLOT_TYPE_SKILL, skillSlotIndex, skillIndex)

        else:
            mouseController.DeattachObject()

    def OnUseGuildSkill(self, slotNumber, type):
        skillIndex = player.GetSkillIndex(slotNumber)
        skillLevel = guild.GetSkillLevel(slotNumber)

        if skillLevel <= 0:
            return

        player.UseGuildSkill(slotNumber)

    def OnUpGuildSkill(self, slotNumber, type):
        skillIndex = player.GetSkillIndex(slotNumber)
        net.SendChatPacket("/gskillup " + str(skillIndex))

    def OnUseSkill(self, slotNumber, coolTime):

        if self.isLoaded==0:
            return

        page = self.pageWindow["SKILL"]

        if page.activeSlot.HasSlot(slotNumber):
            page.activeSlot.SetSlotCoolTime(slotNumber, coolTime)

    def OnStartGuildWar(self, guildSelf, guildOpp):

        if self.isLoaded==0:
            return

        if guild.GetGuildID() != guildSelf:
            return

        guildName = guild.GetGuildName(guildOpp)
        for guildNameTextLine in self.enemyGuildNameList:
            if localeInfo.GUILD_INFO_ENEMY_GUILD_EMPTY == guildNameTextLine.GetText():
                guildNameTextLine.SetText(guildName)
                return

    def OnEndGuildWar(self, guildSelf, guildOpp):

        if self.isLoaded==0:
            return

        if guild.GetGuildID() != guildSelf:
            return

        guildName = guild.GetGuildName(guildOpp)
        for guildNameTextLine in self.enemyGuildNameList:
            if guildName == guildNameTextLine.GetText():
                guildNameTextLine.SetText(localeInfo.GUILD_INFO_ENEMY_GUILD_EMPTY)
                return

    ## ToolTip
    def OverInItem(self, slotNumber, type):

        if mouseModule.mouseController.isAttached():
            return

        if None != self.tooltipSkill:
            skillIndex = player.GetSkillIndex(slotNumber)
            skillLevel = guild.GetSkillLevel(slotNumber)

            self.tooltipSkill.SetSkill(skillIndex, skillLevel)

    def OverOutItem(self):
        if None != self.tooltipSkill:
            self.tooltipSkill.HideToolTip()

    def OnPressEscapeKey(self):
        self.Close()
        return True


class BuildGuildBuildingWindow(ui.ScriptWindow):

    if localeInfo.IsJAPAN():
        GUILD_CATEGORY_LIST = (
                ("HEADQUARTER", localeInfo.GUILD_HEADQUARTER),
                ("FACILITY",     localeInfo.GUILD_FACILITY),
                ("OBJECT",     localeInfo.GUILD_OBJECT),
            )
    elif localeInfo.IsYMIR() or localeInfo.IsWE_KOREA():
        GUILD_CATEGORY_LIST = (
                ("HEADQUARTER", "본건물"),
                ("FACILITY", "기능건물"),
                ("OBJECT", "조경물"),
            )
    elif localeInfo.IsEUROPE() or localeInfo.IsHONGKONG():
        GUILD_CATEGORY_LIST = (
                ("HEADQUARTER", localeInfo.GUILD_HEADQUARTER),
                ("FACILITY",     localeInfo.GUILD_FACILITY),
                ("OBJECT",     localeInfo.GUILD_OBJECT),
            )
    else:
        try :
            GUILD_CATEGORY_LIST = (
                    ("HEADQUARTER", localeInfo.GUILD_HEADQUARTER),
                    ("FACILITY",     localeInfo.GUILD_FACILITY),
                    ("OBJECT",     localeInfo.GUILD_OBJECT),
                )
        except:
            GUILD_CATEGORY_LIST = (
                    ("HEADQUARTER", "Main Building"),
                    ("FACILITY", "Facility"),
                    ("OBJECT", "Object"),
                )

    MODE_VIEW = 0
    MODE_POSITIONING = 1
    MODE_PREVIEW = 2

    BUILDING_ALPHA = 0.55

    ENABLE_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
    DISABLE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)

    START_INSTANCE_INDEX = 123450
    #WALL_SET_INSTANCE = 14105

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

        self.closeEvent = None
        self.popup = None
        self.mode = self.MODE_VIEW
        self.race = 0
        self.type = None
        self.x = 0
        self.y = 0
        self.z = 0
        self.rot_x = 0
        self.rot_y = 0
        self.rot_z = 0
        self.rot_x_limit = 0
        self.rot_y_limit = 0
        self.rot_z_limit = 0
        self.needMoney = 0
        self.needStoneCount = 0
        self.needLogCount = 0
        self.needPlywoodCount = 0

        #self.index = 0
        self.indexList = []
        self.raceList = []
        self.posList = []
        self.rotList = []

        index = 0
        for category in self.GUILD_CATEGORY_LIST:
            self.categoryList.InsertItem(index, category[1])
            index += 1

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

    def __LoadWindow(self):

        try:
            pyScrLoader = ui.PythonScriptLoader()
            if localeInfo.IsARABIC():
                pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "buildguildbuildingwindow.py")
            elif localeInfo.IsVIETNAM():
                pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "buildguildbuildingwindow.py")
            else:
                pyScrLoader.LoadScriptFile(self, "uiscript/buildguildbuildingwindow.py")
        except:
            import exception
            exception.Abort("DeclareGuildWarWindow.__CreateDialog - LoadScript")

        try:
            getObject = self.GetChild
            self.board = getObject("Board")
            self.categoryList = getObject("CategoryList")
            self.buildingList = getObject("BuildingList")
            self.listScrollBar = getObject("ListScrollBar")
            self.positionButton = getObject("PositionButton")
            self.previewButton = getObject("PreviewButton")
            self.posValueX = getObject("BuildingPositionXValue")
            self.posValueY = getObject("BuildingPositionYValue")
            self.ctrlRotationX = getObject("BuildingRotationX")
            self.ctrlRotationY = getObject("BuildingRotationY")
            self.ctrlRotationZ = getObject("BuildingRotationZ")
            self.buildingPriceValue = getObject("BuildingPriceValue")
            self.buildingMaterialStoneValue = getObject("BuildingMaterialStoneValue")
            self.buildingMaterialLogValue = getObject("BuildingMaterialLogValue")
            self.buildingMaterialPlywoodValue = getObject("BuildingMaterialPlywoodValue")

            self.positionButton.SetEvent(ui.__mem_func__(self.__OnSelectPositioningMode))
            self.previewButton.SetToggleDownEvent(ui.__mem_func__(self.__OnEnterPreviewMode))
            self.previewButton.SetToggleUpEvent(ui.__mem_func__(self.__OnLeavePreviewMode))
            self.ctrlRotationX.SetEvent(ui.__mem_func__(self.__OnChangeRotation))
            self.ctrlRotationY.SetEvent(ui.__mem_func__(self.__OnChangeRotation))
            self.ctrlRotationZ.SetEvent(ui.__mem_func__(self.__OnChangeRotation))
            self.listScrollBar.SetScrollEvent(ui.__mem_func__(self.__OnScrollBuildingList))

            getObject("CategoryList").SetEvent(ui.__mem_func__(self.__OnSelectCategory))
            getObject("BuildingList").SetEvent(ui.__mem_func__(self.__OnSelectBuilding))
            getObject("AcceptButton").SetEvent(ui.__mem_func__(self.Build))
            getObject("CancelButton").SetEvent(ui.__mem_func__(self.Close))
            self.board.SetCloseEvent(ui.__mem_func__(self.Close))

        except:
            import exception
            exception.Abort("BuildGuildBuildingWindow.__LoadWindow - BindObject")

    def __CreateWallBlock(self, race, x, y, rot=0.0 ):
        idx = self.START_INSTANCE_INDEX + len(self.indexList)
        self.indexList.append(idx)
        self.raceList.append(race)
        self.posList.append((x, y))
        self.rotList.append(rot)
        chr.CreateInstance(idx)
        chr.SelectInstance(idx)
        chr.SetVirtualID(idx)
        chr.SetInstanceType(chr.INSTANCE_TYPE_OBJECT)

        chr.SetRace(race)
        chr.SetArmor(0)
        chr.Refresh()
        chr.SetLoopMotion(chr.MOTION_WAIT)
        chr.SetBlendRenderMode(idx, self.BUILDING_ALPHA)
        chr.SetRotationAll(0.0, 0.0, rot)

        self.ctrlRotationX.SetSliderPos(0.5)
        self.ctrlRotationY.SetSliderPos(0.5)
        self.ctrlRotationZ.SetSliderPos(0.5)

    def __GetObjectSize(self, race):
        idx = self.START_INSTANCE_INDEX + 1000
        chr.CreateInstance(idx)
        chr.SelectInstance(idx)
        chr.SetVirtualID(idx)
        chr.SetInstanceType(chr.INSTANCE_TYPE_OBJECT)

        chr.SetRace(race)
        chr.SetArmor(0)
        chr.Refresh()
        chr.SetLoopMotion(chr.MOTION_WAIT)
        sx, sy, ex, ey = chr.GetBoundBoxOnlyXY(idx)
        chr.DeleteInstance(idx)
        return sx, sy, ex, ey

    def __GetBuildInPosition(self):

        zList = []
        zList.append( background.GetHeight(self.x+self.sxPos, self.y+self.syPos) )
        zList.append( background.GetHeight(self.x+self.sxPos, self.y+self.eyPos) )
        zList.append( background.GetHeight(self.x+self.exPos, self.y+self.syPos) )
        zList.append( background.GetHeight(self.x+self.exPos, self.y+self.eyPos) )
        zList.append( background.GetHeight(self.x+(self.exPos+self.sxPos)/2, self.y+(self.eyPos+self.syPos)/2) )
        zList.sort()
        return zList[3]

    def __CreateBuildInInstance(self,race):

        self.__DeleteInstance()

        object_base = race - race%10

        door_minX, door_minY, door_maxX, door_maxY = self.__GetObjectSize(object_base+4)
        corner_minX, corner_minY, corner_maxX, corner_maxY = self.__GetObjectSize(object_base+1)
        line_minX, line_minY, line_maxX, line_maxY = self.__GetObjectSize(object_base+2)
        line_width = line_maxX - line_minX
        line_width_half = line_width / 2

        X_SIZE_STEP = 2 * 2 ## 2의 단위로만 증가해야 함
        Y_SIZE_STEP = 8
        sxPos = door_maxX - corner_minX + (line_width_half*X_SIZE_STEP)
        exPos = -sxPos
        syPos = 0
        eyPos = -(corner_maxY*2 + line_width*Y_SIZE_STEP)

        self.sxPos = sxPos
        self.syPos = syPos
        self.exPos = exPos
        self.eyPos = eyPos

        z = self.__GetBuildInPosition()

        ## Door
        self.__CreateWallBlock(object_base+4, 0.0, syPos)

        ## Corner
        self.__CreateWallBlock(object_base+1, sxPos, syPos)
        self.__CreateWallBlock(object_base+1, exPos, syPos, 270.0)
        self.__CreateWallBlock(object_base+1, sxPos, eyPos, 90.0)
        self.__CreateWallBlock(object_base+1, exPos, eyPos,180.0 )

        ## Line
        lineBlock = object_base+2
        line_startX = -door_maxX - line_minX - (line_width_half*X_SIZE_STEP)
        self.__CreateWallBlock(lineBlock, line_startX, eyPos)
        self.__CreateWallBlock(lineBlock, line_startX+line_width*1, eyPos)
        self.__CreateWallBlock(lineBlock, line_startX+line_width*2, eyPos)
        self.__CreateWallBlock(lineBlock, line_startX+line_width*3, eyPos)
        for i in xrange(X_SIZE_STEP):
            self.__CreateWallBlock(lineBlock, line_startX+line_width*(3+i+1), eyPos)
        for i in xrange(X_SIZE_STEP/2):
            self.__CreateWallBlock(lineBlock, door_minX - line_maxX - line_width*i, syPos)
            self.__CreateWallBlock(lineBlock, door_maxX - line_minX + line_width*i, syPos)
        for i in xrange(Y_SIZE_STEP):
            self.__CreateWallBlock(lineBlock, sxPos, line_minX + corner_minX - line_width*i, 90.0)
            self.__CreateWallBlock(lineBlock, exPos, line_minX + corner_minX - line_width*i, 90.0)

        self.SetBuildingPosition(int(self.x), int(self.y), self.__GetBuildInPosition())

    def __DeleteInstance(self):
        if not self.indexList:
            return

        for index in self.indexList:
            chr.DeleteInstance(index)

        self.indexList = []
        self.raceList = []
        self.posList = []
        self.rotList = []

    def __CreateInstance(self, race):

        self.__DeleteInstance()

        self.race = race

        idx = self.START_INSTANCE_INDEX
        self.indexList.append(idx)
        self.posList.append((0, 0))
        self.rotList.append(0)

        chr.CreateInstance(idx)
        chr.SelectInstance(idx)
        chr.SetVirtualID(idx)
        chr.SetInstanceType(chr.INSTANCE_TYPE_OBJECT)

        chr.SetRace(race)
        chr.SetArmor(0)
        chr.Refresh()
        chr.SetLoopMotion(chr.MOTION_WAIT)
        chr.SetBlendRenderMode(idx, self.BUILDING_ALPHA)

        self.SetBuildingPosition(int(self.x), int(self.y), 0)
        self.ctrlRotationX.SetSliderPos(0.5)
        self.ctrlRotationY.SetSliderPos(0.5)
        self.ctrlRotationZ.SetSliderPos(0.5)

    def Build(self):

        if not self.__IsEnoughMoney():
            self.__PopupDialog(localeInfo.GUILD_NOT_ENOUGH_MONEY)
            return
        if not self.__IsEnoughMaterialStone():
            self.__PopupDialog(localeInfo.GUILD_NOT_ENOUGH_MATERIAL)
            return
        if not self.__IsEnoughMaterialLog():
            self.__PopupDialog(localeInfo.GUILD_NOT_ENOUGH_MATERIAL)
            return
        if not self.__IsEnoughMaterialPlywood():
            self.__PopupDialog(localeInfo.GUILD_NOT_ENOUGH_MATERIAL)
            return

        ## /build c vnum x y x_rot y_rot z_rot
        ## /build d vnum
        if "BUILDIN" == self.type:
            for i in xrange(len(self.raceList)):
                race = self.raceList
                xPos, yPos = self.posList
                rot = self.rotList
                net.SendChatPacket("/build c %d %d %d %d %d %d" % (race, int(self.x+xPos), int(self.y+yPos), self.rot_x, self.rot_y, rot))
        else:
            net.SendChatPacket("/build c %d %d %d %d %d %d" % (self.race, int(self.x), int(self.y), self.rot_x, self.rot_y, self.rot_z))

        self.Close()

    def Open(self):
        x, y, z = player.GetMainCharacterPosition()
        app.SetCameraSetting(int(x), int(-y), int(z), 3000, 0, 30)

        background.VisibleGuildArea()

        self.x = x
        self.y = y
        self.z = z
        self.categoryList.SelectItem(0)
        self.buildingList.SelectItem(0)
        self.SetTop()
        self.Show()
        self.__DisablePCBlocker()

        import debugInfo
        if debugInfo.IsDebugMode():
            self.categoryList.SelectItem(2)
            self.buildingList.SelectItem(0)

    def Close(self):

        self.__DeleteInstance()

        background.DisableGuildArea()

        self.Hide()
        self.__OnClosePopupDialog()
        self.__EnablePCBlocker()
        self.__UnlockCameraMoving()
        if self.closeEvent:
            self.closeEvent()

    def Destory(self):
        self.Close()

        self.ClearDictionary()
        self.board = None
        self.categoryList = None
        self.buildingList = None
        self.listScrollBar = None
        self.positionButton = None
        self.previewButton = None
        self.posValueX = None
        self.posValueY = None
        self.ctrlRotationX = None
        self.ctrlRotationY = None
        self.ctrlRotationZ = None
        self.buildingPriceValue = None
        self.buildingMaterialStoneValue = None
        self.buildingMaterialLogValue = None
        self.buildingMaterialPlywoodValue = None
        self.closeEvent = None

    def SetCloseEvent(self, event):
        self.closeEvent = event

    def __PopupDialog(self, text):
        popup = uiCommon.PopupDialog()
        popup.SetText(text)
        popup.SetAcceptEvent(self.__OnClosePopupDialog)
        popup.Open()
        self.popup = popup

    def __OnClosePopupDialog(self):
        self.popup = None

    def __EnablePCBlocker(self):
        ## PC Blocker 처리를 켠다. (투명해짐)
        chr.SetInstanceType(chr.INSTANCE_TYPE_BUILDING)

        for idx in self.indexList:
            chr.SetBlendRenderMode(idx, 1.0)

    def __DisablePCBlocker(self):
        ## PC Blocker 처리를 끈다. (안투명해짐)
        chr.SetInstanceType(chr.INSTANCE_TYPE_OBJECT)

        for idx in self.indexList:
            chr.SetBlendRenderMode(idx, self.BUILDING_ALPHA)

    def __OnSelectPositioningMode(self):
        if self.MODE_PREVIEW == self.mode:
            self.positionButton.SetUp()
            return

        self.mode = self.MODE_POSITIONING
        self.Hide()

    def __OnEnterPreviewMode(self):

        if self.MODE_POSITIONING == self.mode:
            self.previewButton.SetUp()
            return

        self.mode = self.MODE_PREVIEW
        self.positionButton.SetUp()
        self.__UnlockCameraMoving()
        self.__EnablePCBlocker()

    def __OnLeavePreviewMode(self):
        self.__RestoreViewMode()

    def __RestoreViewMode(self):
        self.__DisablePCBlocker()
        self.__LockCameraMoving()
        self.mode = self.MODE_VIEW
        self.positionButton.SetUp()
        self.previewButton.SetUp()

    def __IsEnoughMoney(self):

        if app.IsEnableTestServerFlag():
            return True

        curMoney = player.GetMoney()
        if curMoney < self.needMoney:
            return False
        return True

    def __IsEnoughMaterialStone(self):

        if app.IsEnableTestServerFlag():
            return True

        curStoneCount = player.GetItemCountByVnum(MATERIAL_STONE_ID)
        if curStoneCount < self.needStoneCount:
            return False
        return True

    def __IsEnoughMaterialLog(self):

        if app.IsEnableTestServerFlag():
            return True

        curLogCount = player.GetItemCountByVnum(MATERIAL_LOG_ID)
        if curLogCount < self.needLogCount:
            return False
        return True

    def __IsEnoughMaterialPlywood(self):

        if app.IsEnableTestServerFlag():
            return True

        curPlywoodCount = player.GetItemCountByVnum(MATERIAL_PLYWOOD_ID)
        if curPlywoodCount < self.needPlywoodCount:
            return False
        return True

    def __OnSelectCategory(self):
        self.listScrollBar.SetPos(0.0)
        self.__RefreshItem()

    def __SetBuildingData(self, data):
        self.buildingPriceValue.SetText(NumberToMoneyString(data["PRICE"]))

        self.needMoney = int(data["PRICE"])

        materialList = data["MATERIAL"]
        self.needStoneCount = int(materialList[MATERIAL_STONE_INDEX])
        self.needLogCount = int(materialList[MATERIAL_LOG_INDEX])
        self.needPlywoodCount = int(materialList[MATERIAL_PLYWOOD_INDEX])

        if (localeInfo.IsEUROPE() and app.GetLocalePath() != "locale/ca") and (localeInfo.IsEUROPE() and app.GetLocalePath() != "locale/br"):
            self.buildingMaterialStoneValue.SetText(materialList[MATERIAL_STONE_INDEX])
            self.buildingMaterialLogValue.SetText(materialList[MATERIAL_LOG_INDEX] )
            self.buildingMaterialPlywoodValue.SetText(materialList[MATERIAL_PLYWOOD_INDEX])
        else:
            self.buildingMaterialStoneValue.SetText(materialList[MATERIAL_STONE_INDEX] + localeInfo.THING_COUNT)
            self.buildingMaterialLogValue.SetText(materialList[MATERIAL_LOG_INDEX] + localeInfo.THING_COUNT)
            self.buildingMaterialPlywoodValue.SetText(materialList[MATERIAL_PLYWOOD_INDEX] + localeInfo.THING_COUNT)
        if self.__IsEnoughMoney():
            self.buildingPriceValue.SetPackedFontColor(self.ENABLE_COLOR)
        else:
            self.buildingPriceValue.SetPackedFontColor(self.DISABLE_COLOR)

        if self.__IsEnoughMaterialStone():
            self.buildingMaterialStoneValue.SetPackedFontColor(self.ENABLE_COLOR)
        else:
            self.buildingMaterialStoneValue.SetPackedFontColor(self.DISABLE_COLOR)

        if self.__IsEnoughMaterialLog():
            self.buildingMaterialLogValue.SetPackedFontColor(self.ENABLE_COLOR)
        else:
            self.buildingMaterialLogValue.SetPackedFontColor(self.DISABLE_COLOR)

        if self.__IsEnoughMaterialPlywood():
            self.buildingMaterialPlywoodValue.SetPackedFontColor(self.ENABLE_COLOR)
        else:
            self.buildingMaterialPlywoodValue.SetPackedFontColor(self.DISABLE_COLOR)

        self.rot_x_limit = data["X_ROT_LIMIT"]
        self.rot_y_limit = data["Y_ROT_LIMIT"]
        self.rot_z_limit = data["Z_ROT_LIMIT"]
        self.ctrlRotationX.Enable()
        self.ctrlRotationY.Enable()
        self.ctrlRotationZ.Enable()
        if 0 == self.rot_x_limit:
            self.ctrlRotationX.Disable()
        if 0 == self.rot_y_limit:
            self.ctrlRotationY.Disable()
        if 0 == self.rot_z_limit:
            self.ctrlRotationZ.Disable()

    def __OnSelectBuilding(self):
        buildingIndex = self.buildingList.GetSelectedItem()
        if buildingIndex >= len(BUILDING_DATA_LIST):
            return

        categoryIndex = self.categoryList.GetSelectedItem()
        if categoryIndex >= len(self.GUILD_CATEGORY_LIST):
            return
        selectedType = self.GUILD_CATEGORY_LIST[categoryIndex][0]

        index = 0
        for data in BUILDING_DATA_LIST:
            type = data["TYPE"]
            vnum = data["VNUM"]
            if selectedType != type:
                continue

            if index == buildingIndex:
                self.type = type
                if "BUILDIN" == self.type:
                    self.__CreateBuildInInstance(vnum)
                else:
                    self.__CreateInstance(vnum)

                self.__SetBuildingData(data)

            index += 1

    def __OnScrollBuildingList(self):
        viewItemCount = self.buildingList.GetViewItemCount()
        itemCount = self.buildingList.GetItemCount()
        pos = self.listScrollBar.GetPos() * (itemCount-viewItemCount)
        self.buildingList.SetBasePos(int(pos))

    def __OnChangeRotation(self):
        self.rot_x = self.ctrlRotationX.GetSliderPos() * self.rot_x_limit - self.rot_x_limit/2
        self.rot_y = self.ctrlRotationY.GetSliderPos() * self.rot_y_limit - self.rot_y_limit/2
        self.rot_z = (self.ctrlRotationZ.GetSliderPos() * 360 + 180) % 360
        if "BUILDIN" == self.type:
            chr.SetRotationAll(self.rot_x, self.rot_y, self.rot_z)
        else:
            chr.SetRotationAll(self.rot_x, self.rot_y, self.rot_z)

    def __LockCameraMoving(self):
        app.SetCameraSetting(int(self.x), int(-self.y), int(self.z), 3000, 0, 30)

    def __UnlockCameraMoving(self):
        app.SetDefaultCamera()

    def __RefreshItem(self):

        self.buildingList.ClearItem()

        categoryIndex = self.categoryList.GetSelectedItem()
        if categoryIndex >= len(self.GUILD_CATEGORY_LIST):
            return
        selectedType = self.GUILD_CATEGORY_LIST[categoryIndex][0]

        index = 0
        for data in BUILDING_DATA_LIST:
            if selectedType != data["TYPE"]:
                continue

            if data["SHOW"]:
                self.buildingList.InsertItem(index, data["LOCAL_NAME"])

            index += 1

        self.buildingList.SelectItem(0)

        if self.buildingList.GetItemCount() < self.buildingList.GetViewItemCount():
            self.buildingList.SetSize(120, self.buildingList.GetHeight())
            self.buildingList.LocateItem()
            self.listScrollBar.Hide()
        else:
            self.buildingList.SetSize(105, self.buildingList.GetHeight())
            self.buildingList.LocateItem()
            self.listScrollBar.Show()

    def SettleCurrentPosition(self):
        guildID = miniMap.GetGuildAreaID(self.x, self.y)

        import debugInfo
        if debugInfo.IsDebugMode():
            guildID = player.GetGuildID()

        if guildID != player.GetGuildID():
            return

        self.__RestoreViewMode()
        self.__LockCameraMoving()
        self.Show()

    def SetBuildingPosition(self, x, y, z):
        self.x = x
        self.y = y
        self.posValueX.SetText(str(int(x)))
        self.posValueY.SetText(str(int(y)))

        for i in xrange(len(self.indexList)):
            idx = self.indexList
            xPos, yPos = self.posList

            chr.SelectInstance(idx)
            if 0 != z:
                self.z = z
                chr.SetPixelPosition(int(x+xPos), int(y+yPos), int(z))
            else:
                chr.SetPixelPosition(int(x+xPos), int(y+yPos))

    def IsPositioningMode(self):
        if self.MODE_POSITIONING == self.mode:
            return True
        return False

    def IsPreviewMode(self):
        if self.MODE_PREVIEW == self.mode:
            return True
        return False

    def OnPressEscapeKey(self):
        self.Close()
        return True

"""
- 프로토콜

게임돌입시:
    RecvLandPacket:
        CPythonMiniMap::RegisterGuildArea

게임이동중:
    PythonPlayer::Update()
        CPythonPlayer::__Update_NotifyGuildAreaEvent()
            game.py.BINARY_Guild_EnterGuildArea
                uigameButton.GameButtonWindow.ShowBuildButton()
            game.py.BINARY_Guild_ExitGuildArea
                uigameButton.GameButtonWindow.HideBuildButton()

BuildButton:
!길드장인지 처리 없음
!건물이 있어도 짓기 버튼은 있음

!건물이 임시로 사용하는 VID 는 서버가 보내주는 것과 혼동될 염려가 있음
!건물 VNUM 은 BuildGuildBuildingWindow.BUILDING_VNUM_LIST 를 이용해 변환

!건물 지을때는 /build c(reate)
!건물 부술때는 /build d(estroy)
!rotation 의 단위는 degree

    interfaceModule.interface.__OnClickBuildButton:
        interfaceModule.interface.BUILD_OpenWindow:

AcceptButton:
    BuildGuildBuildingWindow.Build:
        net.SendChatPacket("/build c vnum x y x_rot y_rot z_rot")

PreviewButton:
    __OnPreviewMode:
    __RestoreViewMode:

건물 부수기:
    uiTarget.TargetBoard.__OnDestroyBuilding
        net.SendChatPacket("/build d vid")
"""

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()

    import chrmgr
    chrmgr.CreateRace(0)
    chrmgr.SelectRace(0)
    chrmgr.SetPathName("d:/ymir Work/pc/warrior/")
    chrmgr.LoadRaceData("warrior.msm")
    chrmgr.SetPathName("d:/ymir work/pc/warrior/general/")
    chrmgr.RegisterMotionMode(chr.MOTION_MODE_GENERAL)
    chrmgr.RegisterMotionData(chr.MOTION_MODE_GENERAL, chr.MOTION_WAIT, "wait.msa")
    chrmgr.RegisterMotionData(chr.MOTION_MODE_GENERAL, chr.MOTION_RUN, "run.msa")

    def LoadGuildBuildingList(filename):
        handle = app.OpenTextFile(filename)
        count = app.GetTextFileLineCount(handle)
        for i in xrange(count):
            line = app.GetTextFileLine(handle, i)
            tokens = line.split("\t")

            TOKEN_VNUM = 0
            TOKEN_TYPE = 1
            TOKEN_NAME = 2
            TOKEN_LOCAL_NAME = 3
            NO_USE_TOKEN_SIZE_1 = 4
            NO_USE_TOKEN_SIZE_2 = 5
            NO_USE_TOKEN_SIZE_3 = 6
            NO_USE_TOKEN_SIZE_4 = 7
            TOKEN_X_ROT_LIMIT = 8
            TOKEN_Y_ROT_LIMIT = 9
            TOKEN_Z_ROT_LIMIT = 10
            TOKEN_PRICE = 11
            TOKEN_MATERIAL = 12
            TOKEN_NPC = 13
            TOKEN_GROUP = 14
            TOKEN_DEPEND_GROUP = 15
            TOKEN_ENABLE_FLAG = 16
            LIMIT_TOKEN_COUNT = 17

            if not tokens[TOKEN_VNUM].isdigit():
                continue

            if not int(tokens[TOKEN_ENABLE_FLAG]):
                continue

            if len(tokens) < LIMIT_TOKEN_COUNT:
                import dbg
                dbg.TraceError("Strange token count [%d/%d] [%s]" % (len(tokens), LIMIT_TOKEN_COUNT, line))
                continue

            ENABLE_FLAG_TYPE_NOT_USE = False
            ENABLE_FLAG_TYPE_USE = True
            ENABLE_FLAG_TYPE_USE_BUT_HIDE = 2

            if ENABLE_FLAG_TYPE_NOT_USE == int(tokens[TOKEN_ENABLE_FLAG]):
                continue

            vnum = int(tokens[TOKEN_VNUM])
            type = tokens[TOKEN_TYPE]
            name = tokens[TOKEN_NAME]
            localName = tokens[TOKEN_LOCAL_NAME]
            xRotLimit = int(tokens[TOKEN_X_ROT_LIMIT])
            yRotLimit = int(tokens[TOKEN_Y_ROT_LIMIT])
            zRotLimit = int(tokens[TOKEN_Z_ROT_LIMIT])
            price = tokens[TOKEN_PRICE]
            material = tokens[TOKEN_MATERIAL]

            folderName = ""
            if "HEADQUARTER" == type:
                folderName = "headquarter"
            elif "FACILITY" == type:
                folderName = "facility"
            elif "OBJECT" == type:
                folderName = "object"
            ##"BuildIn" Is made by exist instance.

            materialList = ["0", "0", "0"]
            if material[0] == "\"":
                material = material[1:]
            if material[-1] == "\"":
                material = material[:-1]
            for one in material.split("/"):
                data = one.split(",")
                if 2 != len(data):
                    continue
                itemID = int(data[0])
                count = data[1]

                if itemID == MATERIAL_STONE_ID:
                    materialList[MATERIAL_STONE_INDEX] = count
                elif itemID == MATERIAL_LOG_ID:
                    materialList[MATERIAL_LOG_INDEX] = count
                elif itemID == MATERIAL_PLYWOOD_ID:
                    materialList[MATERIAL_PLYWOOD_INDEX] = count

            import chrmgr
            chrmgr.RegisterRaceSrcName(name, folderName)
            chrmgr.RegisterRaceName(vnum, name)

            appendingData = { "VNUM":vnum,
                              "TYPE":type,
                              "NAME":name,
                              "LOCAL_NAME":localName,
                              "X_ROT_LIMIT":xRotLimit,
                              "Y_ROT_LIMIT":yRotLimit,
                              "Z_ROT_LIMIT":zRotLimit,
                              "PRICE":price,
                              "MATERIAL":materialList,
                              "SHOW" : True }

            if ENABLE_FLAG_TYPE_USE_BUT_HIDE == int(tokens[TOKEN_ENABLE_FLAG]):
                appendingData["SHOW"] = False

            BUILDING_DATA_LIST.append(appendingData)

        app.CloseTextFile(handle)

    LoadGuildBuildingList(app.GetLocalePath()+"/GuildBuildingList.txt")

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

            x = 30000
            y = 40000

            self.wndGuildBuilding = None
            self.onClickKeyDict = {}
            self.onClickKeyDict[app.DIK_SPACE] = lambda: self.OpenBuildGuildBuildingWindow()

            background.Initialize()
            background.LoadMap("metin2_map_a1", x, y, 0)
            background.SetShadowLevel(background.SHADOW_ALL)

            self.MakeCharacter(1, 0, x, y)
            player.SetMainCharacterIndex(1)
            chr.SelectInstance(1)

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

        def MakeCharacter(self, index, race, x, y):
            chr.CreateInstance(index)
            chr.SelectInstance(index)
            chr.SetVirtualID(index)
            chr.SetInstanceType(chr.INSTANCE_TYPE_PLAYER)

            chr.SetRace(race)
            chr.SetArmor(0)
            chr.SetHair(0)
            chr.Refresh()
            chr.SetMotionMode(chr.MOTION_MODE_GENERAL)
            chr.SetLoopMotion(chr.MOTION_WAIT)

            chr.SetPixelPosition(x, y)
            chr.SetDirection(chr.DIR_NORTH)

        def OpenBuildGuildBuildingWindow(self):
            self.wndGuildBuilding = BuildGuildBuildingWindow()
            self.wndGuildBuilding.Open()
            self.wndGuildBuilding.SetParent(self)
            self.wndGuildBuilding.SetTop()

        def OnKeyUp(self, key):
            if key in self.onClickKeyDict:
                self.onClickKeyDict[key]()
            return True

        def OnMouseLeftButtonDown(self):
            if self.wndGuildBuilding:
                if self.wndGuildBuilding.IsPositioningMode():
                    self.wndGuildBuilding.SettleCurrentPosition()
                    return

            player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);
            return True

        def OnMouseLeftButtonUp(self):
            if self.wndGuildBuilding:
                return

            player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)
            return True

        def OnMouseRightButtonDown(self):
            player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS);
            return True

        def OnMouseRightButtonUp(self):
            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.wndGuildBuilding:
                if self.wndGuildBuilding.IsPositioningMode():
                    x, y, z = background.GetPickingPoint()
                    self.wndGuildBuilding.SetBuildingPosition(x, y, z)

        def OnRender(self):
            app.RenderGame()
            grp.PopState()
            grp.SetInterfaceRenderState()

    game = TestGame()
    game.SetSize(systemSetting.GetWidth(), systemSetting.GetHeight())
    game.Show()

    wndGuildBuilding = BuildGuildBuildingWindow()
    wndGuildBuilding.Open()
    wndGuildBuilding.SetTop()

    app.Loop()

    """
    - 프로토콜

게임돌입시:
    RecvLandPacket:
        CPythonMiniMap::RegisterGuildArea

게임이동중:
    PythonPlayer::Update()
        CPythonPlayer::__Update_NotifyGuildAreaEvent()
            game.py.BINARY_Guild_EnterGuildArea
                uigameButton.GameButtonWindow.ShowBuildButton()
            game.py.BINARY_Guild_ExitGuildArea
                uigameButton.GameButtonWindow.HideBuildButton()

BuildButton:
!길드장인지 처리 없음
!건물이 있어도 짓기 버튼은 있음

!건물이 임시로 사용하는 VID 는 서버가 보내주는 것과 혼동될 염려가 있음
!건물 VNUM 은 BuildGuildBuildingWindow.BUILDING_VNUM_LIST 를 이용해 변환

!건물 지을때는 /build c(reate)
!건물 부술때는 /build d(estroy)
!rotation 의 단위는 degree

    interfaceModule.interface.__OnClickBuildButton:
        interfaceModule.interface.BUILD_OpenWindow:

AcceptButton:
    BuildGuildBuildingWindow.Build:
        net.SendChatPacket("/build c vnum x y x_rot y_rot z_rot")

    x_rot, y_rot 는 AffectContainer에 저장

PreviewButton:
    __OnPreviewMode:
    __RestoreViewMode:

건물 부수기:
    uiTarget.TargetBoard.__OnDestroyBuilding
        net.SendChatPacket("/build d vid")
    """
 

this is my GuildWindow class 

onupdate function in inside class TestGame(ui.Window):  

and i don't have another onupdate functions

Link to comment
Share on other sites

  • 10 months later...

And why to put this pulse, players can't see anyways the new messages and the old one is just hide if u reach the limit of 12 rows at guild window, better to make a check to can add only 12 messages and delete one for write another one.

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
  • Recently Browsing   0 members

    • No registered users viewing this page.


  • Activity

    1. 4

      problem Dargon Soul Changre Attribute

    2. 41

      Global Chat

    3. 4

      problem Dargon Soul Changre Attribute

    4. 2

      Startup Loading Window Library

    5. 28

      Ludus2: metin2 fan project

    6. 44

      Inbuild GR2 Animation

    7. 6

      Minimap Mob proto

Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.