172 lines
6 KiB
Python
172 lines
6 KiB
Python
from CatalogSurfaceItem import *
|
|
FTTextureName = 0
|
|
FTColor = 1
|
|
FTBasePrice = 2
|
|
FlooringTypes = {1000: ('phase_5.5/maps/floor_wood_neutral.jpg', CTBasicWoodColorOnWhite, 150),
|
|
1010: ('phase_5.5/maps/flooring_carpetA_neutral.jpg', CTFlatColorDark, 150),
|
|
1020: ('phase_4/maps/flooring_tile_neutral.jpg', CTFlatColorDark, 150),
|
|
1030: ('phase_5.5/maps/flooring_tileB2.jpg', None, 150),
|
|
1040: ('phase_4/maps/grass.jpg', None, 150),
|
|
1050: ('phase_4/maps/floor_tile_brick_diagonal2.jpg', None, 150),
|
|
1060: ('phase_4/maps/floor_tile_brick_diagonal.jpg', None, 150),
|
|
1070: ('phase_4/maps/plazz_tile.jpg', None, 150),
|
|
1080: ('phase_4/maps/sidewalk.jpg', CTFlatColorDark, 150),
|
|
1090: ('phase_3.5/maps/boardwalk_floor.jpg', None, 150),
|
|
1100: ('phase_3.5/maps/dustroad.jpg', None, 150),
|
|
1110: ('phase_5.5/maps/floor_woodtile_neutral.jpg', CTBasicWoodColorOnWhite, 150),
|
|
1120: ('phase_5.5/maps/floor_tile_neutral.jpg', CTBasicWoodColorOnWhite + CTFlatColorDark, 150),
|
|
1130: ('phase_5.5/maps/floor_tile_honeycomb_neutral.jpg', CTBasicWoodColorOnWhite, 150),
|
|
1140: ('phase_5.5/maps/UWwaterFloor1.jpg', None, 150),
|
|
1150: ('phase_5.5/maps/UWtileFloor4.jpg', None, 150),
|
|
1160: ('phase_5.5/maps/UWtileFloor3.jpg', None, 150),
|
|
1170: ('phase_5.5/maps/UWtileFloor2.jpg', None, 150),
|
|
1180: ('phase_5.5/maps/UWtileFloor1.jpg', None, 150),
|
|
1190: ('phase_5.5/maps/UWsandyFloor1.jpg', None, 150),
|
|
10000: ('phase_5.5/maps/floor_icecube.jpg', CTWhite, 225),
|
|
10010: ('phase_5.5/maps/floor_snow.jpg', CTWhite, 225),
|
|
11000: ('phase_5.5/maps/StPatsFloor1.jpg', CTWhite, 225),
|
|
11010: ('phase_5.5/maps/StPatsFloor2.jpg', CTWhite, 225)}
|
|
|
|
class CatalogFlooringItem(CatalogSurfaceItem):
|
|
|
|
def makeNewItem(self, patternIndex, colorIndex = None):
|
|
self.patternIndex = patternIndex
|
|
self.colorIndex = colorIndex
|
|
CatalogSurfaceItem.makeNewItem(self)
|
|
|
|
def needsCustomize(self):
|
|
return self.colorIndex == None
|
|
|
|
def getTypeName(self):
|
|
return TTLocalizer.SurfaceNames[STFlooring]
|
|
|
|
def getName(self):
|
|
name = TTLocalizer.FlooringNames.get(self.patternIndex)
|
|
if name:
|
|
return name
|
|
return self.getTypeName()
|
|
|
|
def getSurfaceType(self):
|
|
return STFlooring
|
|
|
|
def getPicture(self, avatar):
|
|
frame = self.makeFrame()
|
|
sample = loader.loadModel('phase_5.5/models/estate/wallpaper_sample')
|
|
a = sample.find('**/a')
|
|
b = sample.find('**/b')
|
|
c = sample.find('**/c')
|
|
a.setTexture(self.loadTexture(), 1)
|
|
a.setColorScale(*self.getColor())
|
|
b.setTexture(self.loadTexture(), 1)
|
|
b.setColorScale(*self.getColor())
|
|
c.setTexture(self.loadTexture(), 1)
|
|
c.setColorScale(*self.getColor())
|
|
sample.reparentTo(frame)
|
|
self.hasPicture = True
|
|
return (frame, None)
|
|
|
|
def output(self, store = -1):
|
|
return 'CatalogFlooringItem(%s, %s%s)' % (self.patternIndex, self.colorIndex, self.formatOptionalData(store))
|
|
|
|
def getFilename(self):
|
|
return FlooringTypes[self.patternIndex][FTTextureName]
|
|
|
|
def compareTo(self, other):
|
|
if self.patternIndex != other.patternIndex:
|
|
return self.patternIndex - other.patternIndex
|
|
return 0
|
|
|
|
def getHashContents(self):
|
|
return self.patternIndex
|
|
|
|
def getBasePrice(self):
|
|
return FlooringTypes[self.patternIndex][FTBasePrice]
|
|
|
|
def loadTexture(self):
|
|
from pandac.PandaModules import Texture
|
|
filename = FlooringTypes[self.patternIndex][FTTextureName]
|
|
texture = loader.loadTexture(filename)
|
|
texture.setMinfilter(Texture.FTLinearMipmapLinear)
|
|
texture.setMagfilter(Texture.FTLinear)
|
|
return texture
|
|
|
|
def getColor(self):
|
|
if self.colorIndex == None:
|
|
colorIndex = 0
|
|
else:
|
|
colorIndex = self.colorIndex
|
|
colors = FlooringTypes[self.patternIndex][FTColor]
|
|
if colors:
|
|
if colorIndex < len(colors):
|
|
return colors[colorIndex]
|
|
else:
|
|
print 'Warning: colorIndex not in colors. Returning white.'
|
|
return CT_WHITE
|
|
else:
|
|
return CT_WHITE
|
|
return
|
|
|
|
def decodeDatagram(self, di, versionNumber, store):
|
|
CatalogAtticItem.CatalogAtticItem.decodeDatagram(self, di, versionNumber, store)
|
|
if versionNumber < 3:
|
|
self.patternIndex = di.getUint8()
|
|
else:
|
|
self.patternIndex = di.getUint16()
|
|
if versionNumber < 4 or store & CatalogItem.Customization:
|
|
self.colorIndex = di.getUint8()
|
|
else:
|
|
self.colorIndex = 0
|
|
wtype = FlooringTypes[self.patternIndex]
|
|
return
|
|
|
|
def encodeDatagram(self, dg, store):
|
|
CatalogAtticItem.CatalogAtticItem.encodeDatagram(self, dg, store)
|
|
dg.addUint16(self.patternIndex)
|
|
if store & CatalogItem.Customization:
|
|
dg.addUint8(self.colorIndex)
|
|
|
|
|
|
def getFloorings(*indexList):
|
|
list = []
|
|
for index in indexList:
|
|
list.append(CatalogFlooringItem(index))
|
|
|
|
return list
|
|
|
|
|
|
def getAllFloorings(*indexList):
|
|
list = []
|
|
for index in indexList:
|
|
colors = FlooringTypes[index][FTColor]
|
|
if colors:
|
|
for n in range(len(colors)):
|
|
list.append(CatalogFlooringItem(index, n))
|
|
|
|
else:
|
|
list.append(CatalogFlooringItem(index, 0))
|
|
|
|
return list
|
|
|
|
|
|
def getFlooringRange(fromIndex, toIndex, *otherRanges):
|
|
list = []
|
|
froms = [fromIndex]
|
|
tos = [toIndex]
|
|
i = 0
|
|
while i < len(otherRanges):
|
|
froms.append(otherRanges[i])
|
|
tos.append(otherRanges[i + 1])
|
|
i += 2
|
|
|
|
for patternIndex in FlooringTypes.keys():
|
|
for fromIndex, toIndex in zip(froms, tos):
|
|
if patternIndex >= fromIndex and patternIndex <= toIndex:
|
|
colors = FlooringTypes[patternIndex][FTColor]
|
|
if colors:
|
|
for n in range(len(colors)):
|
|
list.append(CatalogFlooringItem(patternIndex, n))
|
|
|
|
else:
|
|
list.append(CatalogFlooringItem(patternIndex, 0))
|
|
|
|
return list
|