#!/usr/bin/python
# -*- coding: GBK -*-
#
#
##@package CommFunc.py
# @todo: ¹«¹²µ÷Óú¯Êý¼¯
# @author:eggxp
# @date 2010-01-01 00:00
# @version 1.8
#
# ÐÞ¸Äʱ¼ä ÐÞ¸ÄÈË ÐÞ¸ÄÄÚÈÝ
# @change: "2010-01-19 16:35"  zb  Ð޸Ĺ«¹²º¯ÊýµÄÒ»¸ö´íÎó,½â¾öСÀ®°ÈÊäÈë'²'×ֻᵼÖ¿ͻ§¶Ëµ¯¿òµÄÎÊÌâ
# @change: "2010-01-29 11:45"  chenxuewei  Ð޸Ĺ«¹²º¯ÊýReplaceBig5AppointSign(srcStr,sign,desSign)µÄÒ»¸ö´íÎó,½â¾ö×Ö·û´®srcStr×îºóÒ»¸ö×Ö½ÚµÄ×Ö·ûÌæ»»ÎÊÌâ
# @change: "2010-04-02 17:45"  zb  Ìí¼Ó¹«¹²º¯ÊýToDWORD()
# @change: "2010-04-02 20:30"  zb  ½«ReadBYTE()/ReadDWORD()/ReadDWORD(),¸Ä³ÉÎÞ·ûºÅÊý¶ÁÈ¡
# @change: "2010-09-27 15:55"  chenxuewei  ½«WriteBYTE()/WriteDWORD()/WriteDWORD(),¸Ä³É×Ô¶¯×ª»¯ÓÐÎÞ·ûºÅÊýдÈë
# @change: "2011-06-27 17:20" yyz ÒÆÖ²µ½Server¶Ë
# @change: "2013-01-18 18:45" hyx Ôö¼Ó»ñÈ¡×Ö·û´®CRC32µÄº¯Êý
# @change: "2014-12-15 11:00" hxp Ôö¼ÓÐÔÄÜ·ÖÎö×°ÊÎÆ÷º¯Êý
#
#---------------------------------------------------------------------
#µ¼Èë
import os
import struct
import string
import math
import datetime
import subprocess
import binascii
import GameWorld
#---------------------------------------------------------------------
#È«¾Ö±äÁ¿

MODULE_NAME = "cmd_mail"

VER = "2014-12-15 11:00"


## ÓÃÓÚ·¢°ü£¬µ±·â°üÊÇDWORDµÄʱºò
#  @param num Êý×Ö
#  @return ÓзûºÅÊý×Ö
#  @remarks º¯ÊýÏêϸ˵Ã÷£ºÓÃÓÚ·¢°ü£¬µ±·â°üÊÇDWORDµÄʱºò£¬×ª»»ÎªÓзûºÅÊý
def ToDWORD( num ):
    if num >= 0:
        return num
    return num + 4294967296

## ½«hexת»¯³É¶þ½øÖƶÔÓ¦µÄ×Ö·û´®£¬ÓÃÓÚ·¢°ü
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º½«hexת»¯³É¶þ½øÖƶÔÓ¦µÄ×Ö·û´®£¬ÓÃÓÚ·¢°ü
def HexToBin (hexStr):
    returnStr = ''
    hexStrLen = len(hexStr)
    for i in [j for j in range(hexStrLen) if j%2==0]:
        returnStr += chr(string.atoi(hexStr[i:i+2],16))
    return returnStr

#»ñÈ¡Òì³£ÐÅÏ¢#£¨try:...except:..GetExceptionInfo()£©
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def GetExceptionInfo():
    import traceback
    return traceback.format_exc()


