#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#×÷Õߣºifo
|
# Change Log: ÐÞ¸ÄÀà¼Ü¹¹ 2011-9-9 Alee
|
|
import string
|
import CommFunc
|
import Log4P
|
import binascii
|
import os
|
import logging
|
import IPY_AStar
|
from ConfigurationReader import ConfigIniReader
|
|
DUMP_MAPDATA = False
|
|
|
class tagFLCOMMONHEADERS:
|
|
Signature = 0 # (DWORD Signature ) // ±êÖ¾
|
Numbering = 0 # (DWORD Numbering ) // 񅧏
|
OSVersion = 0 # (DWORD OSVersion ) // °æ±¾
|
Copyright = "" # (char Copyright[64] ) // °æȨÉùÃ÷
|
CreationTime = 0 # (double CreationTime ) // ´´½¨Ê±¼ä
|
LastWriteTime = 0 # (double LastWriteTime ) // ×îºóÒ»´ÎÐÞ¸Äʱ¼ä
|
BuildVersion = 0 # (DWORD BuildVersion ) // ¸Äд´ÎÊý
|
Ressource = 0 # (DWORD Ressource ) // ×ÊÔ´ÀàÐÍ
|
ResVersion = 0 # (DWORD ResVersion ) // ×ÊÔ´°æ±¾
|
AddonsResCount = 0 # (DWORD AddonsResCount ) // ¸½¼Ó×ÊÔ´ÊýÁ¿
|
Reserved = "" # (char Reserved[20] ) // ¶ÔÆëÖÁ 128 byte(s)
|
|
def __init__(self):
|
self.Clear()
|
|
return
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
|
self.Signature, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Numbering, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.OSVersion, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Copyright, _pos = CommFunc.ReadString(_lpData, _pos, 64)
|
self.CreationTime, _pos = CommFunc.ReadDouble(_lpData, _pos)
|
self.LastWriteTime, _pos = CommFunc.ReadDouble(_lpData, _pos)
|
self.BuildVersion, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Ressource, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.ResVersion, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.AddonsResCount, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Reserved, _pos = CommFunc.ReadString(_lpData, _pos, 20)
|
|
if _Len != 0 and _pos != _Len:
|
Log4P.Warn("Error in tagFLCOMMONHEADERS : %s "% binascii.b2a_hex(_lpData))
|
return 0
|
return _pos
|
|
def Clear(self):
|
self.Signature = 0
|
self.Numbering = 0
|
self.OSVersion = 0
|
self.Copyright = ""
|
self.CreationTime = 0
|
self.LastWriteTime = 0
|
self.BuildVersion = 0
|
self.Ressource = 0
|
self.ResVersion = 0
|
self.AddonsResCount = 0
|
self.Reserved = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 4
|
length += 4
|
length += 4
|
length += 64
|
length += 8
|
length += 8
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 20
|
return length;
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteDWORD(data, self.Signature)
|
data = CommFunc.WriteDWORD(data, self.Numbering)
|
data = CommFunc.WriteDWORD(data, self.OSVersion)
|
data = CommFunc.WriteString(data, 64, self.Copyright)
|
data = CommFunc.WriteDouble(data, self.CreationTime)
|
data = CommFunc.WriteDouble(data, self.LastWriteTime)
|
data = CommFunc.WriteDWORD(data, self.BuildVersion)
|
data = CommFunc.WriteDWORD(data, self.Ressource)
|
data = CommFunc.WriteDWORD(data, self.ResVersion)
|
data = CommFunc.WriteDWORD(data, self.AddonsResCount)
|
data = CommFunc.WriteString(data, 20, self.Reserved)
|
return data
|
|
def OutputString(self):
|
DumpString = ''':
|
Signature:%d,
|
Numbering:%d,
|
OSVersion:%d,
|
Copyright:%s,
|
CreationTime:%d,
|
LastWriteTime:%d,
|
BuildVersion:%d,
|
Ressource:%d,
|
ResVersion:%d,
|
AddonsResCount:%d,
|
Reserved:%s
|
'''\
|
%(
|
self.Signature,
|
self.Numbering,
|
self.OSVersion,
|
self.Copyright,
|
self.CreationTime,
|
self.LastWriteTime,
|
self.BuildVersion,
|
self.Ressource,
|
self.ResVersion,
|
self.AddonsResCount,
|
self.Reserved
|
)
|
|
return DumpString
|
|
|
#ÕÏ°±íÐÅÏ¢
|
class tagMapObs:
|
Width = 0 # (DWORD Width )
|
Height = 0 # (DWORD Height )
|
def __init__(self):
|
self.Clear()
|
|
return
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
|
self.Width, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Height, _pos = CommFunc.ReadDWORD(_lpData, _pos)
|
|
if _Len != 0 and _pos != _Len:
|
Log4P.Warn("Error in tagMapObs : %s "% binascii.b2a_hex(_lpData))
|
return 0
|
return _pos
|
|
def Clear(self):
|
self.Width = 0
|
self.Height = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 4
|
length += 4
|
return length;
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteDWORD(data, self.Width)
|
data = CommFunc.WriteDWORD(data, self.Height)
|
return data
|
|
def OutputString(self):
|
DumpString = ''':
|
Width:%d,
|
Height:%d
|
'''\
|
%(
|
self.Width,
|
self.Height
|
)
|
|
return DumpString
|
|
|
class MapNameInfoType:
|
def __init__(self):
|
self.MapFileName = ''
|
self.MapID = 0
|
self.MapName = ''
|
|
def ReadFromList(self, curList):
|
self.MapFileName = curList[0]
|
self.MapID = CommFunc.ToIntDef(curList[1])
|
self.MapName = curList[2]
|
return
|
|
def __str__(self):
|
DumpString = "MapFileName:%s," \
|
"MapID:%d," \
|
"MapName:%s" \
|
%( \
|
self.MapFileName, \
|
self.MapID, \
|
self.MapName \
|
)
|
|
return DumpString
|
|
|
class MapData():
|
def __init__(self, mapID):
|
self.aStarPath = IPY_AStar.IPY_AStar()
|
self.mapDataHead = tagFLCOMMONHEADERS()
|
self.mapObs = tagMapObs()
|
self.mapID = mapID
|
|
def GetAStarPath(self):
|
return self.aStarPath
|
|
def ReadFromFile(self, filepath ):
|
f = open(filepath,'rb')
|
buf = f.read()
|
pos = self.mapDataHead.ReadData(buf)
|
pos = self.mapObs.ReadData(buf, pos)
|
|
obsPos = pos
|
self.DataList=[]#mapdatalist
|
for j in range(self.mapObs.Height):
|
self.DataList.append([])
|
for i in range(self.mapObs.Width):
|
curValue, pos = CommFunc.ReadBYTE(buf, pos)
|
self.DataList[j].append(curValue)
|
|
mapObsData, pos = CommFunc.ReadString(buf, obsPos, len(buf) - obsPos)
|
|
#ÉèÖÃÕÏ°±í
|
self.aStarPath.SetMap(mapObsData, self.mapObs.Width, self.mapObs.Height)
|
|
|
|
#Check Is Block
|
def IsBlockPoint( self,posX, posY ):
|
data = self.GetMapFilePointValue( posX, posY )
|
if not data:
|
return True
|
|
return 0 != data
|
|
def __str__(self):
|
data="MapDataDump:\n MapID:%d Width:%d Height:%d\n" \
|
% ( self.mapID, self.mapObs.Width, self.mapObs.Height )
|
for y in range(len(self.DataList)):
|
for x in range(len(self.DataList[y])):
|
data += str(self.DataList[y][x])
|
data+="\n"
|
|
return data
|
|
#return mapPointValue
|
def GetMapFilePointValue(self, posX, posY):
|
if posY >= self.mapObs.Height \
|
or posX >= self.mapObs.Width:
|
logging.warning( "Out of Range in map:%d pos:(%d,%d)" % ( self.mapID, posX, posY ))
|
return None
|
|
return self.DataList[posY][posX]
|
|
|
|
class MapDataReader:
|
def __init__(self, PyBaseRoot, mapsPath, postFix ):
|
self.mapNameInfo = {}
|
self.mapDataDict = {}
|
self.mapsPath = PyBaseRoot + mapsPath
|
self.postFix = postFix
|
|
self.ReadMapIDTxt()
|
self.ReadAllMapData()
|
|
def ReadMapIDTxt(self ):
|
mapIdTxtPath = os.path.join(self.mapsPath, 'MapID.txt')
|
logging.debug( "MapID.txt path:%s" % mapIdTxtPath )
|
f = file(mapIdTxtPath)
|
mapTxt = f.readlines()
|
for line in mapTxt:
|
curList = line.split('\t')
|
infoType = MapNameInfoType()
|
infoType.ReadFromList(curList)
|
self.mapNameInfo[infoType.MapID] = infoType
|
logging.debug( "Dump....%s" % str(infoType) )
|
|
def ReadAllMapData(self):
|
for mapID in self.mapNameInfo.keys():
|
self.mapDataDict[mapID] = self.__ReadMapData( mapID )
|
|
def __ReadMapData( self, mapID ):
|
curMapPath = os.path.join(self.mapsPath, self.mapNameInfo[mapID].MapFileName + self.postFix)
|
logging.debug( "MapFileReader: reading [%d]%s ..." % ( mapID, curMapPath ) )
|
data = MapData( mapID )
|
data.ReadFromFile( curMapPath )
|
return data
|
|
def GetMapDataByID(self,mapID):
|
return self.mapDataDict[mapID]
|
|
def GetAllMapData(self):
|
return self.mapDataDict
|
|
#Check Is Block
|
def IsBlockPoint(self,mapID,posX,posY):
|
mapData = self.GetMapDataByID(mapID)
|
if not mapList:
|
logging.warning( "NO DATA for map %d" % mapID )
|
return True
|
return mapData.IsBlockPoint( posX, posY )
|
|
|
def __str__(self):
|
data = "MapPath:%s\n" % self.mapsPath
|
data += "MapFilePostFix:%s\n" % self.postFix
|
data += "MapNameInfo:\n"
|
for mapID in self.mapNameInfo.keys():
|
data += "%d:%s\n" %( mapID, str(self.mapNameInfo[mapID]) )
|
for mapID in self.mapDataDict.keys():
|
data += "%d:%s\n" % ( mapID, str(self.mapDataDict[mapID]) )
|
return data
|
|
|
|
__gRobotsMapData = None
|
|
def ReadMapData( PyBaseRoot,):
|
global __gRobotsMapData
|
if not __gRobotsMapData:
|
__gRobotsMapData = MapDataReader( PyBaseRoot, ConfigIniReader.GetConfig().GetMapFilePath(),\
|
ConfigIniReader.GetConfig().GetMapFilePostFix())
|
if DUMP_MAPDATA:
|
logging.debug( "%s", str(__gRobotsMapData) )
|
|
|
def GetMapData():
|
global __gRobotsMapData
|
return __gRobotsMapData
|
|
|
|
if __name__ == "__main__":
|
pass
|
|
|
|
|
|
|
