import app
import grp
import wndMgr
import ui
import os
import sys
import stat
import chrmgr
import chr
import net
import background
import snd
import net
import player
import locale
import uiScriptLocale

class Console(object):
	def __init__(self, output):
		self.dirNameList = []
		self.fileNameList = []

		self.output = output		
		self.curPathName = "D:\\Ymir Work\\"
		self.collision = 0

		self.bgPartDict = {
			"terrain":background.PART_TERRAIN,
			"object":background.PART_OBJECT,
			"cloud":background.PART_CLOUD,
			"tree":background.PART_TREE,
			"water":background.PART_WATER,
			"sky":background.PART_SKY,
		}

		self.bgSortDict = {
			"distance":background.DISTANCE_SORT,
			"texture":background.TEXTURE_SORT,
		}

		self.game = 0

	def Close(self):
		self.output = 0

	def BindGameClass(self, game):
		self.game = game

	def Exit(self):
		"Exit Program"
		app.Exit()

	def EnablePerformanceTime(self, mode, isEnable):
		app.EnablePerformanceTime(mode, int(isEnable))

	def ReloadLocale(self):
		"Reload Locale"
		reload(locale)
		reload(uiScriptLocale)
		self.Print("RELOAD LOCALE")

	def ReloadDevel(self):
		"ReloadDevel"
		import consoleModule
		import uiGuild
		import uiInventory
		reload(uiGuild)
		self.Print("ReloadGuild")
		reload(uiInventory)
		self.Print("ReloadInventory")

	def ShowPerformanceInfo(self):
		"Shows Performance Info"
		self.Print(app.GetInfo(app.INFO_ACTOR))
		self.Print(app.GetInfo(app.INFO_ITEM))
		self.Print(app.GetInfo(app.INFO_EFFECT))
		self.Print(app.GetInfo(app.INFO_TEXTTAIL))

	def Disconnect(self):
		"Disconnect by sending unknown packet"
		net.SendStrangePacket()

	def ToggleActorDirectionLine(self):
		"Shows character's direction line"
		chrmgr.ToggleDirectionLine()

	def RegisterCharacterEffect(self, effectType, effectFileName):
		"Set character's effect state (state number, bone name, effect filename/number)"
		if effectFileName.isdigit():
			effectFileName = self.GetFileName(int(effectFileName))

		effectFullPathFileName = self.GetFullPathName(effectFileName)
		chrmgr.RegisterEffect(chrmgr.EFFECT_STATE+int(effectType), "", effectFullPathFileName)
		self.Print("effect state %d: %s" % (int(effectType), effectFullPathFileName))

	def SetCharacterAffect(self, affectType, isVisible):
		"Set character's affect (number, visiblity 1|0)"
		chrmgr.SetAffect(-1, int(affectType), int(isVisible))
		self.Print("affect set %d: %d" % (int(affectType), int(isVisible)))

	def SetCharacterEmoticon(self, EmoticonNum):
		"Show emoticon (number)"
		chrmgr.SetEmoticon(-1, int(EmoticonNum))
		self.Print("Emoticon %d: %d" % (int(EmoticonNum), int(isVisible)))

	def ShowPickedCharacterInfo(self):
		"Show information of picked character"
		vid=chrmgr.GetPickedVID()
		info=chrmgr.GetVIDInfo(vid)
		self.Print(info)

	def ShowCharacterInfo(self, arg):
		"Show information of character (vid)"
		if arg.isdigit():
			vid=int(arg)
		else:
			vid=0

		info=chrmgr.GetVIDInfo(vid)
		self.Print(info)

	def SetWeaponTraceTexture(self, arg):
		"Sets sword afterimage texture (filename)"
		if arg.isdigit():
			textureFileName = self.GetFileName(int(arg))
		else:
			textureFileName = arg

		chr.WeaponTraceSetTexture(textureFileName)

	def SetAutoCameraRotationSpeed(self, arg):
		"Auto camera rotation speed (angle per sec)"
		spd=float(arg)
		player.SetAutoCameraRotationSpeed(spd)

		self.Print("Auto camera rotation speed: %f" % (spd))

	def SetWeaponTraceMode(self, *mode):
		"Sword afterimage mode (0 = Use alpha, 1 = Use texture)"
		if mode and mode[0].isdigit() and int(mode[0]):
			chr.WeaponTraceUseTexture()
		else:
			chr.WeaponTraceUseAlpha()

	def SetCollision(self, *mode):
		"Show collison objects (0 | 1)"
		if mode and mode[0].isdigit():
			self.collision = int(mode[0])
		else:
			self.collision = not self.collision 	

	def SetMovingSpeed(self, arg):
		"Set walking speed"
		chrmgr.SetMovingSpeed(int(arg))

	def SetMusicVolume(self, arg):
		"Set BGM volumn (0 ~ 1.0)"
		snd.SetMusicVolume(float(arg))

	def SetSoundVolume(self, arg):
		"Set Effect sound volumn (0 ~ 5)"
		snd.SetSoundVolume(int(arg))

	def SetSoundScale(self, arg):
		"3D Sound scale (default : 200)"
		snd.SetSoundScale(int(arg))

	def SetAmbienceSoundScale(self, arg):
		"3D Ambience sound scale (default : 200)"
		snd.SetAmbienceSoundScale(int(arg))

	def SetCoolTime(self):
		"Cooltime toggle"
		flag = player.ToggleCoolTime()
		if flag:
			self.Print("Cooltime will be applied")
		else:
			self.Print("Cooltime disabled")

	def SetLevelLimit(self):
		"Sets Level limit"
		flag = player.ToggleLevelLimit()
		if flag:
			self.Print("Level limit will be applied")
		else:
			self.Print("Level limit disabled")

	def ShowCursor(self):
		app.ShowCursor()

	def HideCursor(self):
		app.HideCursor()

	def Print(self, msg):
		self.output.Print(msg)

	def RefreshPath(self):
		self.SetPath(self.curPathName)

	def	SetPath(self, newPathName):
		if '\\'!=newPathName[-1]:
			newPathName=newPathName+'\\'

		if os.access(newPathName, os.R_OK)==0:
			self.Print(newPathName+" Cannot find path")
			return

		nameList=os.listdir(newPathName)

		dirNameList=[]
		fileNameList=[]
		for sName in nameList:
			mode=os.stat(newPathName+sName)[stat.ST_MODE]
			if stat.S_ISDIR(mode):
				dirNameList.append(sName)
			else:
				fileNameList.append(sName)

		self.curPathName=newPathName
		self.dirNameList=dirNameList
		self.fileNameList=fileNameList

		self.ShowPath()

	def GetPath(self):
		return self.curPathName

	def GetDirName(self, iDir):
		if (len(self.dirNameList)>iDir):
			return self.dirNameList[iDir]
		else:
			print len(self.dirNameList)
			return ""

	def GetFileName(self, iFile):	
		if (len(self.fileNameList)>iFile):
			return self.fileNameList[iFile]
		else:
			print len(self.fileNameList)
			return ""

	def	MoveParentPath(self):
		"Go to Parent directory"
		newPathName=self.GetPath()

		lastPos=-1
		if '\\'==newPathName[-1]:
			lastPos=-2

		lastPos=newPathName.rfind('\\', 0,	lastPos)
		if 0>lastPos:
			self.Print("Here is root")
			return

		newPathName=newPathName[0:lastPos]+'\\'

		self.SetPath(newPathName)

	def GetFullPathName(self, sPathName):
		sParentPathName=self.GetPath()

		if '\\'!=sParentPathName[-1]:
			sParentPathName=sParentPathName+'\\'

		return sParentPathName+sPathName

	def	MoveChildPath(self, directory):
		"[Directory name/number] change to child directory"
		if ""==directory:
			self.Print("You need directory name or number")
			return

		if directory.isdigit():
			directory=self.GetDirName(int(directory))

		newPathName=self.GetFullPathName(directory)

		self.SetPath(newPathName)

	def SetHitEffect(self, arg):
		"Sets hit effect"
		if arg.isdigit():
			effectFileName = self.GetFileName(int(arg))
		else:
			effectFileName = arg

		effectFullPathFileName=self.GetFullPathName(EffectFileName)
		chrmgr.RegisterEffect(chrmgr.EFFECT_HIT, "", effectFullPathFileName)

		self.Print("Hit effect: "+effectFullPathFileName)

	def SetStunEffect(self, arg):
		"Sets stun effect"
		if arg.isdigit():
			effectFileName = self.GetFileName(int(arg))
		else:
			effectFileName = arg

		effectFullPathFileName = self.GetFullPathName(effectFileName)
		chrmgr.RegisterEffect(chrmgr.EFFECT_STUN, "Bip01 Head", effectFullPathFileName)

		self.Print("Stun effect: "+effectFullPathFileName)

	def SetDustEffect(self, arg):
		"Sets dirt effect"
		if arg.isdigit():
			effectFileName = self.GetFileName(int(arg))
		else:
			effectFileName = arg

		effectFullPathFileName = self.GetFullPathName(effectFileName)
		chrmgr.RegisterEffect(chrmgr.EFFECT_DUST, "", effectFullPathFileName)

		self.Print("Dirt effect: "+effectFullPathFileName)

	def SetDustGap(self, arg):
		"Sets dirt effect gap"
		if arg.isdigit() == 0:
			self.Print("Dirt effect gap argument must be a number")
		else:
			gap = int(arg)
			chrmgr.SetDustGap(gap)
			self.Print("Dirt effect gap: %d" % (gap))

	def ShowBackgroundPart(self, arg):
		"Show background part"
		try:
			background.SetVisiblePart(self.bgPartDict[arg], 1);
		except KeyError:
			self.Print("Unknown part: ", arg);
		except:
			raise
		
	def HideBackgroundPart(self, arg):
		"Hide background part"
		try:
			background.SetVisiblePart(self.bgPartDict[arg], 0);
		except KeyError:
			self.Print("Unknown part: ", arg);
		except:
			raise

	def SetShadowLevel(self, arg):
		"Shadow level setting (0~5)"
		if arg.isdigit() == 0:
			self.Print("Shadow setting must be a number")
		else:
			level = int(arg)

			if level < 0 or level > 5:
				self.Print("Shadow level range is 0~5")
			else:
				background.SetShadowLevel(level)
				self.Print("Shadow level: %d" % (level))

	def SetSplatLimit(self, arg):
		"Splat number limit"
		if arg.isdigit() == 0:
			self.Print("Splat number limit must be a number")
		else:
			limit = int(arg)

			background.SetSplatLimit(limit)
			self.Print("Splat number limit: %d" % (limit))

	def SelectViewDistanceNum(self, arg):
		"View distance (0~4)"
		if arg.isdigit() == 0:
			self.Print("Enter between 0 to 4")
		else:
			settingnum = int(arg)

			if settingnum < 0 or settingnum > 4:
				self.Print("View distance range is 0 to 4")

			else:
				background.SelectViewDistanceNum(settingnum)
				self.Print("View distance: %d" % (settingnum))

	def SetBGLoading(self, bBGLoading):
		"Background loading (0, 1)"
		bResultBoolean = int(bBGLoading)

		if bResultBoolean != 0 and bResultBoolean != 1:
			self.Print("Enter 0 or 1")
		else:
			background.SetBGLoading(bResultBoolean)
			self.Print("Background loading: %d" % (bResultBoolean))

	def SetTerrainRenderSort(self, arg):
		"Terrain rendering type"
		try:
			background.SetRenderSort(self.bgSortDict[arg]);
		except KeyError:
			self.Print("Unknown part: ", arg);
		except:
			raise

	def SetTransparentTree(self, arg):
		"Tree's leaf transparency"
		bTransparent = int(arg)
		try:
			background.SetTransparentTree(bTransparent);
		except KeyError:
			self.Print("must be 0 or 1: ", bTransparent);
		except:
			raise

	def WarpTest(self, warpX, warpY):
		"WarpTest : warp dwX dwY"
		iWarpX = int(warpX)
		iWarpY = int(warpY)
		try:
			background.Destroy()
			background.Initialize()
			background.WarpTest(iWarpX, iWarpY);
			background.RegisterEnvironmentData(0, "d:/ymir work/environment/b3.msenv")
			background.SetEnvironmentData(0)
			background.SetShadowLevel(background.SHADOW_ALL)
		except:
			import exception
			exception.Abort("consoleModule.Console.WarpTest")

	def ToggleDebugInfo(self):
		"Show DebugInfo"
		net.ToggleGameDebugInfo()
		
	def ShowPath(self):
		"Show current path"
		self.Print("Current path is "+self.GetPath())

	def	ShowList(self):	
		"Show current path's list"
		self.ShowDirList()
		self.ShowFileList()

	def	ShowDirList(self):
		"Show current path's child directories"
		self.Print(self.GetPath()+" directories:")
		self.ShowNameList(self.dirNameList)
		self.Print("")

	def	ShowFileList(self, Filter=[]):
		"Show current path's files (extension filter)"
		self.Print(self.GetPath()+" files:")
		self.ShowNameList(self.fileNameList, Filter)
		self.Print("")

	def	ShowEffectList(self):
		"Show current path's effect"
		self.Print(self.GetPath()+" effects:")
		self.ShowNameList(self.fileNameList, ["mse"])
		self.Print("")

	def ShowWeb(self):
		"ShowWeb"
		if app.IsWebPageMode():
			app.HideWebPage()
		else:
			app.ShowWebPage("http://wiki.metin.co.kr/metin1help/01.htm", (0, 0, 320, 600))

	def ShowUI(self):
		"Shows UI"
		self.game.CheckGameButton()
		self.game.interface.ShowDefaultWindows()
		self.game.interface.wndChat.Show()

	def HideUI(self):
		"Hides UI"
		self.game.interface.HideAllWindows()
		self.game.interface.wndChat.Hide()

	def SetCameraSpeed(self, percentage):
		"Sets camera speed (Default = 100)"
		app.SetCameraSpeed(int(percentage))

	def SaveCameraSetting(self, filename):
		"Save current camera attributes (filename)"
		app.SaveCameraSetting(filename)

	def LoadCameraSetting(self, filename):
		"Load camera attributes (filename)"
		if not app.LoadCameraSetting(filename):
			self.Print("Could not load camera attribute")

	def SetDefaultCamera(self):
		"Return to default camera attribute"
		app.SetDefaultCamera()

	def ShowClock(self, second):
		self.game.ShowClock(int(second))

	def HideClock(self):
		self.game.HideClock()

	def ShowNotice(self):
		app.SetVisibleNotice(TRUE)
		self.Print("Show Notice")

	def HideNotice(self):
		app.SetVisibleNotice(FALSE)
		self.Print("Hide Notice")

	def SetSight(self, range):
		"Set Force Sight Range"
		app.SetSightRange(int(range))

	def SetComboType(self, type):
		chr.testSetComboType(int(type))

	def SetSkillGroupFake(self, index):
		"""Å×½ºÆ® ÄÚµå"""
		net.SetSkillGroupFake(int(index))
		self.Print(" SetSkillGroupFake : %d" % int(index))

	def SetEmpireLanguageMode(self, mode):
		net.SetEmpireLanguageMode(int(mode))
		self.Print(" SetEmpireLanguageMode : %d" % int(mode))

	def SetCharacterRenderModeTypeAdd(self, color):
		vid = player.GetTargetVID()
		print " -> SetCharacterRenderModeTypeAdd", vid, color
		chr.testSetAddRenderMode(vid, int(color,16))

	def SetCharacterRenderModeTypeMod(self, color):
		vid = player.GetTargetVID()
		print " -> SetCharacterRenderModeTypeMod", vid, color, int(color,16)
		chr.testSetModulateRenderMode(vid, int(color,16))

	def SetCharacterRenderModeTypeAddRGB(self, r, g, b):
		vid = player.GetTargetVID()
		print " -> SetCharacterRenderModeTypeAddRGB", vid, r, g, b
		chr.testSetAddRenderModeRGB(vid, float(r)/255.0, float(g)/255.0, float(b)/255.0)

	def SetCharacterRenderModeTypeModRGB(self, r, g, b):
		vid = player.GetTargetVID()
		print " -> SetCharacterRenderModeTypeModRGB", vid, r, g, b
		chr.testSetModulateRenderModeRGB(vid, float(r)/255.0, float(g)/255.0, float(b)/255.0)

	def SetCharacterRenderModeSpecular(self, alpha):
		vid = player.GetTargetVID()
		print " -> SetCharacterRenderModeSpecular", vid, alpha
		chr.testSetSpecularRenderMode(vid, float(alpha))

	def RestoreCharacterRenderModeType(self):
		vid = player.GetTargetVID()
		chr.testRestoreRenderMode(vid)


	def	ShowNameList(self, lstsName, lstsFilter=None):
		if len(lstsName)==0:
			self.Print("None")
			return

		if lstsFilter:
			isFilter=1
		else:
			isFilter=0

		sLine=""
		iCol=0

		iName=0
		for sName in lstsName:
			if isFilter:
				iDotPos=sName.rfind('.', 0, -1)
				if iDotPos<0:
					iName=iName+1
					continue

				if (sName[iDotPos+1:] in lstsFilter)==0:
					iName=iName+1
					continue

			sLine=sLine+"%3d %-15s " % (iName, sName)

			if iCol>4:
				iCol=0
				self.Print(sLine)
				sLine=""

			iCol=iCol+1

			iName=iName+1

		if ""!=sLine:
			self.Print(sLine)