#Ö´ÐÐcmdÖ¸Áî
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def RunCmd(curCmd):
    pipe = subprocess.Popen(['cmd', ""], shell = False,
                                 stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
    pipe.stdin.write('%s\n'%curCmd)
    pipe.stdin.close()
    retStr = pipe.stdout.read()
    retStr += pipe.stderr.read()
    print retStr
    return retStr


#È¡µÃ´úÂëÖÐÕæʵµÄ×Ö·û´®£¨Èç²ÎÊýsrcStrÊÇ'\n',»áµÃµ½»Ø³µ·û£©
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def GetCodeStr(srcStr):
    desStr = srcStr.replace("'", "\\'")
    cmd = "desStr='" + desStr + "'"
    exec(cmd)
    return desStr 


#pythonдÎļþ:
#    f = file('c:\\fuck.txt', 'a')
#    f.write(mapObsData)

#µÈ´ýÊäÈë: raw_input()

#´´½¨Socket
#s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
#s.bind(('192.168.0.81', 6112))
#s.listen(1)

#»ñµÃ×ÓĿ¼:
#os.path.abspath

#µÈ´ýÊäÈë:
#raw_input()

#µÃµ½±¾Ä¿Â¼:
#os.getcwd()

#µÃµ½²ÎÊý:
#os.sys.argv

#µÃµ½python·¾¶
#os.sys.executable

#ÔËÐÐÍⲿÎļþ/½áÊøÍⲿÎļþ
#processID = os.spawnl(os.P_NOWAIT, pythonPath, '-p', os.path.join(curPath, 'test.py'))
#win32api.TerminateProcess(processID, 0)


#pythonµÄ¶ÁÈ¡/дÈë¿â

#------------------------¶ÁÈ¡ 
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReadBYTE(buf, pos):
    curValue = struct.unpack_from('B', buf, pos)
    pos += 1
    return curValue[0], pos

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReadWORD(buf, pos):
    curValue = struct.unpack_from('H', buf, pos)
    pos += 2  
    return curValue[0], pos

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReadDWORD(buf, pos):
    curValue = struct.unpack_from('I', buf, pos)  
    pos += 4
    return curValue[0], pos

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReadFloat(buf, pos):
    curValue = struct.unpack_from('f', buf, pos)  
    pos += 4
    return curValue[0], pos

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReadDouble(buf, pos):
    curValue = struct.unpack_from('d', buf, pos)  
    pos += 8
    return curValue[0], pos

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReadString(buf, pos, _len):
    curValue = struct.unpack_from('%ds'%_len, buf, pos)
    pos += _len  
    return curValue[0], pos


#----------------------дÈë
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def Pack(sign, value):
    
    if value < 0:
        sign = sign.lower()
    else:
        sign = sign.upper()
    
    return struct.pack(sign, value)
        
        
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def WriteBYTE(buf, value):
    buf += Pack('B', value)
    return buf


## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def WriteWORD(buf, value):
    buf += Pack('H', value)
    return buf

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def WriteDWORD(buf, value):
    buf += Pack('I', value)
    return buf

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def WriteFloat(buf, value):
    buf += struct.pack('f', value)
    return buf

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def WriteDouble(buf, value):
    buf += struct.pack('d', value)
    return buf

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def WriteString(buf, len, value):
    buf += struct.pack('%ds'%len, value)
    return buf

## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def GetDistance(srcX, srcY, destX, destY):
    return math.sqrt(pow(srcX - destX, 2) + pow(srcY - destY, 2))
    
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def MovePos(srcX, srcY, destX, destY, curMoveDist):
    if curMoveDist == 0:
        return  srcX, srcY
    
    totalDist = GetDistance(srcX, srcY, destX, destY)
    if totalDist == 0:
        return  srcX, srcY
    
    resultX = curMoveDist / float(totalDist) * (destX - srcX) + srcX
    resultY = curMoveDist / float(totalDist) * (destY - srcY) + srcY
    return resultX, resultY 
    

##²âÊÔ´úÂë:
#strs = 'ÃÀÏãÊÇÖí'
#buf = ''
#buf = WriteString(buf, len(strs), strs)
#value, pos = ReadString(buf, 0, len(strs))
#print value

#»ñµÃµ±Ç°ÏµÍ³Ê±¼ä
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def GetCurrentDataTimeStr():
    curTime = datetime.datetime.today()
    curTimeStr = str(curTime)
    curTimeStr = curTimeStr.split(".")[0]
    return curTimeStr

#»ñµÃϵͳʱ¼ä(²ÎÊý -> ʱ¼äÁбí)
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def GetDateTimeByStr(timeStr):
    timeStr = timeStr.split(".")[0]
    return  datetime.datetime.strptime(timeStr, "%Y-%m-%d %H:%M:%S")
    
    
    
#×Ö·û´®×ª»»ÎªÕûÐÍ, Èç¹û²»ÄÜת»», ·µ»ØĬÈÏÖµ
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ToIntDef(input, defValue = 0):
    try:
        result = int(input)
        return result
    except ValueError:
        return defValue
    
#16½øÖÆÑÕɫת»»
#"#FFFFFF"--"255,255,255"
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def HcToSc(h):
    h="0x"+h[1:7]
    red=string.atoi(h[:2]+h[2:4], base=16)
    green=string.atoi(h[:2]+h[4:6], base=16)
    blue=string.atoi(h[:2]+h[6:8], base=16)
    cStr=str(red)+","+str(green)+","+str(blue)
    return cStr

#"255,255,255"--"#FFFFFF"
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ScToHc(s):
    red=hex(string.atoi(s.split(",")[0]))[2:]
    green=hex(string.atoi(s.split(",")[1]))[2:]
    blue=hex(string.atoi(s.split(",")[2]))[2:]
    hStr="#"+str(red+green+blue)
    return hStr

#16½øÖÆת»»
#"0xFFFFFF"--"255,255,255"
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def HdToSd(h):
    red=string.atoi(h[0:2]+h[2:4], base=16)
    green=string.atoi(h[0:2]+h[4:6], base=16)
    blue=string.atoi(h[0:2]+h[6:8], base=16)
    cStr=str(red)+","+str(green)+","+str(blue)
    return cStr

#"255,255,255"--"0xFFFFFF"
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def SdToHd(s):
    red=hex(string.atoi(s.split(",")[0]))[2:]
    green=hex(string.atoi(s.split(",")[1]))[2:]
    blue=hex(string.atoi(s.split(",")[2]))[2:]
    hStr="0x"+str(red+green+blue)
    return hStr

#Ìáʾ³ýÁã´íÎóµÄEVAL
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def SafeEval(value):
    try:
        return eval(value)
    except ZeroDivisionError:
        return "Division is Zero"

##Éú³ÉÖ¸¶¨Îļþ£¨Èçpar£ºr'E:\¿ª·¢°æ±¾\Data\logo\formName1.log'£©
#def MakeAppointFile(par):
#    dir = os.path.dirname(par)  # »ñµÃÎļþĿ¼
#    os.makedirs(dir)  # ´´½¨¶à¼¶Ä¿Â¼
#    file = open(os.path.basename(par),'w')
#    file.close()
#
##ÔÚÖ¸¶¨Ä¿Â¼¸ù¾Ýµ±Ç°Ê±¼äÉú³ÉÐÂĿ¼£¨Èçpar£ºr'E:\¿ª·¢°æ±¾\Data\logo'£©
#def MakeCurTimeDir(par):
#    if not os.path.exists(par):  # ´«½øÀ´µÄĿ¼²»´æÔÚ
#        return
#    path=par+'\\'+str(datetime.datetime.today()).split()[0]
#    if not os.path.exists(path):  # Îļþ¼ÐÊÇ·ñ´æÔÚ£¬²»´æÔÚÔò´´½¨
#        os.mkdir(path)  # ´´½¨Îļþ¼Ð
        
#Éú³ÉÖ¸¶¨Ä¿Â¼£¨Èçpar£ºr'E:\¿ª·¢°æ±¾\Data\logo'£©
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def MakeAppointDir(par):
    if not isinstance(par,str):
        return
    pathList=par.split('\\')
    path=pathList[0]
    for i in range(1,len(pathList)):
        path+='\\'+pathList[i]
        if not os.path.exists(path):  # Îļþ¼ÐÊÇ·ñ´æÔÚ£¬²»´æÔÚÔò´´½¨
            os.mkdir(path)  # ´´½¨Îļþ¼Ð
                
#Éú³ÉÖ¸¶¨Îļþ£¨Èçpar£ºr'E:\¿ª·¢°æ±¾\Data\logo\formName1.log'£©
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def MakeAppointFile(par):
    if not isinstance(par,str):
        return
    pathList=par.split('\\')
    path=pathList[0]
    for i in range(1,len(pathList)):
        path+='\\'+pathList[i]
        if i==len(pathList)-1:
            file=open(path,'w')
            file.close()
        else:
            if not os.path.exists(path):  # Îļþ¼ÐÊÇ·ñ´æÔÚ£¬²»´æÔÚÔò´´½¨
                os.mkdir(path)  # ´´½¨Îļþ¼Ð

#ÔÚÖ¸¶¨Ä¿Â¼¸ù¾Ýµ±Ç°Ê±¼äÉú³ÉÐÂĿ¼£¨Èçpar£ºr'E:\¿ª·¢°æ±¾\Data\logo'£©
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def MakeCurTimeDir(par):
    if not os.path.exists(par):  # ´«½øÀ´µÄĿ¼²»´æÔÚ
        return
    path=par+'\\'+str(datetime.datetime.today()).split()[0]
    if not os.path.exists(path):  # Îļþ¼ÐÊÇ·ñ´æÔÚ£¬²»´æÔÚÔò´´½¨
        os.mkdir(path)  # ´´½¨Îļþ¼Ð


#µÃµ½Ìæ»»ºóµÄ×Ö·û´®£¨²ÎÊý£ºstringÊÇÐèÒªÌæ»»µÄ×Ö·û´®£»varlistΪ²»¶¨²Î£¬ÎªÌæ»»ÄÚÈÝ£©
#ÈçGetReplaceString('str%s%s','str1','str2','str3','str4'),return½á¹ûΪ'strstr1str2'
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def GetReplaceString(string,*varlist):
    if '%' not in string:
        return string
    repalceCount = len(varlist)  # Ìæ»»´ÎÊý
    newStr = string
    if '%%' in string:
        newStr = string.replace('%%','')  # È¥³ý×Ö·û´®strÄÚµÄ'%%'
    needReplaceCount = newStr.count('%')  # ×Ö·û´®newStrÄÚµÄ'%'¸öÊý,¼´ÐèÒªÌæ»»µÄ´ÎÊý
    if repalceCount < needReplaceCount:
        tempList = list(varlist)
        for i in range(needReplaceCount-repalceCount):
            tempList.append(0)
        replaceTuple= tuple(tempList)
        #¸æËßµ÷ÓÃÕߣ¬²ÎÊý´«ÉÙÁË
        return 'func:GetReplaceString();error:the parameter lack'
#        return string%replaceTuple
        
    replaceTuple = tuple(varlist[:needReplaceCount])
    return string%replaceTuple


#½«unicode±àÂëת»»³ÉÖÐÎÄ×Ö·û(²ÎÊý£º"#19968"-"#40869"Ö®¼ä)
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def UnicodeStrToGBKStr(U_STR):#ÈçÊäÈë"#23435",»ñµÃ·µ»ØÖµ"ËÎ"
    import re
    import ShareDefine
    RegularExpression="#[0-9]+"
    if not re.match(RegularExpression,U_STR):
        return U_STR
    UnicodeNum=int(U_STR[1:])
    CODEC = ShareDefine.Def_Game_Character_Encoding
    try:
        unicode_string=eval("u'\u%s'"%((hex(UnicodeNum))[2:]))
        GBK_str=unicode_string.encode(CODEC)
    except:
        return U_STR
    return GBK_str
   
   
#ÓÃÖ¸¶¨×Ö·ûdesSignÌæ»»·±Ìå×Ö·û´®srcStrµÄÖ¸¶¨µ¥×Ö½Ú×Ö·ûsign
## 
#  @param ²ÎÊý
#  @return ·µ»ØÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷£º
def ReplaceBig5AppointSign(srcStr,sign,desSign):
    
    isContinue = False
    desStr = ''
    
    for i in range( len(srcStr) ):
            
        if isContinue:
            #Èç¹û×îºóÁ½¸ö×Ö½Ú¸ÕºÃÊÇÒ»¸ö·±Ìå×Ö£¬Ôòµ¹ÊýµÚ¶þ¸ö×Ö½Úʱ»áÅж¨£¬×îºóÒ»¸ö×Ö½ÚÔòÔÚ´ËÌø¹ý
            isContinue = False
            continue
        
        #Òѵ½×Ö·û´®×îºóÒ»¸ö×Ö½Ú£¬²Ù×÷ÍêÌø³öÑ­»·
        if i == len(srcStr)-1:
            
            if srcStr[i] == sign:
                #Ìæ»»
                desStr = desStr + desSign
            else:
                desStr = desStr + srcStr[i]
            
            break  # Ìø³öÑ­»·
        
        if 129 <= ord(srcStr[i]) <= 254:  # ÅжÏÊÇ·ñÔÚBig5¸ßλ×Ö½Ú·¶Î§ÄÚ
            
            if 64 <= ord(srcStr[i+1]) <= 126 or 161 <= ord(srcStr[i+1]) <= 254:  # ÅжÏÊÇ·ñBig5µÍλ×Ö½Ú·¶Î§ÄÚ
                isContinue = True  # Ï´ÎÅжϸß×Ö½Úʱ£¬¿ÉÌø¹ýÒ»´ÎÑ­»·
                desStr = desStr + srcStr[i:i+2]
            else:
                #²»ÔÚBig5µÍλ×Ö½Ú·¶Î§ÄÚ
                if srcStr[i] == sign:
                    #Ìæ»»
                    desStr = desStr + desSign
                else:
                    desStr = desStr + srcStr[i]
        else:
            #²»ÔÚBig5¸ßλ×Ö½Ú·¶Î§ÄÚ
            if srcStr[i] == sign:
                #Ìæ»»
                desStr = desStr + desSign
            else:
                desStr = desStr + srcStr[i]
        
    return desStr


## »ñÈ¡×Ö·û´®µÄCRC
#  @param msg ×Ö·û´®
#  @return CRC
def GetStrCrc(msg):
    crc = binascii.crc32(msg)
    return crc & 0x7fffffff


## ÐÔÄÜ·ÖÎö×°ÊÎÆ÷º¯Êý
#  @param func
#  @return
## @remarks ½âÎöµÄÎļþ´æ·ÅÔÚ\MapServer\MapServerData
def DoCProfile(func):
    
    def Profiled_func(*args, **kwargs):
        import cProfile
        profile = cProfile.Profile()
        try:
            profile.enable()
            funcName = func.__name__
            result = func(*args, **kwargs)
            profile.dump_stats(funcName)
            profile.disable()
            return result
        except BaseException:
            GameWorld.ErrLog("DoCProfile Err!")
        
        return
    
    return Profiled_func

# 1.ʹÓ÷½·¨ÔÚ²âÊÔº¯ÊýÇ°¼Ó @CommFunc.DoCProfile  ¼´¿É
# 2.½âÎö·ÖÎöÎļþº¯Êý
#def ProfStats():
#    import pstats
#    p = pstats.Stats('½âÎöºóµÄÎļþÃûÒ»°ãÊÇ´ý·ÖÎöµÄº¯ÊýÃû')
#    p.strip_dirs().sort_stats('cumulative', 'time', 'pcalls').print_stats()


## »ñÈ¡½Ø¶ÏºóµÄ×Ö·û´®
#  @param srcStr Ô´×Ö·û´®
#  @param maxLen ×î´ó³¤¶È
#  @return
def GetStrCutoff(srcStr, maxLen):
    import ShareDefine
    if len(srcStr) <= maxLen:
        return srcStr
    tempComment = srcStr[:maxLen]
    # Ò»°ã×î¶àÁ½´Î¼´¿É
    for i in xrange(10):
        try:
            return tempComment[:maxLen-i].decode(ShareDefine.Def_Game_Character_Encoding).encode(ShareDefine.Def_Game_Character_Encoding)
        except:
            pass
        
    return ""

def CoinToYuan(orderCoin, rate=1):
    '''coinת»¯ÎªÔª
    '''
    yuan = orderCoin / float(rate)
    if str(yuan).endswith(".0"):
        return int(yuan)
    return yuan

def RMBToCoin(floatRMB, rate=100):
    ''' ԪתΪcoin£¬Í³Ò»º¯Êý£¬·½±ãÐ޸ļ°ËÑË÷
    @param floatRMB: µ¥Î»Ôª£¬float ÀàÐÍ£¬Ö§³Ö RMB »ò ÃÀÔª
    @param rate: ת»¯±ÈÀý£¬Ô½ÄÏ°æ±¾Åä±í¼°coin¾ùʹÓÃÔ½Ä϶ÜÔ­Öµ£¬¼´±ÈÀýΪ1:1£¬¹ÊĬÈÏÖµ¸Ä1
    @return: ת»¯ÎªcoinÊýÖµ
    '''
    # ÓÉÓÚfloat»áÓв»¾«È·µÄÏÖÏó³öÏÖxxx.9999999»òxxx.0000000000001µÄÎÊÌ⣬ËùÒÔÕâÀï¼ÆËã³öµÄ½á¹ûÏòÉÏÈ¡Õû
    return int(math.ceil(round(floatRMB * rate)))

#64½øÖÆ·ûºÅ£¬Ç°¶ËÓÃ*ºÅ²¹¿Õ
symbols64 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/'
def Convert10To64(number):
    """½«Ê®½øÖÆÊýת»»Îª64½øÖÆ"""
    if number < 0:
        number = abs(number)
    result = ''
    while number > 0:
        result = symbols64[number % 64] + result
        number //= 64
    return result or '0'

def Convert64To10(number64):
    """½«64½øÖÆÊýת»»ÎªÊ®½øÖÆ"""
    value = 0
    for digit in number64:
        value = value * 64 + symbols64.index(digit)
    return value

def ParseSetting(playerSetting, index, cLen=1):
    """½âÎöÍæ¼ÒÉèÖô洢"""
    s = playerSetting[index:index+cLen]
    s = s.replace("*", "") # Ç°¶Ë*´ú±í¿Õ
    if not s:
        return 0
    return Convert64To10(s)

def ParseSetting_AutoSkillList(playerSetting, defaultSkillList):
    '''½âÎöÍæ¼ÒÉèÖà  - ×Ô¶¯Êͷż¼ÄÜ˳ÐòÁбí
    @param playerSetting: Íæ¼ÒÉèÖñ£´æ´®
    @param skillOrderList: ¼¼ÄÜĬÈÏ˳ÐòÁбí
    '''
    playerSkillSetList = []
    SkillMatchPage = ParseSetting(playerSetting, 30, 1)
    fromIndex = 32 + SkillMatchPage * 15
    indexNum = 0
    for index in range(fromIndex, fromIndex + 15):
        skillIndex = indexNum
        v = ParseSetting(playerSetting, index, 1)
        if v:
            skillIndex = v - 1
        
        if skillIndex >= len(defaultSkillList):
            break
        skillID = defaultSkillList[skillIndex]
        playerSkillSetList.append(skillID)
        indexNum += 1
    return playerSkillSetList