Exemplo n.º 1
0
    def __LoadBoard(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            if locale.IsJAPAN():
                pyScrLoader.LoadScriptFile(
                    self, uiScriptLocale.LOCALE_UISCRIPT_PATH +
                    "PartyMemberInfoBoard.py")
            else:
                pyScrLoader.LoadScriptFile(self,
                                           "UIScript/PartyMemberInfoBoard.py")
        except:
            import exception
            exception.Abort("PartyMemberInfoBoard.__LoadBoard.LoadScript")

        try:
            self.nameTextLine = self.GetChild("NamePrint")
            self.gauge = self.GetChild("Gauge")
            self.stateButton = self.GetChild("StateButton")
            self.partyAffectImageList.append(self.GetChild("ExperienceImage"))
            self.partyAffectImageList.append(self.GetChild("AttackerImage"))
            self.partyAffectImageList.append(self.GetChild("DefenderImage"))
            self.partyAffectImageList.append(self.GetChild("BufferImage"))
            self.partyAffectImageList.append(self.GetChild("SkillMasterImage"))
            self.partyAffectImageList.append(self.GetChild("TimeBonusImage"))
            self.partyAffectImageList.append(self.GetChild("RegenBonus"))
            self.partyAffectImageList.append(self.GetChild("IncreaseArea150"))
            self.partyAffectImageList.append(self.GetChild("IncreaseArea200"))
            self.stateButton.SetEvent(
                ui.__mem_func__(self.OnMouseLeftButtonDown))
        except:
            import exception
            exception.Abort("PartyMemberInfoBoard.__LoadBoard.BindObject")

        self.__SetAffectsMouseEvent()
        self.__HideAllAffects()
Exemplo n.º 2
0
    def __LoadWindow(self):
        if self.isLoaded == 1:
            return

        self.isLoaded = 1

        try:
            if locale.IsARABIC() or locale.IsVIETNAM() or locale.IsJAPAN():
                self.__LoadScript(uiScriptLocale.LOCALE_UISCRIPT_PATH +
                                  "CharacterWindow.py")
            else:
                self.__LoadScript("UIScript/CharacterWindow.py")

            self.__BindObject()
            self.__BindEvent()
        except:
            import exception
            exception.Abort("CharacterWindow.__LoadWindow")

        #self.tabButtonDict["EMOTICON"].Disable()
        self.SetState("STATUS")
Exemplo n.º 3
0
class PartyMemberInfoBoard(ui.ScriptWindow):
    if locale.IsJAPAN():
        BOARD_WIDTH = 130
    else:
        BOARD_WIDTH = 106
    BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
    GAUGE_OUT_LINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)

    LINK_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
    UNLINK_COLOR = grp.GenerateColor(0.5, 0.5, 0.5, 1.0)
    #UNLINK_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)

    PARTY_AFFECT_EXPERIENCE = 0
    PARTY_AFFECT_ATTACKER = 1
    PARTY_AFFECT_TANKER = 2
    PARTY_AFFECT_BUFFER = 3
    PARTY_AFFECT_SKILL_MASTER = 4
    PARTY_AFFECT_BERSERKER = 5
    PARTY_AFFECT_DEFENDER = 6
    #PARTY_AFFECT_TIME_BONUS		= 5
    #PARTY_AFFECT_REGEN_BONUS		= 6
    PARTY_AFFECT_INCREASE_AREA_150 = 7
    PARTY_AFFECT_INCREASE_AREA_200 = 8
    AFFECT_STRING_DICT = {
        PARTY_AFFECT_EXPERIENCE: locale.PARTY_BONUS_EXP,
        PARTY_AFFECT_ATTACKER: locale.PARTY_BONUS_ATTACKER,
        PARTY_AFFECT_TANKER: locale.PARTY_BONUS_TANKER,
        PARTY_AFFECT_BUFFER: locale.PARTY_BONUS_BUFFER,
        PARTY_AFFECT_SKILL_MASTER: locale.PARTY_BONUS_SKILL_MASTER,
        PARTY_AFFECT_BERSERKER: locale.PARTY_BONUS_BERSERKER,
        PARTY_AFFECT_DEFENDER: locale.PARTY_BONUS_DEFENDER,
        PARTY_AFFECT_INCREASE_AREA_150: locale.PARTY_INCREASE_AREA_150,
        PARTY_AFFECT_INCREASE_AREA_200: locale.PARTY_INCREASE_AREA_200,
    }

    PARTY_SKILL_HEAL = 1
    PARTY_SKILL_WARP = 2
    MEMBER_BUTTON_NORMAL = 10
    MEMBER_BUTTON_WARP = 11
    MEMBER_BUTTON_EXPEL = 12
    MEMBER_BUTTON_PATH = "d:/ymir work/ui/game/windows/"
    MEMBER_BUTTON_IMAGE_FILE_NAME_DICT = {
        player.PARTY_STATE_LEADER: "party_state_leader",
        player.PARTY_STATE_ATTACKER: "party_state_attacker",
        player.PARTY_STATE_BERSERKER: "party_state_berserker",
        player.PARTY_STATE_TANKER: "party_state_tanker",
        player.PARTY_STATE_DEFENDER: "party_state_defender",
        player.PARTY_STATE_BUFFER: "party_state_buffer",
        player.PARTY_STATE_SKILL_MASTER: "party_state_skill_master",
        MEMBER_BUTTON_NORMAL: "party_state_normal",
        MEMBER_BUTTON_WARP: "party_skill_warp",
        MEMBER_BUTTON_EXPEL: "party_expel",
    }

    STATE_NAME_DICT = {
        player.PARTY_STATE_ATTACKER: locale.PARTY_SET_ATTACKER,
        player.PARTY_STATE_BERSERKER: locale.PARTY_SET_BERSERKER,
        player.PARTY_STATE_TANKER: locale.PARTY_SET_TANKER,
        player.PARTY_STATE_DEFENDER: locale.PARTY_SET_DEFENDER,
        player.PARTY_STATE_BUFFER: locale.PARTY_SET_BUFFER,
        player.PARTY_STATE_SKILL_MASTER: locale.PARTY_SET_SKILL_MASTER,
    }

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

        self.pid = None
        self.vid = None
        self.partyAffectImageList = []
        self.stateButtonDict = {}
        self.affectValueDict = {}
        self.state = -1
        self.isShowStateButton = FALSE

        self.__LoadBoard()
        self.__CreateAffectToolTip()
        self.__CreateStateButton()
        self.Show()

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

        print " =============================== DESTROIED PartyMemberInfoBoard"

    def __LoadBoard(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            if locale.IsJAPAN():
                pyScrLoader.LoadScriptFile(
                    self, uiScriptLocale.LOCALE_UISCRIPT_PATH +
                    "PartyMemberInfoBoard.py")
            else:
                pyScrLoader.LoadScriptFile(self,
                                           "UIScript/PartyMemberInfoBoard.py")
        except:
            import exception
            exception.Abort("PartyMemberInfoBoard.__LoadBoard.LoadScript")

        try:
            self.nameTextLine = self.GetChild("NamePrint")
            self.gauge = self.GetChild("Gauge")
            self.stateButton = self.GetChild("StateButton")
            self.partyAffectImageList.append(self.GetChild("ExperienceImage"))
            self.partyAffectImageList.append(self.GetChild("AttackerImage"))
            self.partyAffectImageList.append(self.GetChild("DefenderImage"))
            self.partyAffectImageList.append(self.GetChild("BufferImage"))
            self.partyAffectImageList.append(self.GetChild("SkillMasterImage"))
            self.partyAffectImageList.append(self.GetChild("TimeBonusImage"))
            self.partyAffectImageList.append(self.GetChild("RegenBonus"))
            self.partyAffectImageList.append(self.GetChild("IncreaseArea150"))
            self.partyAffectImageList.append(self.GetChild("IncreaseArea200"))
            self.stateButton.SetEvent(
                ui.__mem_func__(self.OnMouseLeftButtonDown))
        except:
            import exception
            exception.Abort("PartyMemberInfoBoard.__LoadBoard.BindObject")

        self.__SetAffectsMouseEvent()
        self.__HideAllAffects()

    def Destroy(self):
        self.ClearDictionary()
        self.nameTextLine = None
        self.gauge = None
        self.stateButton = None
        self.partyAffectImageList = []
        self.stateButtonDict = {}

        self.leaderButton = None
        self.attackerButton = None
        self.tankerButton = None

        self.Hide()

    def __SetAffectsMouseEvent(self):
        for i in xrange(len(self.partyAffectImageList)):
            self.partyAffectImageList[
                i].OnMouseOverIn = lambda selfArg=self, index=i: selfArg.OnAffectOverIn(
                    index)
        for i in xrange(len(self.partyAffectImageList)):
            self.partyAffectImageList[
                i].OnMouseOverOut = lambda selfArg=self, index=i: selfArg.OnAffectOverOut(
                    index)

    def __HideAllAffects(self):
        for img in self.partyAffectImageList:
            img.Hide()

    def __CreateAffectToolTip(self):
        affectToolTip = uiToolTip.ToolTip(220)
        affectToolTip.Hide()
        self.affectToolTip = affectToolTip

    def __CreateStateButton(self):
        for key, name in self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT.items():
            if key == player.PARTY_STATE_LEADER:
                continue
            button = ui.Button()
            button.SetUpVisual(self.MEMBER_BUTTON_PATH + name + "_01.sub")
            button.SetOverVisual(self.MEMBER_BUTTON_PATH + name + "_02.sub")
            button.SetDownVisual(self.MEMBER_BUTTON_PATH + name + "_03.sub")
            button.Hide()
            self.stateButtonDict[key] = button

        for state, name in self.STATE_NAME_DICT.items():
            button = self.stateButtonDict[state]
            button.SetToolTipText(name)
            button.SetEvent(ui.__mem_func__(self.OnSelectState), state)

        self.stateButtonDict[self.MEMBER_BUTTON_NORMAL].SetEvent(
            ui.__mem_func__(self.OnSelectState), -1)
        self.stateButtonDict[self.MEMBER_BUTTON_NORMAL].SetToolTipText(
            locale.PARTY_SET_NORMAL)
        self.stateButtonDict[self.MEMBER_BUTTON_WARP].SetEvent(
            ui.__mem_func__(self.OnWarp))
        self.stateButtonDict[self.MEMBER_BUTTON_WARP].SetToolTipText(
            locale.PARTY_RECALL_MEMBER)
        self.stateButtonDict[self.MEMBER_BUTTON_EXPEL].SetToolTipText(
            locale.TARGET_BUTTON_EXCLUDE)
        self.stateButtonDict[self.MEMBER_BUTTON_EXPEL].SetEvent(
            ui.__mem_func__(self.OnExpel))

    def __GetPartySkillLevel(self):
        slotIndex = player.GetSkillSlotIndex(player.SKILL_INDEX_TONGSOL)
        skillGrade = player.GetSkillGrade(slotIndex)
        skillLevel = player.GetSkillLevel(slotIndex)
        return skillLevel + skillGrade * 20

    def __AppendStateButton(self, x, y, state):
        if state == self.state:
            button = self.stateButtonDict[self.MEMBER_BUTTON_NORMAL]
        else:
            button = self.stateButtonDict[state]

        button.SetPosition(x, y)
        button.Show()

    def __ShowStateButton(self):
        self.isShowStateButton = TRUE

        (x, y) = self.GetGlobalPosition()
        xPos = x + 110

        skillLevel = self.__GetPartySkillLevel()

        ## Tanker
        if skillLevel >= 10:
            self.__AppendStateButton(xPos, y, player.PARTY_STATE_ATTACKER)
            xPos += 23

        ## Attacker
        if skillLevel >= 20:
            self.__AppendStateButton(xPos, y, player.PARTY_STATE_BERSERKER)
            xPos += 23

        ## Tanker
        if skillLevel >= 20:
            self.__AppendStateButton(xPos, y, player.PARTY_STATE_TANKER)
            xPos += 23

        ## Buffer
        if skillLevel >= 25:
            self.__AppendStateButton(xPos, y, player.PARTY_STATE_BUFFER)
            xPos += 23

        ## Skill Master
        if skillLevel >= 35:
            self.__AppendStateButton(xPos, y, player.PARTY_STATE_SKILL_MASTER)
            xPos += 23

        ## Defender
        if skillLevel >= 40:
            self.__AppendStateButton(xPos, y, player.PARTY_STATE_DEFENDER)
            xPos += 23

        ## Warp
        #if skillLevel >= 35:
        #	if self.stateButtonDict.has_key(self.MEMBER_BUTTON_WARP):
        #		button = self.stateButtonDict[self.MEMBER_BUTTON_WARP]
        #		button.SetPosition(xPos, y)
        #		button.Show()
        #		xPos += 23

        ## Expel
        if self.stateButtonDict.has_key(self.MEMBER_BUTTON_EXPEL):
            button = self.stateButtonDict[self.MEMBER_BUTTON_EXPEL]
            button.SetPosition(xPos, y)
            button.Show()
            xPos += 23

    def __HideStateButton(self):
        self.isShowStateButton = FALSE
        for button in self.stateButtonDict.values():
            button.Hide()

    def __GetAffectNumber(self, img):
        for i in xrange(self.partyAffectImageList):
            if img == self.partyAffectImageList[i]:
                return i

        return -1

    def SetCharacterName(self, name):
        self.nameTextLine.SetText(name)

    def GetCharacterName(self):
        return self.nameTextLine.GetText()

    def SetCharacterPID(self, pid):
        self.pid = pid

    def SetCharacterVID(self, vid):
        self.vid = vid

    def GetCharacterPID(self):
        return self.pid

    def GetCharacterVID(self):
        return self.vid

    def SetCharacterHP(self, hpPercentage):
        hpPercentage = max(0, hpPercentage)
        self.gauge.SetPercentage(hpPercentage, 100)

    def SetCharacterState(self, state):

        if self.state == state:
            return

        self.state = state
        self.stateButton.Show()

        name = self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT[
            self.MEMBER_BUTTON_NORMAL]
        if self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT.has_key(state):
            name = self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT[state]

        self.stateButton.SetUpVisual(self.MEMBER_BUTTON_PATH + name +
                                     "_01.sub")
        self.stateButton.SetOverVisual(self.MEMBER_BUTTON_PATH + name +
                                       "_02.sub")
        self.stateButton.SetDownVisual(self.MEMBER_BUTTON_PATH + name +
                                       "_03.sub")

    def SetAffect(self, affectSlotIndex, affectValue):

        if affectSlotIndex >= len(self.partyAffectImageList):
            return

        if affectValue > 0:
            self.partyAffectImageList[affectSlotIndex].Show()
        else:
            self.partyAffectImageList[affectSlotIndex].Hide()

        self.affectValueDict[affectSlotIndex] = affectValue

    def Link(self):
        self.nameTextLine.SetPackedFontColor(self.LINK_COLOR)
        self.gauge.Show()

    def Unlink(self):
        self.vid = None
        self.nameTextLine.SetPackedFontColor(self.UNLINK_COLOR)
        self.gauge.Hide()
        self.__HideAllAffects()

    def OnSelectState(self, state):

        self.__HideStateButton()
        if state <= 0:
            net.SendPartySetStatePacket(self.pid, self.state, FALSE)

        else:

            if self.state <= 0:
                net.SendPartySetStatePacket(self.pid, state, TRUE)

            else:
                net.SendPartySetStatePacket(self.pid, self.state, FALSE)
                net.SendPartySetStatePacket(self.pid, state, TRUE)

    def OnWarp(self):
        self.__HideStateButton()

        if self.vid:
            net.SendPartyUseSkillPacket(self.PARTY_SKILL_WARP, self.vid)

    def OnExpel(self):
        self.__HideStateButton()

        if not self.pid:
            return
        net.SendPartyRemovePacket(self.pid)

    def OnMouseLeftButtonDown(self):

        if self.vid:
            player.SetTarget(self.vid)
            player.OpenCharacterMenu(self.vid)

            if mouseModule.mouseController.isAttached():
                attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber(
                )
                net.SendExchangeStartPacket(self.vid)
                net.SendExchangeItemAddPacket(attachedSlotPos, 0)
                mouseModule.mouseController.DeattachObject()
                return

        if player.IsPartyLeader(player.GetMainCharacterIndex()):
            if player.PARTY_STATE_LEADER != self.state:

                if self.isShowStateButton:
                    self.__HideStateButton()

                else:
                    self.__ShowStateButton()

    def OnMouseLeftButtonUp(self):

        if self.vid:
            player.SetTarget(self.vid)
            player.OpenCharacterMenu(self.vid)

            if mouseModule.mouseController.isAttached():
                attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber(
                )
                net.SendExchangeStartPacket(self.vid)
                net.SendExchangeItemAddPacket(attachedSlotPos, 0)
                mouseModule.mouseController.DeattachObject()

    def OnMouseRightButtonDown(self):
        self.OnMouseLeftButtonDown()

    def OnAffectOverIn(self, index):

        if not self.AFFECT_STRING_DICT.has_key(index):
            return
        if not self.affectValueDict.has_key(index):
            return

        (x, y) = self.GetGlobalPosition()

        self.affectToolTip.ClearToolTip()
        self.affectToolTip.SetTitle(self.AFFECT_STRING_DICT[index](
            self.affectValueDict[index]))
        self.affectToolTip.SetToolTipPosition(x + index * 12, y + 11)
        self.affectToolTip.ShowToolTip()

    def OnAffectOverOut(self, index):
        self.affectToolTip.HideToolTip()
Exemplo n.º 4
0
        "PASERR3": locale.LOGIN_FAILURE_PASERR3,
        "PASERR4": locale.LOGIN_FAILURE_PASERR4,
        "PASERR5": locale.LOGIN_FAILURE_PASERR5,
    }