class ConsoleWindow(ui.Window):

	BACK_GROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
	EDIT_LINE_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
	BUTTON_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
	HEIGHT = 200
	LINE_STEP = 15
	MAX_LINE_COUNT = 50

	class ConsoleEditLine(ui.EditLine):
		def __init__(self):
			ui.EditLine.__init__(self)
			self.eventReturn = 0
			self.eventEscape = 0
		def __del__(self):
			ui.EditLine.__del__(self)

		def SetReturnEvent(self, event):
			self.eventReturn = event

		def SetEscapeEvent(self, event):
			self.eventEscape = event

		def OnIMEReturn(self):
			text = self.GetText()

			if len(text) > 0:
				self.eventReturn(text)

			else:
				wndMgr.KillFocus()
				self.eventEscape()

			self.SetText("")
			return TRUE

		def OnPressEscapeKey(self):
			self.SetText("")
			wndMgr.KillFocus()
			self.eventEscape()
			return TRUE

	class ResizingButton(ui.DragButton):

		BUTTON_NORMAL_COLOR = grp.GenerateColor(0.3320, 0.2929, 0.2578, 1.0)
		BUTTON_OVER_COLOR = grp.GenerateColor(0.5320, 0.4929, 0.4578, 1.0)
		BUTTON_LIGHT_OUTLINE_COLOR = grp.GenerateColor(0.6666, 0.6509, 0.6313, 1.0)
		BUTTON_DARK_OUTLINE_COLOR = grp.GenerateColor(0.1647, 0.1450, 0.1294, 1.0)

		def __init__(self):
			ui.DragButton.__init__(self)
			self.AddFlag("limit")
			self.AddFlag("restrict_x")

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

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

		self.TextList = []
		self.game = 0
		self.Console = Console(self)

		self.ResizingButton = self.ResizingButton()
		self.ResizingButton.SetParent(self)
		self.ResizingButton.SetSize(15, 15)
		self.ResizingButton.SetPosition(100, 100)
		self.ResizingButton.Show()

		self.EditLine = self.ConsoleEditLine()
		self.EditLine.SetParent(self)
		self.EditLine.SetMax(100)
		self.EditLine.SetFontName(locale.UI_DEF_FONT)
		self.EditLine.SetText("")
		self.EditLine.Show()

		from _weakref import ref

		self.ResizingButton.SetMoveEvent(lambda s = ref(self): s().UpdatePosition())
		self.EditLine.SetReturnEvent(lambda x,s = ref(self): s().ProcessCommand(x))
		self.EditLine.SetEscapeEvent(lambda s = ref(self): s().CloseWindow())

		self.UpdatePosition()

		self.functionDict = {}
		self.InitFunction()

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

	def BindGameClass(self, game):
		self.Console.BindGameClass(game)

	def Close(self):
		self.Console.Close()
		self.ResizingButton = 0
		self.EditLine = 0

	def SetConsoleSize(self, width, height):
		self.ResizingButton.SetPosition(width-20, height-20)
		self.UpdatePosition()

	def OnRender(self):
		grp.SetColor(self.BACK_GROUND_COLOR)
		grp.RenderBar(self.gx, self.gy, self.width, self.height)
	
		grp.SetColor(ConsoleWindow.EDIT_LINE_COLOR)
		grp.RenderBar(self.gxEditLine-2, self.gyEditLine-3, self.width - 40, 17)

		grp.SetColor(ConsoleWindow.BUTTON_COLOR)
		grp.RenderBar(self.gxButton-2, self.gyButton-3, self.widthButton, self.heightButton)

	def UpdatePosition(self):

		self.width = self.GetWidth()
		self.height = self.GetHeight()
		self.widthButton = self.ResizingButton.GetWidth()
		self.heightButton = self.ResizingButton.GetHeight()
		(self.gx, self.gy) = self.GetGlobalPosition()
		(self.gxButton, self.gyButton) = self.ResizingButton.GetGlobalPosition()

		self.SetSize(self.gxButton - self.gx + 20, self.gyButton - self.gy + 20)

		self.EditLine.SetSize(self.width-30, 16)
		self.EditLine.SetPosition(7, self.height-20)
		(self.gxEditLine, self.gyEditLine) = self.EditLine.GetGlobalPosition()

		#####

		yPosition = (self.height-20) - self.LINE_STEP
		ItemCount = len(self.TextList)

		for i in xrange(ItemCount):
			TextLine = self.TextList[ItemCount-i-1]

			TextLine.SetPosition(10, yPosition)
			yPosition -= self.LINE_STEP

			if yPosition < 0:
				TextLine.Hide()
			else:
				TextLine.Show()

	def OpenWindow(self):

		self.EditLine.SetFocus()

		self.Show()
		self.Console.RefreshPath()

	def CloseWindow(self):
		self.Hide()

	## NOTE : ÀÌ°÷¿¡¼­ Command¸¦ ó¸®ÇÕ´Ï´Ù - [levites]
	def ProcessCommand(self, text):

		if '/' == text[0]:
			net.SendChatPacket(text)
			return

		Console=self.Console
		Console.Print(">> "+text)

		lstsArg=text.split()
		if len(lstsArg)==0:
			return

		sCmd=lstsArg[0]

		if self.functionDict.has_key(sCmd):
			try:
				self.functionDict[sCmd](self.Console, *lstsArg[1:])
			except Exception, e:
				Console.Print(str(e))
				#self.Console.Print(e)
				#self.Console.Print(self.functionDict[sCmd].__doc__)
		else:
			if sCmd == 'help' or sCmd == 'h':
				try:
					k = lstsArg[1]
					v = self.functionDict[k]
					argcount = v.im_func.func_code.co_argcount - 1 # -1 for self
					if v.im_func.func_code.co_flags & 4:
						argcount+=1
					argnames = v.im_func.func_code.co_varnames[1:argcount+1]
					if argcount:
						Console.Print("%s(%s) : %s" % (k,argcount, v.__doc__))
						Console.Print("   arg : %s" % argnames)
					else:
						Console.Print("%s : %s" % (k,v.__doc__))
				except:
					for k,v in self.functionDict.iteritems():
						argcount = v.im_func.func_code.co_argcount - 1 # -1 for self
						if v.im_func.func_code.co_flags & 4:
							argcount+=1
						if argcount:
							Console.Print("%s(%s) : %s" % (k,argcount, v.__doc__))
						else:
							Console.Print("%s : %s" % (k,v.__doc__))
					Console.Print("? : All commands list")
					Console.Print("h : Help for all commands")
					Console.Print("h blah : Help for blah")

				Console.Print("")
			elif sCmd == '?':
				list = self.functionDict.keys()
				list.sort()
				Console.ShowNameList(list)
			pass

	def InitFunction(self):
		#self.AddFunction("help",		Console.PrintHelp)
		#self.AddFunction("?",			Console.PrintHelp)

		self.AddFunction("exit",		Console.Exit)
		self.AddFunction("mvol",		Console.SetMusicVolume)
		self.AddFunction("svol",		Console.SetSoundVolume)
		self.AddFunction("snds",		Console.SetSoundScale)
		self.AddFunction("asnds",		Console.SetAmbienceSoundScale)
		self.AddFunction("mspd",		Console.SetMovingSpeed)
		self.AddFunction("pwd",			Console.ShowPath)
		self.AddFunction("ls", 			Console.ShowList)
		self.AddFunction("shadow",		Console.SetShadowLevel)
		self.AddFunction("splat",		Console.SetSplatLimit)
		self.AddFunction("distance", 	Console.SelectViewDistanceNum)
		self.AddFunction("bgloading",	Console.SetBGLoading)
		self.AddFunction("terrainrender",	Console.SetTerrainRenderSort)
		self.AddFunction("transtree",		Console.SetTransparentTree)
		self.AddFunction("stune",		Console.SetStunEffect)
		self.AddFunction("duste",		Console.SetDustEffect)
		self.AddFunction("dustt",		Console.SetDustGap)
		self.AddFunction("hite",		Console.SetHitEffect)
		self.AddFunction("cd",			Console.MoveChildPath)
		self.AddFunction("up",			Console.MoveParentPath)
		self.AddFunction("lsd",			Console.ShowDirList)
		self.AddFunction("lsf",			Console.ShowFileList)
		self.AddFunction("lse",			Console.ShowEffectList)
		self.AddFunction("show",		Console.ShowBackgroundPart)
		self.AddFunction("hide",		Console.HideBackgroundPart)
		self.AddFunction("debuginfo",	Console.ToggleDebugInfo)

		self.AddFunction("collision",	Console.SetCollision)
		self.AddFunction("colli",	Console.SetCollision)

		#self.AddFunction("wt",	Console.SetWeaponTrace)
		self.AddFunction("wtt",	Console.SetWeaponTraceTexture)
		self.AddFunction("wtm",	Console.SetWeaponTraceMode)

		self.AddFunction("disconnect",	Console.Disconnect)
		self.AddFunction("autorot", Console.SetAutoCameraRotationSpeed)

		self.AddFunction("dirline", Console.ToggleActorDirectionLine)
		self.AddFunction("pickc", Console.ShowPickedCharacterInfo)
		self.AddFunction("infoc", Console.ShowCharacterInfo)
		self.AddFunction("regchre", Console.RegisterCharacterEffect)
		self.AddFunction("setchra", Console.SetCharacterAffect)
		self.AddFunction("emoticon", Console.SetCharacterEmoticon)
		self.AddFunction("perfinfo", Console.ShowPerformanceInfo)
		self.AddFunction("reload_locale", Console.ReloadLocale)
		self.AddFunction("re", Console.ReloadDevel)
		self.AddFunction("perftime", Console.EnablePerformanceTime)
		self.AddFunction("cooltime", Console.SetCoolTime)
		self.AddFunction("levellimit", Console.SetLevelLimit)
		self.AddFunction("showcursor", Console.ShowCursor)
		self.AddFunction("hidecursor", Console.HideCursor)

		self.AddFunction("warp", Console.WarpTest)
		self.AddFunction("web", Console.ShowWeb)

		self.AddFunction("showui", Console.ShowUI)
		self.AddFunction("hideui", Console.HideUI)

		self.AddFunction("setcspd", Console.SetCameraSpeed)
		self.AddFunction("savecmr", Console.SaveCameraSetting)
		self.AddFunction("loadcmr", Console.LoadCameraSetting)
		self.AddFunction("setdefcmr", Console.SetDefaultCamera)

		self.AddFunction("showclock", Console.ShowClock)
		self.AddFunction("hideclock", Console.HideClock)

		self.AddFunction("setsight", Console.SetSight)

		self.AddFunction("setcombotype", Console.SetComboType)
		self.AddFunction("setsk_fake", Console.SetSkillGroupFake)

		self.AddFunction("trans", Console.SetEmpireLanguageMode)

		self.AddFunction("shownotice", Console.ShowNotice)
		self.AddFunction("hidenotice", Console.HideNotice)

		self.AddFunction("setrmadd", Console.SetCharacterRenderModeTypeAdd)
		self.AddFunction("setrmmod", Console.SetCharacterRenderModeTypeMod)
		self.AddFunction("setrmaddrgb", Console.SetCharacterRenderModeTypeAddRGB)
		self.AddFunction("setrmmodrgb", Console.SetCharacterRenderModeTypeModRGB)
		self.AddFunction("setspec", Console.SetCharacterRenderModeSpecular)
		self.AddFunction("restorerm", Console.RestoreCharacterRenderModeType)
	
	def AddFunction(self, cmd, func):
		self.functionDict[cmd] = func

	def Print(self, text):
		TextLine = ui.TextLine()
		TextLine.SetParent(self)
		TextLine.SetFontName(locale.UI_DEF_FONT)
		TextLine.Show()
		TextLine.SetText(text)
		self.TextList.append(TextLine)

		count = len(self.TextList)
		if count > self.MAX_LINE_COUNT:
			for i in xrange(count - self.MAX_LINE_COUNT):
				del self.TextList[0]

		self.UpdatePosition()