846 lines
28 KiB
Python
846 lines
28 KiB
Python
import ui
|
|
import chr
|
|
import grp
|
|
import app
|
|
import net
|
|
import snd
|
|
import math
|
|
import event
|
|
import wndMgr
|
|
import uiToolTip
|
|
import constInfo
|
|
import musicInfo
|
|
import localeInfo
|
|
import networkModule
|
|
import systemSetting
|
|
import uiScriptLocale
|
|
import playerSettingModule
|
|
|
|
MAN = 0
|
|
WOMAN = 1
|
|
SHAPE0 = 0
|
|
SHAPE1 = 1
|
|
PAGE_COUNT = 2
|
|
SLOT_COUNT = 5
|
|
BASE_CHR_ID = 3
|
|
LOCALE_PATH = "uiscript/"+uiScriptLocale.CODEPAGE+"_"
|
|
|
|
class CreateCharacterWindow(ui.Window):
|
|
CREATE_STAT_POINT = 0
|
|
|
|
STAT_CON = 0
|
|
STAT_INT = 1
|
|
STAT_STR = 2
|
|
STAT_DEX = 3
|
|
START_STAT = (
|
|
[4, 3, 6, 3,],
|
|
[3, 3, 4, 6,],
|
|
[3, 5, 5, 3,],
|
|
[4, 6, 3, 3,],
|
|
[6, 2, 6, 2,],
|
|
)
|
|
|
|
EMPIRE_NAME = {
|
|
net.EMPIRE_A : localeInfo.EMPIRE_A,
|
|
#net.EMPIRE_B : localeInfo.EMPIRE_B,
|
|
net.EMPIRE_C : localeInfo.EMPIRE_C
|
|
}
|
|
|
|
STAT_DESCRIPTION = {
|
|
STAT_CON : localeInfo.STAT_TOOLTIP_CON,
|
|
STAT_INT : localeInfo.STAT_TOOLTIP_INT,
|
|
STAT_STR : localeInfo.STAT_TOOLTIP_STR,
|
|
STAT_DEX : localeInfo.STAT_TOOLTIP_DEX,
|
|
}
|
|
|
|
DESCRIPTION_FILE_NAME = (
|
|
uiScriptLocale.JOBDESC_WARRIOR_PATH,
|
|
uiScriptLocale.JOBDESC_ASSASSIN_PATH,
|
|
uiScriptLocale.JOBDESC_SURA_PATH,
|
|
uiScriptLocale.JOBDESC_SHAMAN_PATH,
|
|
uiScriptLocale.JOBDESC_WOLFMAN_PATH,
|
|
)
|
|
|
|
RACE_DECT = {
|
|
0 : playerSettingModule.RACE_WARRIOR_M,
|
|
1 : playerSettingModule.RACE_ASSASSIN_M,
|
|
2 : playerSettingModule.RACE_SURA_M,
|
|
3 : playerSettingModule.RACE_SHAMAN_M,
|
|
4 : playerSettingModule.RACE_WOLFMAN_M,
|
|
5 : playerSettingModule.RACE_WARRIOR_W,
|
|
6 : playerSettingModule.RACE_ASSASSIN_W,
|
|
7 : playerSettingModule.RACE_SURA_W,
|
|
8 : playerSettingModule.RACE_SHAMAN_W,
|
|
9 : playerSettingModule.RACE_WOLFMAN_M,
|
|
}
|
|
|
|
FACE_IMAGE_DICT = {
|
|
0 : "icon/face/warrior_m.tga",
|
|
1 : "icon/face/assassin_m.tga",
|
|
2 : "icon/face/sura_m.tga",
|
|
3 : "icon/face/shaman_m.tga",
|
|
4 : "icon/face/wolf_m.tga",
|
|
5 : "icon/face/warrior_w.tga",
|
|
6 : "icon/face/assassin_w.tga",
|
|
7 : "icon/face/sura_w.tga",
|
|
8 : "icon/face/shaman_w.tga",
|
|
9 : "icon/face/wolf_w.tga",
|
|
}
|
|
|
|
RACE_NAME = {
|
|
0 : localeInfo.JOB_WARRIOR,
|
|
1 : localeInfo.JOB_ASSASSIN,
|
|
2 : localeInfo.JOB_SURA,
|
|
3 : localeInfo.JOB_SHAMAN,
|
|
4 : localeInfo.JOB_WOLFMAN,
|
|
5 : localeInfo.JOB_WARRIOR,
|
|
6 : localeInfo.JOB_ASSASSIN,
|
|
7 : localeInfo.JOB_SURA,
|
|
8 : localeInfo.JOB_SHAMAN,
|
|
9 : localeInfo.JOB_WOLFMAN,
|
|
}
|
|
|
|
class DescriptionBox(ui.Window):
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
self.descIndex = 0
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
def SetIndex(self, index):
|
|
self.descIndex = index
|
|
def OnRender(self):
|
|
event.RenderEventSet(self.descIndex)
|
|
|
|
class CharacterRenderer(ui.Window):
|
|
def OnRender(self):
|
|
grp.ClearDepthBuffer()
|
|
grp.SetGameRenderState()
|
|
grp.PushState()
|
|
grp.SetOmniLight()
|
|
|
|
screenWidth = wndMgr.GetScreenWidth()
|
|
screenHeight = wndMgr.GetScreenHeight()
|
|
newScreenWidth = float(screenWidth - 270)
|
|
newScreenHeight = float(screenHeight)
|
|
grp.SetViewport(270.0/screenWidth, 0.0, newScreenWidth/screenWidth, newScreenHeight/screenHeight)
|
|
|
|
app.SetCenterPosition(0.0, 0.0, 0.0)
|
|
app.SetCamera(1550.0, 15.0, 180.0, 95.0)
|
|
grp.SetPerspective(10.0, newScreenWidth/newScreenHeight, 1000.0, 3000.0)
|
|
|
|
(x, y) = app.GetCursorPosition()
|
|
grp.SetCursorPosition(x, y)
|
|
|
|
chr.Deform()
|
|
chr.Render()
|
|
|
|
grp.RestoreViewport()
|
|
grp.PopState()
|
|
grp.SetInterfaceRenderState()
|
|
|
|
def __init__(self, stream):
|
|
print "NEW CREATE WINDOW ----------------------------------------------------------------------------"
|
|
|
|
ui.Window.__init__(self)
|
|
net.SetPhaseWindow(net.PHASE_WINDOW_CREATE, self)
|
|
self.stream=stream
|
|
|
|
def __del__(self):
|
|
print "---------------------------------------------------------------------------- DELETE CREATE WINDOW"
|
|
|
|
net.SetPhaseWindow(net.PHASE_WINDOW_CREATE, 0)
|
|
ui.Window.__del__(self)
|
|
|
|
def Open(self):
|
|
print "OPEN CREATE WINDOW ----------------------------------------------------------------------------"
|
|
|
|
self.reservingRaceIndex = -1
|
|
self.reservingShapeIndex = -1
|
|
self.reservingStartTime = 0
|
|
self.stat = [0, 0, 0, 0]
|
|
self.slot = 0
|
|
self.gender = 0
|
|
self.shapeList = [[0, 0, 0, 0, 0],[0, 0, 0, 0, 0]]
|
|
self.descIndex = 0
|
|
try:
|
|
dlgBoard = ui.ScriptWindow()
|
|
pythonScriptLoader = ui.PythonScriptLoader()
|
|
pythonScriptLoader.LoadScriptFile(dlgBoard, uiScriptLocale.LOCALE_UISCRIPT_PATH + "createcharacterwindow.py")
|
|
except:
|
|
import exception
|
|
exception.Abort("CreateCharacterWindow.Open.LoadObject")
|
|
|
|
try:
|
|
getChild = dlgBoard.GetChild
|
|
self.backGroundImg1 = getChild("BackGround")
|
|
self.backGroundImg2 = getChild("BackGround2")
|
|
self.backGroundImg2.Hide()
|
|
self.backGroundImg3 = getChild("BackGround3")
|
|
self.backGroundImg3.Hide()
|
|
|
|
self.empireName = getChild("EmpireName")
|
|
self.EmpireFlagA = getChild("EmpireFlag_A")
|
|
self.EmpireFlagB = getChild("EmpireFlag_B")
|
|
self.EmpireFlagC = getChild("EmpireFlag_C")
|
|
|
|
self.CharacterSlot_0 = getChild("WARRIOR")
|
|
self.CharacterFace_0 = getChild("CharacterFace_0")
|
|
self.CharacterSlot_1 = getChild("ASSASSIN")
|
|
self.CharacterFace_1 = getChild("CharacterFace_1")
|
|
self.CharacterSlot_2 = getChild("SURA")
|
|
self.CharacterFace_2 = getChild("CharacterFace_2")
|
|
self.CharacterSlot_3 = getChild("SHAMAN")
|
|
self.CharacterFace_3 = getChild("CharacterFace_3")
|
|
self.CharacterSlot_4 = getChild("WOLF")
|
|
self.CharacterFace_4 = getChild("CharacterFace_4")
|
|
self.DiscFace = getChild("DiscFace")
|
|
self.raceName = getChild("raceName_Text")
|
|
|
|
self.NameList = []
|
|
self.NameList.append(getChild("name_warrior"))
|
|
self.NameList.append(getChild("name_assassin"))
|
|
self.NameList.append(getChild("name_sura"))
|
|
self.NameList.append(getChild("name_shaman"))
|
|
self.NameList.append(getChild("name_wolf"))
|
|
|
|
self.GaugeList = []
|
|
self.GaugeList.append(getChild("hth_gauge"))
|
|
self.GaugeList.append(getChild("int_gauge"))
|
|
self.GaugeList.append(getChild("str_gauge"))
|
|
self.GaugeList.append(getChild("dex_gauge"))
|
|
|
|
self.btnCreate = getChild("create_button")
|
|
self.btnCancel = getChild("cancel_button")
|
|
self.btnPrev = getChild("prev_button")
|
|
self.btnNext = getChild("next_button")
|
|
self.textBoard = getChild("text_board")
|
|
|
|
self.genderButtonList = []
|
|
self.genderButtonList.append(getChild("gender_button_01"))
|
|
self.genderButtonList.append(getChild("gender_button_02"))
|
|
|
|
self.shapeButtonList = []
|
|
self.shapeButtonList.append(getChild("shape_button_01"))
|
|
self.shapeButtonList.append(getChild("shape_button_02"))
|
|
|
|
self.editCharacterName = getChild("character_name_value")
|
|
|
|
self.statValue = []
|
|
self.statValue.append(getChild("hth_value"))
|
|
self.statValue.append(getChild("int_value"))
|
|
self.statValue.append(getChild("str_value"))
|
|
self.statValue.append(getChild("dex_value"))
|
|
|
|
getChild("hth_slot").ShowToolTip = lambda arg=self.STAT_CON: self.OverInStatButton(arg)
|
|
getChild("hth_slot").HideToolTip = lambda arg=self.STAT_CON: self.OverOutStatButton()
|
|
getChild("int_slot").ShowToolTip = lambda arg=self.STAT_INT: self.OverInStatButton(arg)
|
|
getChild("int_slot").HideToolTip = lambda arg=self.STAT_INT: self.OverOutStatButton()
|
|
getChild("str_slot").ShowToolTip = lambda arg=self.STAT_STR: self.OverInStatButton(arg)
|
|
getChild("str_slot").HideToolTip = lambda arg=self.STAT_STR: self.OverOutStatButton()
|
|
getChild("dex_slot").ShowToolTip = lambda arg=self.STAT_DEX: self.OverInStatButton(arg)
|
|
getChild("dex_slot").HideToolTip = lambda arg=self.STAT_DEX: self.OverOutStatButton()
|
|
getChild("hth_slot").Hide()
|
|
getChild("int_slot").Hide()
|
|
getChild("str_slot").Hide()
|
|
getChild("dex_slot").Hide()
|
|
|
|
self.genderButtonList[0].ShowToolTip = lambda arg=1: self.OverInButton(arg)
|
|
self.genderButtonList[0].HideToolTip = lambda arg=1: self.OverOutButton()
|
|
self.genderButtonList[1].ShowToolTip = lambda arg=2: self.OverInButton(arg)
|
|
self.genderButtonList[1].HideToolTip = lambda arg=2: self.OverOutButton()
|
|
self.shapeButtonList[0].ShowToolTip = lambda arg=3: self.OverInButton(arg)
|
|
self.shapeButtonList[0].HideToolTip = lambda arg=3: self.OverOutButton()
|
|
self.shapeButtonList[1].ShowToolTip = lambda arg=4: self.OverInButton(arg)
|
|
self.shapeButtonList[1].HideToolTip = lambda arg=4: self.OverOutButton()
|
|
getChild("prev_button").ShowToolTip = lambda arg=5: self.OverInButton(arg)
|
|
getChild("prev_button").HideToolTip = lambda arg=5: self.OverOutButton()
|
|
getChild("next_button").ShowToolTip = lambda arg=6: self.OverInButton(arg)
|
|
getChild("next_button").HideToolTip = lambda arg=6: self.OverOutButton()
|
|
getChild("create_button").ShowToolTip = lambda arg=7: self.OverInButton(arg)
|
|
getChild("create_button").HideToolTip = lambda arg=7: self.OverOutButton()
|
|
getChild("cancel_button").ShowToolTip = lambda arg=8: self.OverInButton(arg)
|
|
getChild("cancel_button").HideToolTip = lambda arg=8: self.OverOutButton()
|
|
getChild("WARRIOR").ShowToolTip = lambda arg=9: self.OverInButton(arg)
|
|
getChild("WARRIOR").HideToolTip = lambda arg=9: self.OverOutButton()
|
|
getChild("ASSASSIN").ShowToolTip = lambda arg=10: self.OverInButton(arg)
|
|
getChild("ASSASSIN").HideToolTip = lambda arg=10: self.OverOutButton()
|
|
getChild("SURA").ShowToolTip = lambda arg=11: self.OverInButton(arg)
|
|
getChild("SURA").HideToolTip = lambda arg=11: self.OverOutButton()
|
|
getChild("SHAMAN").ShowToolTip = lambda arg=12: self.OverInButton(arg)
|
|
getChild("SHAMAN").HideToolTip = lambda arg=12: self.OverOutButton()
|
|
getChild("WOLF").ShowToolTip = lambda arg=13: self.OverInButton(arg)
|
|
getChild("WOLF").HideToolTip = lambda arg=13: self.OverOutButton()
|
|
except:
|
|
import exception
|
|
exception.Abort("CreateCharacterWindow.Open.BindObject")
|
|
|
|
self.CharacterSlot_0.SAFE_SetEvent(self.__SelectSlot, 0)
|
|
self.CharacterSlot_1.SAFE_SetEvent(self.__SelectSlot, 1)
|
|
self.CharacterSlot_2.SAFE_SetEvent(self.__SelectSlot, 2)
|
|
self.CharacterSlot_3.SAFE_SetEvent(self.__SelectSlot, 3)
|
|
self.CharacterSlot_4.SAFE_SetEvent(self.__SelectSlot, 4)
|
|
self.CharacterSlot_4.Hide()
|
|
if constInfo.WOLF_MAN != "DISABLED" and constInfo.WOLF_MAN == "ENABLED":
|
|
self.CharacterSlot_4.Show()
|
|
elif constInfo.WOLF_WOMEN != "DISABLED" and constInfo.WOLF_WOMEN == "ENABLED":
|
|
self.CharacterSlot_4.Show()
|
|
|
|
self.btnCreate.SetEvent(ui.__mem_func__(self.CreateCharacter))
|
|
self.btnCancel.SetEvent(ui.__mem_func__(self.CancelCreate))
|
|
self.btnPrev.SetEvent(ui.__mem_func__(self.PrevDescriptionPage))
|
|
self.btnNext.SetEvent(ui.__mem_func__(self.NextDescriptionPage))
|
|
|
|
self.genderButtonList[0].SetEvent(ui.__mem_func__(self.__SelectGender), MAN)
|
|
self.genderButtonList[1].SetEvent(ui.__mem_func__(self.__SelectGender), WOMAN)
|
|
|
|
self.shapeButtonList[0].SetEvent(ui.__mem_func__(self.__SelectShape), SHAPE0)
|
|
self.shapeButtonList[1].SetEvent(ui.__mem_func__(self.__SelectShape), SHAPE1)
|
|
self.editCharacterName.SetReturnEvent(ui.__mem_func__(self.CreateCharacter))
|
|
self.editCharacterName.SetEscapeEvent(ui.__mem_func__(self.CancelCreate))
|
|
self.dlgBoard = dlgBoard
|
|
|
|
self.curNameAlpha = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
|
|
self.destNameAlpha = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
|
|
self.curGauge = [0.0, 0.0, 0.0, 0.0]
|
|
self.destGauge = [0.0, 0.0, 0.0, 0.0]
|
|
|
|
self.descriptionBox = self.DescriptionBox()
|
|
self.descriptionBox.Show()
|
|
|
|
self.toolTip = uiToolTip.ToolTip()
|
|
self.toolTip.ClearToolTip()
|
|
|
|
self.editCharacterName.SetText("")
|
|
|
|
self.EnableWindow()
|
|
|
|
app.SetCamera(500.0, 10.0, 180.0, 95.0)
|
|
|
|
self.__SelectSlot(0)
|
|
|
|
self.dlgBoard.Show()
|
|
self.Show()
|
|
|
|
if musicInfo.createMusic != "":
|
|
snd.SetMusicVolume(systemSetting.GetMusicVolume())
|
|
snd.FadeInMusic("BGM/"+musicInfo.createMusic)
|
|
|
|
empire_w = 0
|
|
if net.GetEmpireID() == 2:
|
|
empire_w = 3
|
|
else:
|
|
empire_w = net.GetEmpireID()
|
|
|
|
self.SetEmpire(empire_w)
|
|
app.ShowCursor()
|
|
|
|
def Close(self):
|
|
print "---------------------------------------------------------------------------- CLOSE CREATE WINDOW"
|
|
|
|
self.editCharacterName.Enable()
|
|
self.dlgBoard.ClearDictionary()
|
|
self.stream = 0
|
|
self.shapeButtonList = []
|
|
self.genderButtonList = []
|
|
self.btnCreate = 0
|
|
self.btnCancel = 0
|
|
self.btnPrev = 0
|
|
self.btnNext = 0
|
|
self.textBoard = 0
|
|
self.editCharacterName = 0
|
|
self.backGroundImg1 = None
|
|
self.backGroundImg2 = None
|
|
self.backGroundImg3 = None
|
|
self.EmpireFlagA = None
|
|
self.EmpireFlagB = None
|
|
self.EmpireFlagC = None
|
|
if musicInfo.createMusic != "":
|
|
snd.FadeOutMusic("BGM/"+musicInfo.createMusic)
|
|
|
|
for id in xrange(BASE_CHR_ID + SLOT_COUNT * PAGE_COUNT):
|
|
chr.DeleteInstance(id)
|
|
|
|
self.dlgBoard.Hide()
|
|
self.Hide()
|
|
|
|
app.HideCursor()
|
|
event.Destroy()
|
|
|
|
def SetEmpire(self, id):
|
|
self.empireName.SetText(self.EMPIRE_NAME.get(id, ""))
|
|
if id == 1:
|
|
self.empireName.SetFontColor(1.0, 0, 0)
|
|
self.EmpireFlagA.Show()
|
|
self.EmpireFlagB.Hide()
|
|
self.EmpireFlagC.Hide()
|
|
self.BackGround = self.backGroundImg1
|
|
self.backGroundImg1.Show()
|
|
self.backGroundImg2.Hide()
|
|
self.backGroundImg3.Hide()
|
|
|
|
self.chrRenderer = self.CharacterRenderer()
|
|
self.chrRenderer.SetParent(self.backGroundImg1)
|
|
self.chrRenderer.Show()
|
|
elif id == 2:
|
|
self.empireName.SetFontColor(1.0, 1.0, 0.0)
|
|
self.EmpireFlagA.Hide()
|
|
self.EmpireFlagB.Show()
|
|
self.EmpireFlagC.Hide()
|
|
self.BackGround = self.backGroundImg2
|
|
self.backGroundImg1.Hide()
|
|
self.backGroundImg2.Show()
|
|
self.backGroundImg3.Hide()
|
|
|
|
self.chrRenderer = self.CharacterRenderer()
|
|
self.chrRenderer.SetParent(self.backGroundImg2)
|
|
self.chrRenderer.Show()
|
|
elif id == 3:
|
|
self.empireName.SetFontColor(0.0, 0, 1.0)
|
|
self.EmpireFlagA.Hide()
|
|
self.EmpireFlagB.Hide()
|
|
self.EmpireFlagC.Show()
|
|
self.BackGround = self.backGroundImg3
|
|
self.backGroundImg1.Hide()
|
|
self.backGroundImg2.Hide()
|
|
self.backGroundImg3.Show()
|
|
|
|
self.chrRenderer = self.CharacterRenderer()
|
|
self.chrRenderer.SetParent(self.backGroundImg3)
|
|
self.chrRenderer.Show()
|
|
|
|
def EnableWindow(self):
|
|
self.reservingRaceIndex = -1
|
|
self.reservingShapeIndex = -1
|
|
self.btnCreate.Enable()
|
|
self.btnCancel.Enable()
|
|
self.btnPrev.Enable()
|
|
self.btnNext.Enable()
|
|
self.editCharacterName.SetFocus()
|
|
self.editCharacterName.Enable()
|
|
for page in xrange(PAGE_COUNT):
|
|
if page == 2 and constInfo.WOLF_WOMEN != "DISABLED" and constInfo.WOLF_WOMEN == "ENABLED":
|
|
SLOT_COUNT_TWO = 5
|
|
else:
|
|
if constInfo.WOLF_MAN != "DISABLED" and constInfo.WOLF_MAN == "ENABLED":
|
|
SLOT_COUNT_TWO = 5
|
|
else:
|
|
SLOT_COUNT_TWO = 4
|
|
|
|
for slot in xrange(SLOT_COUNT_TWO):
|
|
chr_id = self.__GetSlotChrID(page, slot)
|
|
chr.SelectInstance(chr_id)
|
|
chr.BlendLoopMotion(chr.MOTION_INTRO_WAIT, 0.1)
|
|
|
|
def DisableWindow(self):
|
|
self.btnCreate.Disable()
|
|
self.btnCancel.Disable()
|
|
self.btnPrev.Disable()
|
|
self.btnNext.Disable()
|
|
self.editCharacterName.Disable()
|
|
self.btnCreate.SetUp()
|
|
|
|
def __GetSlotChrID(self, gender, slot):
|
|
return self.RACE_DECT[gender + slot]
|
|
|
|
def __MakeCharacter(self, race):
|
|
chr_id = self.__GetSlotChrID(self.gender, self.slot)
|
|
chr.CreateInstance(chr_id)
|
|
chr.SelectInstance(chr_id)
|
|
chr.SetVirtualID(chr_id)
|
|
chr.SetRace(chr_id)
|
|
chr.SetArmor(0)
|
|
chr.SetHair(0)
|
|
chr.Refresh()
|
|
chr.SetMotionMode(chr.MOTION_MODE_GENERAL)
|
|
chr.SetLoopMotion(chr.MOTION_INTRO_WAIT)
|
|
chr.SetRotation(0.0)
|
|
|
|
distance = 50.0
|
|
rotRadian = 82.0 * (math.pi*2) / 360.0
|
|
x = distance*math.sin(rotRadian) + distance*math.cos(rotRadian)
|
|
y = distance*math.cos(rotRadian) - distance*math.sin(rotRadian)
|
|
chr.SetPixelPosition(int(x), int(y), 30)
|
|
chr.Hide()
|
|
|
|
def __SelectGender(self, gender):
|
|
slot = self.slot
|
|
if constInfo.WOLF_WOMEN != "ENABLED" and constInfo.WOLF_WOMEN == "DISABLED" and slot == 4 and gender == 1:
|
|
for button in self.genderButtonList:
|
|
button.Down()
|
|
|
|
self.genderButtonList[gender].SetUp()
|
|
return
|
|
elif constInfo.WOLF_MAN != "ENABLED" and constInfo.WOLF_MAN == "DISABLED" and slot == 4 and gender == 0:
|
|
for button in self.genderButtonList:
|
|
button.Down()
|
|
|
|
self.genderButtonList[gender].SetUp()
|
|
return
|
|
|
|
for button in self.genderButtonList:
|
|
button.SetUp()
|
|
|
|
self.genderButtonList[gender].Down()
|
|
self.gender = gender
|
|
if gender == 0 and self.slot > 4:
|
|
slot = self.slot - 4
|
|
elif gender == 1 and self.slot < 4:
|
|
slot = self.slot + 4
|
|
if gender == 1 and self.slot > 8:
|
|
slot = self.slot - 4
|
|
|
|
for i in xrange(9):
|
|
chr.DeleteInstance(i)
|
|
|
|
chr_id = self.__GetSlotChrID(self.gender, slot)
|
|
chr.CreateInstance(chr_id)
|
|
chr.SelectInstance(chr_id)
|
|
chr.SetVirtualID(chr_id)
|
|
chr.SetRace(chr_id)
|
|
chr.SetArmor(0)
|
|
chr.SetHair(0)
|
|
chr.Refresh()
|
|
chr.SetMotionMode(chr.MOTION_MODE_GENERAL)
|
|
chr.SetLoopMotion(chr.MOTION_INTRO_WAIT)
|
|
chr.SetRotation(0.0)
|
|
|
|
distance = 50.0
|
|
rotRadian = 82.0 * (math.pi*2) / 360.0
|
|
x = distance*math.sin(rotRadian) + distance*math.cos(rotRadian)
|
|
y = distance*math.cos(rotRadian) - distance*math.sin(rotRadian)
|
|
chr.SetPixelPosition(int(x), int(y), 30)
|
|
chr.Show()
|
|
|
|
def __SelectShape(self, shape):
|
|
self.shapeList[self.gender][self.slot] = shape
|
|
for button in self.shapeButtonList:
|
|
button.SetUp()
|
|
|
|
self.shapeButtonList[shape].Down()
|
|
chr_id = self.__GetSlotChrID(self.gender, self.slot)
|
|
chr.SelectInstance(chr_id)
|
|
chr.ChangeShape(shape)
|
|
chr.SetMotionMode(chr.MOTION_MODE_GENERAL)
|
|
chr.SetLoopMotion(chr.MOTION_INTRO_WAIT)
|
|
|
|
def GetSlotIndex(self):
|
|
return self.slot
|
|
|
|
def RefreshStat(self):
|
|
statSummary = self.stat[0] + self.stat[1] + self.stat[2] + self.stat[3]
|
|
self.destGauge = (
|
|
float(self.stat[0])/float(statSummary),
|
|
float(self.stat[1])/float(statSummary),
|
|
float(self.stat[2])/float(statSummary),
|
|
float(self.stat[3])/float(statSummary),
|
|
)
|
|
|
|
for i in xrange(4):
|
|
self.statValue[i].SetText(str(self.stat[i]))
|
|
|
|
def __SelectSlot(self, slot):
|
|
self.slot = slot
|
|
self.ResetStat()
|
|
|
|
for i in xrange(9):
|
|
chr.DeleteInstance(i)
|
|
|
|
self.genderButtonList[0].Show()
|
|
self.genderButtonList[1].Show()
|
|
self.DiscFace.LoadImage(self.FACE_IMAGE_DICT[slot])
|
|
self.DiscFace.Show()
|
|
self.raceName.SetText(self.RACE_NAME[slot])
|
|
self.raceName.Show()
|
|
if slot == 0:
|
|
self.CharacterSlot_0.Down()
|
|
self.CharacterSlot_1.SetUp()
|
|
self.CharacterSlot_2.SetUp()
|
|
self.CharacterSlot_3.SetUp()
|
|
self.CharacterSlot_4.SetUp()
|
|
elif slot == 1:
|
|
self.CharacterSlot_1.Down()
|
|
self.CharacterSlot_0.SetUp()
|
|
self.CharacterSlot_2.SetUp()
|
|
self.CharacterSlot_3.SetUp()
|
|
self.CharacterSlot_4.SetUp()
|
|
elif slot == 2:
|
|
self.CharacterSlot_2.Down()
|
|
self.CharacterSlot_0.SetUp()
|
|
self.CharacterSlot_1.SetUp()
|
|
self.CharacterSlot_3.SetUp()
|
|
self.CharacterSlot_4.SetUp()
|
|
elif slot == 3:
|
|
self.CharacterSlot_3.Down()
|
|
self.CharacterSlot_0.SetUp()
|
|
self.CharacterSlot_1.SetUp()
|
|
self.CharacterSlot_2.SetUp()
|
|
self.CharacterSlot_4.SetUp()
|
|
elif slot == 4:
|
|
self.CharacterSlot_4.Down()
|
|
self.CharacterSlot_0.SetUp()
|
|
self.CharacterSlot_1.SetUp()
|
|
self.CharacterSlot_2.SetUp()
|
|
self.CharacterSlot_3.SetUp()
|
|
if constInfo.WOLF_MAN != "DISABLED" and constInfo.WOLF_MAN == "ENABLED":
|
|
self.genderButtonList[0].Show()
|
|
else:
|
|
self.genderButtonList[0].Hide()
|
|
|
|
if constInfo.WOLF_WOMEN != "DISABLED" and constInfo.WOLF_WOMEN == "ENABLED":
|
|
self.genderButtonList[1].Show()
|
|
else:
|
|
self.genderButtonList[1].Hide()
|
|
|
|
self.__MakeCharacter(slot)
|
|
self.__SelectGender(0)
|
|
self.__SelectShape(0)
|
|
|
|
event.ClearEventSet(self.descIndex)
|
|
self.descIndex = event.RegisterEventSet(self.DESCRIPTION_FILE_NAME[self.slot])
|
|
if localeInfo.IsARABIC():
|
|
event.SetEventSetWidth(self.descIndex, 170)
|
|
|
|
chr_id = self.__GetSlotChrID(self.gender, slot)
|
|
if chr.HasInstance(chr_id):
|
|
chr.SelectInstance(chr_id)
|
|
self.__SelectShape(self.shapeList[self.gender][slot])
|
|
|
|
def CreateCharacter(self):
|
|
if -1 != self.reservingRaceIndex:
|
|
return
|
|
|
|
textName = self.editCharacterName.GetText()
|
|
if self.__CheckCreateCharacter(textName) == FALSE:
|
|
return
|
|
|
|
if musicInfo.selectMusic != "":
|
|
snd.FadeLimitOutMusic("BGM/"+musicInfo.selectMusic, systemSetting.GetMusicVolume()*0.05)
|
|
|
|
self.DisableWindow()
|
|
chr_id = self.__GetSlotChrID(self.gender, self.slot)
|
|
chr.SelectInstance(chr_id)
|
|
self.reservingRaceIndex = chr.GetRace()
|
|
|
|
print("========================================================")
|
|
print("Race : %d" % (self.reservingRaceIndex))
|
|
print("========================================================")
|
|
|
|
self.reservingShapeIndex = self.shapeList[self.gender][self.slot]
|
|
self.reservingStartTime = app.GetTime()
|
|
for eachSlot in xrange(SLOT_COUNT):
|
|
sel_id = self.__GetSlotChrID(self.gender, eachSlot)
|
|
chr.SelectInstance(sel_id)
|
|
if eachSlot == self.slot:
|
|
chr.PushOnceMotion(chr.MOTION_INTRO_SELECTED)
|
|
else:
|
|
chr.PushOnceMotion(chr.MOTION_INTRO_NOT_SELECTED)
|
|
self.toolTip.Hide()
|
|
|
|
def CancelCreate(self):
|
|
self.stream.SetSelectCharacterPhase()
|
|
|
|
def PrevDescriptionPage(self):
|
|
if event.IsWait(self.descIndex) == TRUE:
|
|
if event.GetVisibleStartLine(self.descIndex)-14 >= 0:
|
|
event.SetVisibleStartLine(self.descIndex, event.GetVisibleStartLine(self.descIndex)-14)
|
|
event.Skip(self.descIndex)
|
|
else:
|
|
event.Skip(self.descIndex)
|
|
|
|
def NextDescriptionPage(self):
|
|
if TRUE == event.IsWait(self.descIndex):
|
|
event.SetVisibleStartLine(self.descIndex, event.GetVisibleStartLine(self.descIndex)+14)
|
|
event.Skip(self.descIndex)
|
|
else:
|
|
event.Skip(self.descIndex)
|
|
|
|
def __CheckCreateCharacter(self, name):
|
|
if len(name) == 0:
|
|
self.PopupMessage(localeInfo.CREATE_INPUT_NAME, self.EnableWindow)
|
|
return FALSE
|
|
elif name.find(localeInfo.CREATE_GM_NAME)!=-1:
|
|
self.PopupMessage(localeInfo.CREATE_ERROR_GM_NAME, self.EnableWindow)
|
|
return FALSE
|
|
elif net.IsInsultIn(name):
|
|
self.PopupMessage(localeInfo.CREATE_ERROR_INSULT_NAME, self.EnableWindow)
|
|
return FALSE
|
|
|
|
return TRUE
|
|
|
|
def ResetStat(self):
|
|
for i in xrange(4):
|
|
self.stat[i] = self.START_STAT[self.slot][i]
|
|
|
|
self.lastStatPoint = self.CREATE_STAT_POINT
|
|
self.RefreshStat()
|
|
|
|
def OnCreateSuccess(self):
|
|
self.stream.SetSelectCharacterPhase()
|
|
|
|
def OnCreateFailure(self, type):
|
|
if type == 1:
|
|
self.PopupMessage(localeInfo.CREATE_EXIST_SAME_NAME, self.EnableWindow)
|
|
else:
|
|
self.PopupMessage(localeInfo.CREATE_FAILURE, self.EnableWindow)
|
|
|
|
def OnUpdate(self):
|
|
chr.Update()
|
|
(xposEventSet, yposEventSet) = self.textBoard.GetGlobalPosition()
|
|
event.UpdateEventSet(self.descIndex, xposEventSet+7, -(yposEventSet+7))
|
|
self.descriptionBox.SetIndex(self.descIndex)
|
|
SLOT_COUNT_TWO = 4
|
|
if constInfo.WOLF_WOMEN != "DISABLED" and constInfo.WOLF_WOMEN == "ENABLED":
|
|
SLOT_COUNT_TWO += 1
|
|
else:
|
|
if constInfo.WOLF_MAN != "DISABLED" and constInfo.WOLF_MAN == "ENABLED":
|
|
SLOT_COUNT_TWO += 1
|
|
|
|
if SLOT_COUNT_TWO > 5:
|
|
SLOT_COUNT_TWO = 5
|
|
|
|
for page in xrange(PAGE_COUNT):
|
|
SLOT_COUNT_RES = 5
|
|
for i in xrange(SLOT_COUNT_RES):
|
|
self.curNameAlpha[i] += (self.destNameAlpha[i] - self.curNameAlpha[i]) / 10.0
|
|
self.NameList[i].SetAlpha(self.curNameAlpha[i])
|
|
|
|
for i in xrange(4):
|
|
self.curGauge[i] += (self.destGauge[i] - self.curGauge[i]) / 10.0
|
|
if abs(self.curGauge[i] - self.destGauge[i]) < 0.005:
|
|
self.curGauge[i] = self.destGauge[i]
|
|
self.GaugeList[i].SetPercentage(self.curGauge[i], 1.0)
|
|
|
|
if -1 != self.reservingRaceIndex:
|
|
if app.GetTime() - self.reservingStartTime >= 1.5:
|
|
chrSlot=self.stream.GetCharacterSlot()
|
|
textName = self.editCharacterName.GetText()
|
|
raceIndex = self.reservingRaceIndex
|
|
shapeIndex = self.reservingShapeIndex
|
|
|
|
startStat = self.START_STAT[self.slot]
|
|
statCon = self.stat[0] - startStat[0]
|
|
statInt = self.stat[1] - startStat[1]
|
|
statStr = self.stat[2] - startStat[2]
|
|
statDex = self.stat[3] - startStat[3]
|
|
|
|
net.SendCreateCharacterPacket(chrSlot, textName, raceIndex, shapeIndex, statCon, statInt, statStr, statDex)
|
|
self.reservingRaceIndex = -1
|
|
|
|
def EmptyFunc(self):
|
|
pass
|
|
|
|
def PopupMessage(self, msg, func=0):
|
|
if not func:
|
|
func=self.EmptyFunc
|
|
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(msg, func, localeInfo.UI_OK)
|
|
|
|
def OnPressExitKey(self):
|
|
self.CancelCreate()
|
|
return TRUE
|
|
|
|
def OverInStatButton(self, stat):
|
|
if not self.STAT_DESCRIPTION.has_key(stat):
|
|
return
|
|
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AppendTextLine(self.STAT_DESCRIPTION[stat])
|
|
self.toolTip.Show()
|
|
|
|
def OverOutStatButton(self):
|
|
self.toolTip.Hide()
|
|
|
|
def OverInButton(self, stat):
|
|
if stat == 1:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.CHARACTER_CREATE_MALE, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 2:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.CHARACTER_CREATE_FEMALE, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 3:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.CHARACTER_CREATE_APPEARANCE1, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 4:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.CHARACTER_CREATE_APPEARANCE2, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 5:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(uiScriptLocale.CREATE_PREV, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 6:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(uiScriptLocale.CREATE_NEXT, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 7:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(uiScriptLocale.CREATE_CREATE, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 8:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(uiScriptLocale.CANCEL, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 9:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.JOB_WARRIOR, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 10:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.JOB_ASSASSIN, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 11:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.JOB_SURA, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 12:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.JOB_SHAMAN, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
elif stat == 13:
|
|
self.toolTip.ClearToolTip()
|
|
self.toolTip.AlignHorizonalCenter()
|
|
self.toolTip.AutoAppendNewTextLine(localeInfo.JOB_WOLFMAN, grp.GenerateColor(1.0, 1.0, 0.0, 1.0))
|
|
self.toolTip.Show()
|
|
|
|
def OverOutButton(self):
|
|
self.toolTip.Hide()
|
|
|
|
if __name__ == "__main__":
|
|
|
|
import app
|
|
import wndMgr
|
|
import systemSetting
|
|
import mouseModule
|
|
import networkModule
|
|
|
|
app.SetMouseHandler(mouseModule.mouseController)
|
|
app.SetHairColorEnable(TRUE)
|
|
wndMgr.SetMouseHandler(mouseModule.mouseController)
|
|
wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
|
|
app.Create(localeInfo.APP_TITLE, systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
|
|
mouseModule.mouseController.Create()
|
|
|
|
mainStream = networkModule.MainStream()
|
|
mainStream.Create()
|
|
|
|
test = CreateCharacterWindow(mainStream)
|
|
test.Open()
|
|
|
|
app.Loop()
|