elif locale.IsYMIR() or locale.IsCHEONMA():
    FULL_BACK_IMAGE = TRUE

elif locale.IsHONGKONG():
    FULL_BACK_IMAGE = TRUE
    RUNUP_MATRIX_AUTH = TRUE
    PASSPOD_MSG_DICT = {
        "NOTELE": locale.LOGIN_FAILURE_NOTELEBLOCK,
    }

elif locale.IsJAPAN():
    FULL_BACK_IMAGE = TRUE


def IsFullBackImage():
    global FULL_BACK_IMAGE
    return FULL_BACK_IMAGE


def IsLoginDelay():
    global LOGIN_DELAY_SEC
    if LOGIN_DELAY_SEC > 0.0:
        return TRUE
    else:
        return FALSE
Exemplo n.º 5
0
import player
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder  # 개인상점 열동안 ItemMove 방지
import locale
import constInfo
import ime
import uiToolTip

if locale.IsEUROPE() and app.GetLocalePath() != "locale/sg" or locale.IsYMIR(
) or locale.IsJAPAN():
    ITEM_MALL_BUTTON_ENABLE = TRUE
else:
    ITEM_MALL_BUTTON_ENABLE = FALSE

ITEM_FLAG_APPLICABLE = 1 << 14

COSTUME_START_INDEX = 109
COSTUME_SLOT_COUNT = 3


class CostumeWindow(ui.ScriptWindow):
    def __init__(self, wndInventory):
        import exception

        #if not app.ENABLE_COSTUME_SYSTEM:
Exemplo n.º 6
0
    def RefreshCharacter(self):

        if self.isLoaded == 0:
            return

        ## Name
        try:
            characterName = player.GetName()
            guildName = player.GetGuildName()
            self.characterNameValue.SetText(characterName)
            self.guildNameValue.SetText(guildName)
            if not guildName:
                if locale.IsARABIC():
                    self.characterNameSlot.SetPosition(190, 34)
                else:
                    self.characterNameSlot.SetPosition(109, 34)

                self.guildNameSlot.Hide()
            else:
                if locale.IsJAPAN():
                    self.characterNameSlot.SetPosition(143, 34)
                else:
                    self.characterNameSlot.SetPosition(153, 34)
                self.guildNameSlot.Show()
        except:
            import exception
            exception.Abort("CharacterWindow.RefreshCharacter.BindObject")

        race = net.GetMainActorRace()
        group = net.GetMainActorSkillGroup()
        empire = net.GetMainActorEmpire()

        ## Job Text
        job = chr.RaceToJob(race)
        self.__SetJobText(job, group)

        ## FaceImage
        try:
            faceImageName = FACE_IMAGE_DICT[race]

            try:
                self.faceImage.LoadImage(faceImageName)
            except:
                print "CharacterWindow.RefreshCharacter(race=%d, faceImageName=%s)" % (
                    race, faceImageName)
                self.faceImage.Hide()

        except KeyError:
            self.faceImage.Hide()

        ## GroupName
        self.__SetSkillGroupName(race, group)

        ## Skill
        if 0 == group:
            self.__SelectSkillGroup(0)

        else:
            self.__SetSkillSlotData(race, group, empire)

            if self.__CanUseHorseSkill():
                self.__SelectSkillGroup(0)
Exemplo n.º 7
0
	def Open(self):
		print "OPEN LOADING WINDOW -------------------------------------------------------------------------------"

		#app.HideCursor()

		try:
			pyScrLoader = ui.PythonScriptLoader()
			
			if locale.IsYMIR() or locale.IsWE_KOREA() or locale.IsCANADA() or locale.IsBRAZIL() or locale.IsEUROPE():
				pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "LoadingWindow.py")
			else:			
				pyScrLoader.LoadScriptFile(self, "UIScript/LoadingWindow.py")
		except:
			import exception
			exception.Abort("LodingWindow.Open - LoadScriptFile Error")

		try:
			self.loadingImage=self.GetChild("BackGround")
			self.errMsg=self.GetChild("ErrorMessage")
			self.loadingGage=self.GetChild("FullGage")
		except:
			import exception
			exception.Abort("LodingWindow.Open - LoadScriptFile Error")

		self.errMsg.Hide()

		if locale.IsHONGKONG():
			imgFileNameDict = {
				0 : app.GetLocalePath() + "/ui/loading/loading0.sub",
				1 : app.GetLocalePath() + "/ui/loading/loading1.sub",
				2 : app.GetLocalePath() + "/ui/loading/loading2.sub",
				3 : app.GetLocalePath() + "/ui/loading/loading3.sub",
				4 : app.GetLocalePath() + "/ui/loading/loading4.sub",
				5 : app.GetLocalePath() + "/ui/loading/loading5.sub",
				6 : app.GetLocalePath() + "/ui/loading/loading6.sub"
			}
		elif locale.IsCIBN10():
			imgFileNameDict = {
				0 : app.GetLocalePath() + "/ui/loading/loading0.jpg",
				1 : app.GetLocalePath() + "/ui/loading/loading1.jpg",
				2 : app.GetLocalePath() + "/ui/loading/loading2.jpg",
				3 : app.GetLocalePath() + "/ui/loading/loading3.jpg",
				4 : app.GetLocalePath() + "/ui/loading/loading4.jpg",
				5 : app.GetLocalePath() + "/ui/loading/loading5.jpg",
				6 : app.GetLocalePath() + "/ui/loading/loading6.jpg",
				7 : app.GetLocalePath() + "/ui/loading/loading7.jpg",
			}
		elif locale.IsYMIR() or locale.IsWE_KOREA() or locale.IsCANADA() or locale.IsBRAZIL() or locale.IsEUROPE() or locale.IsJAPAN():
			imgFileNameDict = {
				0 : uiScriptLocale.LOCALE_UISCRIPT_PATH + "loading/loading0.sub",
				1 : uiScriptLocale.LOCALE_UISCRIPT_PATH + "loading/loading1.sub",
				2 : uiScriptLocale.LOCALE_UISCRIPT_PATH + "loading/loading2.sub",
				3 : uiScriptLocale.LOCALE_UISCRIPT_PATH + "loading/loading3.sub",

			}
		elif constInfo.SUB2_LOADING_ENABLE:
			imgFileNameDict = {
				0 : "d:/ymir work/uiloading/background_loading_warrior.sub",
				1 : "d:/ymir work/uiloading/background_loading_assassin.sub",
				2 : "d:/ymir work/uiloading/background_loading_shaman.sub",
				3 : "d:/ymir work/uiloading/background_loading_sura.sub",
				4 : "d:/ymir work/uiloading/background_loading_assassin2.sub",
				5 : "d:/ymir work/uiloading/background_loading_sura2.sub",
				6 : "d:/ymir work/uiloading/background_loading_assassin3.sub",
				7 : "d:/ymir work/uiloading/background_loading_assassin3.sub",
			}
		else:
			imgFileNameDict = {
				0 : "d:/ymir work/ui/intro/pattern/background_loading_warrior.jpg",
				1 : "d:/ymir work/ui/intro/pattern/background_loading_assassin.jpg",
				2 : "d:/ymir work/ui/intro/pattern/background_loading_shaman.jpg",
			}

		try:
			imgFileName = imgFileNameDict[app.GetRandom(0, len(imgFileNameDict) - 1)]
			self.loadingImage.LoadImage(imgFileName)

		except:
			print "LoadingWindow.Open.LoadImage - %s File Load Error" % (imgFileName)
			self.loadingImage.Hide()


		width = float(wndMgr.GetScreenWidth()) / float(self.loadingImage.GetWidth())
		height = float(wndMgr.GetScreenHeight()) / float(self.loadingImage.GetHeight())

		self.loadingImage.SetScale(width, height)
		self.loadingGage.SetPercentage(2, 100)

		self.Show()

		chrSlot=self.stream.GetCharacterSlot()
		net.SendSelectCharacterPacket(chrSlot)

		app.SetFrameSkip(0)